// Generated by tools/generate-css-inputs.mbtx.

///|
#deprecated("Use BoxSizeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BoxSizeInputFallbacks for Array[@values.Length]

///|
pub impl BoxSizeInputFallbacks for Array[@values.Length] with fn fallback_inputs(
  self,
) {
  self.map(value => BoxSizeInput::property_input(value))
}

///|
#deprecated("Use LengthFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl LengthInputFallbacks for Array[@values.Length]

///|
pub impl LengthInputFallbacks for Array[@values.Length] with fn fallback_inputs(
  self,
) {
  self.map(value => LengthInput::length_input(value))
}

///|
#deprecated("Use DisplayFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl DisplayInputFallbacks for Array[@properties.Display]

///|
pub impl DisplayInputFallbacks for Array[@properties.Display] with fn fallback_inputs(
  self,
) {
  self.map(value => DisplayInput::property_input(value))
}

///|
#deprecated("Use PlaceItemsFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PlaceItemsInputFallbacks for Array[@properties.PlaceItems]

///|
pub impl PlaceItemsInputFallbacks for Array[@properties.PlaceItems] with fn fallback_inputs(
  self,
) {
  self.map(value => PlaceItemsInput::property_input(value))
}

///|
#deprecated("Use OverflowFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverflowInputFallbacks for Array[@properties.Overflow]

///|
pub impl OverflowInputFallbacks for Array[@properties.Overflow] with fn fallback_inputs(
  self,
) {
  self.map(value => OverflowInput::property_input(value))
}

///|
#deprecated("Use CursorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl CursorInputFallbacks for Array[@properties.Cursor]

///|
pub impl CursorInputFallbacks for Array[@properties.Cursor] with fn fallback_inputs(
  self,
) {
  self.map(value => CursorInput::property_input(value))
}

///|
#deprecated("Use ColorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ColorInputFallbacks for Array[@values.Color]

///|
pub impl ColorInputFallbacks for Array[@values.Color] with fn fallback_inputs(
  self,
) {
  self.map(value => ColorInput::color_input(value))
}

///|
#deprecated("Use BorderRadiiFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderRadiiInputFallbacks for Array[@values.Length]

///|
pub impl BorderRadiiInputFallbacks for Array[@values.Length] with fn fallback_inputs(
  self,
) {
  self.map(value => BorderRadiiInput::property_input(value))
}

///|
#deprecated("Use BorderStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderStyleInputFallbacks for Array[@properties.BorderStyle]

///|
pub impl BorderStyleInputFallbacks for Array[@properties.BorderStyle] with fn fallback_inputs(
  self,
) {
  self.map(value => BorderStyleInput::property_input(value))
}

///|
#deprecated("Use FontSizeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontSizeInputFallbacks for Array[@values.Length]

///|
pub impl FontSizeInputFallbacks for Array[@values.Length] with fn fallback_inputs(
  self,
) {
  self.map(value => FontSizeInput::property_input(value))
}

///|
#deprecated("Use IntFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl IntInputFallbacks for Array[Int32]

///|
pub impl IntInputFallbacks for Array[Int32] with fn fallback_inputs(self) {
  self.map(value => IntInput::property_input(value))
}

///|
#deprecated("Use LineHeightFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl LineHeightInputFallbacks for Array[Double]

///|
pub impl LineHeightInputFallbacks for Array[Double] with fn fallback_inputs(
  self,
) {
  self.map(value => LineHeightInput::property_input(value))
}

///|
#deprecated("Use DoubleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl DoubleInputFallbacks for Array[Double]

///|
pub impl DoubleInputFallbacks for Array[Double] with fn fallback_inputs(self) {
  self.map(value => DoubleInput::property_input(value))
}

///|
#deprecated("Use StringFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl StringInputFallbacks for Array[String]

///|
pub impl StringInputFallbacks for Array[String] with fn fallback_inputs(self) {
  self.map(value => StringInput::property_input(value))
}

///|
#deprecated("Use BoxShadowListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BoxShadowListInputFallbacks for Array[@values.BoxShadowList]

///|
pub impl BoxShadowListInputFallbacks for Array[@values.BoxShadowList] with fn fallback_inputs(
  self,
) {
  self.map(value => BoxShadowListInput::property_input(value))
}

///|
#deprecated("Use FilterListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FilterListInputFallbacks for Array[@values.FilterList]

///|
pub impl FilterListInputFallbacks for Array[@values.FilterList] with fn fallback_inputs(
  self,
) {
  self.map(value => FilterListInput::property_input(value))
}

///|
#deprecated("Use TextShadowListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextShadowListInputFallbacks for Array[@values.TextShadowList]

///|
pub impl TextShadowListInputFallbacks for Array[@values.TextShadowList] with fn fallback_inputs(
  self,
) {
  self.map(value => TextShadowListInput::property_input(value))
}

///|
#deprecated("Use GridTemplateAreasFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl GridTemplateAreasInputFallbacks for Array[@values.GridTemplateAreas]

///|
pub impl GridTemplateAreasInputFallbacks for Array[@values.GridTemplateAreas] with fn fallback_inputs(
  self,
) {
  self.map(value => GridTemplateAreasInput::property_input(value))
}

///|
#deprecated("Use ContainerNamesFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ContainerNamesInputFallbacks for Array[@values.ContainerNames]

///|
pub impl ContainerNamesInputFallbacks for Array[@values.ContainerNames] with fn fallback_inputs(
  self,
) {
  self.map(value => ContainerNamesInput::property_input(value))
}

///|
#deprecated("Use MaskImageListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MaskImageListInputFallbacks for Array[@values.MaskImageList]

///|
pub impl MaskImageListInputFallbacks for Array[@values.MaskImageList] with fn fallback_inputs(
  self,
) {
  self.map(value => MaskImageListInput::property_input(value))
}

///|
#deprecated("Use PositionListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionListInputFallbacks for Array[@values.PositionList]

///|
pub impl PositionListInputFallbacks for Array[@values.PositionList] with fn fallback_inputs(
  self,
) {
  self.map(value => PositionListInput::property_input(value))
}

///|
#deprecated("Use RepeatStyleListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl RepeatStyleListInputFallbacks for Array[@values.RepeatStyleList]

///|
pub impl RepeatStyleListInputFallbacks for Array[@values.RepeatStyleList] with fn fallback_inputs(
  self,
) {
  self.map(value => RepeatStyleListInput::property_input(value))
}

///|
#deprecated("Use BackgroundSizeListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BackgroundSizeListInputFallbacks for Array[@values.BackgroundSizeList]

///|
pub impl BackgroundSizeListInputFallbacks for Array[@values.BackgroundSizeList] with fn fallback_inputs(
  self,
) {
  self.map(value => BackgroundSizeListInput::property_input(value))
}

///|
#deprecated("Use ClipPathFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ClipPathInputFallbacks for Array[@values.ClipPath]

///|
pub impl ClipPathInputFallbacks for Array[@values.ClipPath] with fn fallback_inputs(
  self,
) {
  self.map(value => ClipPathInput::property_input(value))
}

///|
#deprecated("Use ContentValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ContentValueInputFallbacks for Array[@values.ContentValue]

///|
pub impl ContentValueInputFallbacks for Array[@values.ContentValue] with fn fallback_inputs(
  self,
) {
  self.map(value => ContentValueInput::property_input(value))
}

///|
#deprecated("Use AnchorNamesFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AnchorNamesInputFallbacks for Array[@values.AnchorNames]

///|
pub impl AnchorNamesInputFallbacks for Array[@values.AnchorNames] with fn fallback_inputs(
  self,
) {
  self.map(value => AnchorNamesInput::property_input(value))
}

///|
#deprecated("Use PositionAnchorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionAnchorInputFallbacks for Array[@values.PositionAnchor]

///|
pub impl PositionAnchorInputFallbacks for Array[@values.PositionAnchor] with fn fallback_inputs(
  self,
) {
  self.map(value => PositionAnchorInput::property_input(value))
}

///|
#deprecated("Use PositionAreaFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionAreaInputFallbacks for Array[@values.PositionArea]

///|
pub impl PositionAreaInputFallbacks for Array[@values.PositionArea] with fn fallback_inputs(
  self,
) {
  self.map(value => PositionAreaInput::property_input(value))
}

///|
#deprecated("Use PositionTryFallbacksFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionTryFallbacksInputFallbacks for Array[
  @values.PositionTryFallbacks,
]

///|
pub impl PositionTryFallbacksInputFallbacks for Array[
  @values.PositionTryFallbacks,
] with fn fallback_inputs(self) {
  self.map(value => PositionTryFallbacksInput::property_input(value))
}

///|
#deprecated("Use PositionTryOrderFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionTryOrderInputFallbacks for Array[@values.PositionTryOrder]

///|
pub impl PositionTryOrderInputFallbacks for Array[@values.PositionTryOrder] with fn fallback_inputs(
  self,
) {
  self.map(value => PositionTryOrderInput::property_input(value))
}

///|
#deprecated("Use ViewTransitionNameFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ViewTransitionNameInputFallbacks for Array[@values.ViewTransitionName]

///|
pub impl ViewTransitionNameInputFallbacks for Array[@values.ViewTransitionName] with fn fallback_inputs(
  self,
) {
  self.map(value => ViewTransitionNameInput::property_input(value))
}

///|
#deprecated("Use ViewTransitionClassFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ViewTransitionClassInputFallbacks for Array[
  @values.ViewTransitionClass,
]

///|
pub impl ViewTransitionClassInputFallbacks for Array[
  @values.ViewTransitionClass,
] with fn fallback_inputs(self) {
  self.map(value => ViewTransitionClassInput::property_input(value))
}

///|
#deprecated("Use TimeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TimeInputFallbacks for Array[@values.Time]

///|
pub impl TimeInputFallbacks for Array[@values.Time] with fn fallback_inputs(
  self,
) {
  self.map(value => TimeInput::time_input(value))
}

///|
#deprecated("Use FlexBasisFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FlexBasisInputFallbacks for Array[@values.Length]

///|
pub impl FlexBasisInputFallbacks for Array[@values.Length] with fn fallback_inputs(
  self,
) {
  self.map(value => FlexBasisInput::property_input(value))
}

///|
#deprecated("Use IntegerFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl IntegerInputFallbacks for Array[@values.Integer]

///|
pub impl IntegerInputFallbacks for Array[@values.Integer] with fn fallback_inputs(
  self,
) {
  self.map(value => IntegerInput::integer_input(value))
}

///|
#deprecated("Use NumberFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl NumberInputFallbacks for Array[@values.Number]

///|
pub impl NumberInputFallbacks for Array[@values.Number] with fn fallback_inputs(
  self,
) {
  self.map(value => NumberInput::number_input(value))
}

///|
#deprecated("Use AngleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AngleInputFallbacks for Array[@values.Angle]

///|
pub impl AngleInputFallbacks for Array[@values.Angle] with fn fallback_inputs(
  self,
) {
  self.map(value => AngleInput::angle_input(value))
}

///|
#deprecated("Use ImageFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ImageInputFallbacks for Array[@values.Url]

///|
pub impl ImageInputFallbacks for Array[@values.Url] with fn fallback_inputs(
  self,
) {
  self.map(value => ImageInput::image_input(value))
}

///|
#deprecated("Use PositionModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionModeInputFallbacks for Array[@properties.PositionMode]

///|
pub impl PositionModeInputFallbacks for Array[@properties.PositionMode] with fn fallback_inputs(
  self,
) {
  self.map(value => PositionModeInput::property_input(value))
}

///|
#deprecated("Use BoxSizingFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BoxSizingInputFallbacks for Array[@properties.BoxSizing]

///|
pub impl BoxSizingInputFallbacks for Array[@properties.BoxSizing] with fn fallback_inputs(
  self,
) {
  self.map(value => BoxSizingInput::property_input(value))
}

///|
#deprecated("Use VisibilityFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl VisibilityInputFallbacks for Array[@properties.Visibility]

///|
pub impl VisibilityInputFallbacks for Array[@properties.Visibility] with fn fallback_inputs(
  self,
) {
  self.map(value => VisibilityInput::property_input(value))
}

///|
#deprecated("Use FlexDirectionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FlexDirectionInputFallbacks for Array[@properties.FlexDirection]

///|
pub impl FlexDirectionInputFallbacks for Array[@properties.FlexDirection] with fn fallback_inputs(
  self,
) {
  self.map(value => FlexDirectionInput::property_input(value))
}

///|
#deprecated("Use FlexWrapFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FlexWrapInputFallbacks for Array[@properties.FlexWrap]

///|
pub impl FlexWrapInputFallbacks for Array[@properties.FlexWrap] with fn fallback_inputs(
  self,
) {
  self.map(value => FlexWrapInput::property_input(value))
}

///|
#deprecated("Use AlignmentFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AlignmentInputFallbacks for Array[@properties.Alignment]

///|
pub impl AlignmentInputFallbacks for Array[@properties.Alignment] with fn fallback_inputs(
  self,
) {
  self.map(value => AlignmentInput::property_input(value))
}

///|
#deprecated("Use RatioFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl RatioInputFallbacks for Array[@values.Ratio]

///|
pub impl RatioInputFallbacks for Array[@values.Ratio] with fn fallback_inputs(
  self,
) {
  self.map(value => RatioInput::property_input(value))
}

///|
#deprecated("Use ObjectFitFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ObjectFitInputFallbacks for Array[@properties.ObjectFit]

///|
pub impl ObjectFitInputFallbacks for Array[@properties.ObjectFit] with fn fallback_inputs(
  self,
) {
  self.map(value => ObjectFitInput::property_input(value))
}

///|
#deprecated("Use FloatModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FloatModeInputFallbacks for Array[@properties.FloatMode]

///|
pub impl FloatModeInputFallbacks for Array[@properties.FloatMode] with fn fallback_inputs(
  self,
) {
  self.map(value => FloatModeInput::property_input(value))
}

///|
#deprecated("Use ClearModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ClearModeInputFallbacks for Array[@properties.ClearMode]

///|
pub impl ClearModeInputFallbacks for Array[@properties.ClearMode] with fn fallback_inputs(
  self,
) {
  self.map(value => ClearModeInput::property_input(value))
}

///|
#deprecated("Use ResizeModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ResizeModeInputFallbacks for Array[@properties.ResizeMode]

///|
pub impl ResizeModeInputFallbacks for Array[@properties.ResizeMode] with fn fallback_inputs(
  self,
) {
  self.map(value => ResizeModeInput::property_input(value))
}

///|
#deprecated("Use ContainFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ContainInputFallbacks for Array[@values.Contain]

///|
pub impl ContainInputFallbacks for Array[@values.Contain] with fn fallback_inputs(
  self,
) {
  self.map(value => ContainInput::property_input(value))
}

///|
#deprecated("Use GridAutoFlowFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl GridAutoFlowInputFallbacks for Array[@properties.GridAutoFlow]

///|
pub impl GridAutoFlowInputFallbacks for Array[@properties.GridAutoFlow] with fn fallback_inputs(
  self,
) {
  self.map(value => GridAutoFlowInput::property_input(value))
}

///|
#deprecated("Use GridTrackListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl GridTrackListInputFallbacks for Array[@values.GridTrackList]

///|
pub impl GridTrackListInputFallbacks for Array[@values.GridTrackList] with fn fallback_inputs(
  self,
) {
  self.map(value => GridTrackListInput::grid_track_list_input(value))
}

///|
#deprecated("Use GridLineFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl GridLineInputFallbacks for Array[@values.GridLine]

///|
pub impl GridLineInputFallbacks for Array[@values.GridLine] with fn fallback_inputs(
  self,
) {
  self.map(value => GridLineInput::property_input(value))
}

///|
#deprecated("Use TextAlignFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextAlignInputFallbacks for Array[@properties.TextAlign]

///|
pub impl TextAlignInputFallbacks for Array[@properties.TextAlign] with fn fallback_inputs(
  self,
) {
  self.map(value => TextAlignInput::property_input(value))
}

///|
#deprecated("Use TextTransformFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextTransformInputFallbacks for Array[@properties.TextTransform]

///|
pub impl TextTransformInputFallbacks for Array[@properties.TextTransform] with fn fallback_inputs(
  self,
) {
  self.map(value => TextTransformInput::property_input(value))
}

///|
#deprecated("Use TextDecorationLineFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextDecorationLineInputFallbacks for Array[
  @properties.TextDecorationLine,
]

///|
pub impl TextDecorationLineInputFallbacks for Array[
  @properties.TextDecorationLine,
] with fn fallback_inputs(self) {
  self.map(value => TextDecorationLineInput::property_input(value))
}

///|
#deprecated("Use TextDecorationStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextDecorationStyleInputFallbacks for Array[
  @properties.TextDecorationStyle,
]

///|
pub impl TextDecorationStyleInputFallbacks for Array[
  @properties.TextDecorationStyle,
] with fn fallback_inputs(self) {
  self.map(value => TextDecorationStyleInput::property_input(value))
}

///|
#deprecated("Use TextUnderlinePositionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextUnderlinePositionInputFallbacks for Array[
  @properties.TextUnderlinePosition,
]

///|
pub impl TextUnderlinePositionInputFallbacks for Array[
  @properties.TextUnderlinePosition,
] with fn fallback_inputs(self) {
  self.map(value => TextUnderlinePositionInput::property_input(value))
}

///|
#deprecated("Use OverflowWrapFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverflowWrapInputFallbacks for Array[@properties.OverflowWrap]

///|
pub impl OverflowWrapInputFallbacks for Array[@properties.OverflowWrap] with fn fallback_inputs(
  self,
) {
  self.map(value => OverflowWrapInput::property_input(value))
}

///|
#deprecated("Use WordBreakFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl WordBreakInputFallbacks for Array[@properties.WordBreak]

///|
pub impl WordBreakInputFallbacks for Array[@properties.WordBreak] with fn fallback_inputs(
  self,
) {
  self.map(value => WordBreakInput::property_input(value))
}

///|
#deprecated("Use HyphensFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl HyphensInputFallbacks for Array[@properties.Hyphens]

///|
pub impl HyphensInputFallbacks for Array[@properties.Hyphens] with fn fallback_inputs(
  self,
) {
  self.map(value => HyphensInput::property_input(value))
}

///|
#deprecated("Use TextOverflowFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextOverflowInputFallbacks for Array[@properties.TextOverflow]

///|
pub impl TextOverflowInputFallbacks for Array[@properties.TextOverflow] with fn fallback_inputs(
  self,
) {
  self.map(value => TextOverflowInput::property_input(value))
}

///|
#deprecated("Use WhiteSpaceCollapseFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl WhiteSpaceCollapseInputFallbacks for Array[
  @properties.WhiteSpaceCollapse,
]

///|
pub impl WhiteSpaceCollapseInputFallbacks for Array[
  @properties.WhiteSpaceCollapse,
] with fn fallback_inputs(self) {
  self.map(value => WhiteSpaceCollapseInput::property_input(value))
}

///|
#deprecated("Use TextWrapModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextWrapModeInputFallbacks for Array[@properties.TextWrapMode]

///|
pub impl TextWrapModeInputFallbacks for Array[@properties.TextWrapMode] with fn fallback_inputs(
  self,
) {
  self.map(value => TextWrapModeInput::property_input(value))
}

///|
#deprecated("Use TextWrapStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextWrapStyleInputFallbacks for Array[@properties.TextWrapStyle]

///|
pub impl TextWrapStyleInputFallbacks for Array[@properties.TextWrapStyle] with fn fallback_inputs(
  self,
) {
  self.map(value => TextWrapStyleInput::property_input(value))
}

///|
#deprecated("Use FontStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontStyleInputFallbacks for Array[@properties.FontStyle]

///|
pub impl FontStyleInputFallbacks for Array[@properties.FontStyle] with fn fallback_inputs(
  self,
) {
  self.map(value => FontStyleInput::property_input(value))
}

///|
#deprecated("Use FontStretchFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontStretchInputFallbacks for Array[@properties.FontStretch]

///|
pub impl FontStretchInputFallbacks for Array[@properties.FontStretch] with fn fallback_inputs(
  self,
) {
  self.map(value => FontStretchInput::property_input(value))
}

///|
#deprecated("Use FontKerningFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontKerningInputFallbacks for Array[@properties.FontKerning]

///|
pub impl FontKerningInputFallbacks for Array[@properties.FontKerning] with fn fallback_inputs(
  self,
) {
  self.map(value => FontKerningInput::property_input(value))
}

///|
#deprecated("Use FontOpticalSizingFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontOpticalSizingInputFallbacks for Array[
  @properties.FontOpticalSizing,
]

///|
pub impl FontOpticalSizingInputFallbacks for Array[
  @properties.FontOpticalSizing,
] with fn fallback_inputs(self) {
  self.map(value => FontOpticalSizingInput::property_input(value))
}

///|
#deprecated("Use FontVariantCapsFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontVariantCapsInputFallbacks for Array[@properties.FontVariantCaps]

///|
pub impl FontVariantCapsInputFallbacks for Array[@properties.FontVariantCaps] with fn fallback_inputs(
  self,
) {
  self.map(value => FontVariantCapsInput::property_input(value))
}

///|
#deprecated("Use FontVariantNumericFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontVariantNumericInputFallbacks for Array[@values.FontVariantNumeric]

///|
pub impl FontVariantNumericInputFallbacks for Array[@values.FontVariantNumeric] with fn fallback_inputs(
  self,
) {
  self.map(value => FontVariantNumericInput::property_input(value))
}

///|
#deprecated("Use ListStylePositionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ListStylePositionInputFallbacks for Array[
  @properties.ListStylePosition,
]

///|
pub impl ListStylePositionInputFallbacks for Array[
  @properties.ListStylePosition,
] with fn fallback_inputs(self) {
  self.map(value => ListStylePositionInput::property_input(value))
}

///|
#deprecated("Use BackgroundAttachmentFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BackgroundAttachmentInputFallbacks for Array[
  @properties.BackgroundAttachment,
]

///|
pub impl BackgroundAttachmentInputFallbacks for Array[
  @properties.BackgroundAttachment,
] with fn fallback_inputs(self) {
  self.map(value => BackgroundAttachmentInput::property_input(value))
}

///|
#deprecated("Use BackgroundBoxFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BackgroundBoxInputFallbacks for Array[@properties.BackgroundBox]

///|
pub impl BackgroundBoxInputFallbacks for Array[@properties.BackgroundBox] with fn fallback_inputs(
  self,
) {
  self.map(value => BackgroundBoxInput::property_input(value))
}

///|
#deprecated("Use RepeatStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl RepeatStyleInputFallbacks for Array[@values.RepeatStyle]

///|
pub impl RepeatStyleInputFallbacks for Array[@values.RepeatStyle] with fn fallback_inputs(
  self,
) {
  self.map(value => RepeatStyleInput::property_input(value))
}

///|
#deprecated("Use PositionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionInputFallbacks for Array[@values.Position]

///|
pub impl PositionInputFallbacks for Array[@values.Position] with fn fallback_inputs(
  self,
) {
  self.map(value => PositionInput::property_input(value))
}

///|
#deprecated("Use BackgroundSizeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BackgroundSizeInputFallbacks for Array[@values.BackgroundSize]

///|
pub impl BackgroundSizeInputFallbacks for Array[@values.BackgroundSize] with fn fallback_inputs(
  self,
) {
  self.map(value => BackgroundSizeInput::property_input(value))
}

///|
#deprecated("Use BlendModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BlendModeInputFallbacks for Array[@properties.BlendMode]

///|
pub impl BlendModeInputFallbacks for Array[@properties.BlendMode] with fn fallback_inputs(
  self,
) {
  self.map(value => BlendModeInput::property_input(value))
}

///|
#deprecated("Use ImageRenderingFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ImageRenderingInputFallbacks for Array[@properties.ImageRendering]

///|
pub impl ImageRenderingInputFallbacks for Array[@properties.ImageRendering] with fn fallback_inputs(
  self,
) {
  self.map(value => ImageRenderingInput::property_input(value))
}

///|
#deprecated("Use TransformListFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TransformListInputFallbacks for Array[@values.TransformList]

///|
pub impl TransformListInputFallbacks for Array[@values.TransformList] with fn fallback_inputs(
  self,
) {
  self.map(value => TransformListInput::property_input(value))
}

///|
#deprecated("Use TransformOriginFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TransformOriginInputFallbacks for Array[@values.TransformOrigin]

///|
pub impl TransformOriginInputFallbacks for Array[@values.TransformOrigin] with fn fallback_inputs(
  self,
) {
  self.map(value => TransformOriginInput::property_input(value))
}

///|
#deprecated("Use AnimationIterationsFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AnimationIterationsInputFallbacks for Array[
  @values.AnimationIterations,
]

///|
pub impl AnimationIterationsInputFallbacks for Array[
  @values.AnimationIterations,
] with fn fallback_inputs(self) {
  self.map(value => AnimationIterationsInput::property_input(value))
}

///|
#deprecated("Use BackfaceVisibilityFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BackfaceVisibilityInputFallbacks for Array[
  @properties.BackfaceVisibility,
]

///|
pub impl BackfaceVisibilityInputFallbacks for Array[
  @properties.BackfaceVisibility,
] with fn fallback_inputs(self) {
  self.map(value => BackfaceVisibilityInput::property_input(value))
}

///|
#deprecated("Use TransformStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TransformStyleInputFallbacks for Array[@properties.TransformStyle]

///|
pub impl TransformStyleInputFallbacks for Array[@properties.TransformStyle] with fn fallback_inputs(
  self,
) {
  self.map(value => TransformStyleInput::property_input(value))
}

///|
#deprecated("Use AnimationDirectionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AnimationDirectionInputFallbacks for Array[
  @properties.AnimationDirection,
]

///|
pub impl AnimationDirectionInputFallbacks for Array[
  @properties.AnimationDirection,
] with fn fallback_inputs(self) {
  self.map(value => AnimationDirectionInput::property_input(value))
}

///|
#deprecated("Use AnimationFillModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AnimationFillModeInputFallbacks for Array[
  @properties.AnimationFillMode,
]

///|
pub impl AnimationFillModeInputFallbacks for Array[
  @properties.AnimationFillMode,
] with fn fallback_inputs(self) {
  self.map(value => AnimationFillModeInput::property_input(value))
}

///|
#deprecated("Use AnimationPlayStateFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AnimationPlayStateInputFallbacks for Array[
  @properties.AnimationPlayState,
]

///|
pub impl AnimationPlayStateInputFallbacks for Array[
  @properties.AnimationPlayState,
] with fn fallback_inputs(self) {
  self.map(value => AnimationPlayStateInput::property_input(value))
}

///|
#deprecated("Use EasingFunctionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl EasingFunctionInputFallbacks for Array[@values.EasingFunction]

///|
pub impl EasingFunctionInputFallbacks for Array[@values.EasingFunction] with fn fallback_inputs(
  self,
) {
  self.map(value => EasingFunctionInput::property_input(value))
}

///|
#deprecated("Use TransitionPropertyFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TransitionPropertyInputFallbacks for Array[
  @properties.TransitionProperty,
]

///|
pub impl TransitionPropertyInputFallbacks for Array[
  @properties.TransitionProperty,
] with fn fallback_inputs(self) {
  self.map(value => TransitionPropertyInput::property_input(value))
}

///|
#deprecated("Use PointerEventsFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PointerEventsInputFallbacks for Array[@properties.PointerEvents]

///|
pub impl PointerEventsInputFallbacks for Array[@properties.PointerEvents] with fn fallback_inputs(
  self,
) {
  self.map(value => PointerEventsInput::property_input(value))
}

///|
#deprecated("Use UserSelectFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl UserSelectInputFallbacks for Array[@properties.UserSelect]

///|
pub impl UserSelectInputFallbacks for Array[@properties.UserSelect] with fn fallback_inputs(
  self,
) {
  self.map(value => UserSelectInput::property_input(value))
}

///|
#deprecated("Use TouchActionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TouchActionInputFallbacks for Array[@values.TouchAction]

///|
pub impl TouchActionInputFallbacks for Array[@values.TouchAction] with fn fallback_inputs(
  self,
) {
  self.map(value => TouchActionInput::property_input(value))
}

///|
#deprecated("Use ScrollBehaviorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollBehaviorInputFallbacks for Array[@properties.ScrollBehavior]

///|
pub impl ScrollBehaviorInputFallbacks for Array[@properties.ScrollBehavior] with fn fallback_inputs(
  self,
) {
  self.map(value => ScrollBehaviorInput::property_input(value))
}

///|
#deprecated("Use OverscrollBehaviorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverscrollBehaviorInputFallbacks for Array[
  @properties.OverscrollBehavior,
]

///|
pub impl OverscrollBehaviorInputFallbacks for Array[
  @properties.OverscrollBehavior,
] with fn fallback_inputs(self) {
  self.map(value => OverscrollBehaviorInput::property_input(value))
}

///|
#deprecated("Use ContentVisibilityFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ContentVisibilityInputFallbacks for Array[
  @properties.ContentVisibility,
]

///|
pub impl ContentVisibilityInputFallbacks for Array[
  @properties.ContentVisibility,
] with fn fallback_inputs(self) {
  self.map(value => ContentVisibilityInput::property_input(value))
}

///|
#deprecated("Use LengthPercentageFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl LengthPercentageInputFallbacks for Array[@values.LengthPercentage]

///|
pub impl LengthPercentageInputFallbacks for Array[@values.LengthPercentage] with fn fallback_inputs(
  self,
) {
  self.map(value => LengthPercentageInput::length_percentage_input(value))
}

///|
#deprecated("Use BaselineSourceValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BaselineSourceValueInputFallbacks for Array[
  @properties.BaselineSourceValue,
]

///|
pub impl BaselineSourceValueInputFallbacks for Array[
  @properties.BaselineSourceValue,
] with fn fallback_inputs(self) {
  self.map(value => BaselineSourceValueInput::property_input(value))
}

///|
#deprecated("Use BorderCollapseValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderCollapseValueInputFallbacks for Array[
  @properties.BorderCollapseValue,
]

///|
pub impl BorderCollapseValueInputFallbacks for Array[
  @properties.BorderCollapseValue,
] with fn fallback_inputs(self) {
  self.map(value => BorderCollapseValueInput::property_input(value))
}

///|
#deprecated("Use BorderImageRepeatValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderImageRepeatValueInputFallbacks for Array[
  @properties.BorderImageRepeatValue,
]

///|
pub impl BorderImageRepeatValueInputFallbacks for Array[
  @properties.BorderImageRepeatValue,
] with fn fallback_inputs(self) {
  self.map(value => BorderImageRepeatValueInput::property_input(value))
}

///|
#deprecated("Use BoxDecorationBreakValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BoxDecorationBreakValueInputFallbacks for Array[
  @properties.BoxDecorationBreakValue,
]

///|
pub impl BoxDecorationBreakValueInputFallbacks for Array[
  @properties.BoxDecorationBreakValue,
] with fn fallback_inputs(self) {
  self.map(value => BoxDecorationBreakValueInput::property_input(value))
}

///|
#deprecated("Use BreakAfterValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BreakAfterValueInputFallbacks for Array[@properties.BreakAfterValue]

///|
pub impl BreakAfterValueInputFallbacks for Array[@properties.BreakAfterValue] with fn fallback_inputs(
  self,
) {
  self.map(value => BreakAfterValueInput::property_input(value))
}

///|
#deprecated("Use BreakBeforeValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BreakBeforeValueInputFallbacks for Array[@properties.BreakBeforeValue]

///|
pub impl BreakBeforeValueInputFallbacks for Array[@properties.BreakBeforeValue] with fn fallback_inputs(
  self,
) {
  self.map(value => BreakBeforeValueInput::property_input(value))
}

///|
#deprecated("Use BreakInsideValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BreakInsideValueInputFallbacks for Array[@properties.BreakInsideValue]

///|
pub impl BreakInsideValueInputFallbacks for Array[@properties.BreakInsideValue] with fn fallback_inputs(
  self,
) {
  self.map(value => BreakInsideValueInput::property_input(value))
}

///|
#deprecated("Use CaptionSideValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl CaptionSideValueInputFallbacks for Array[@properties.CaptionSideValue]

///|
pub impl CaptionSideValueInputFallbacks for Array[@properties.CaptionSideValue] with fn fallback_inputs(
  self,
) {
  self.map(value => CaptionSideValueInput::property_input(value))
}

///|
#deprecated("Use ClipRuleValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ClipRuleValueInputFallbacks for Array[@properties.ClipRuleValue]

///|
pub impl ClipRuleValueInputFallbacks for Array[@properties.ClipRuleValue] with fn fallback_inputs(
  self,
) {
  self.map(value => ClipRuleValueInput::property_input(value))
}

///|
#deprecated("Use ColorInterpolationFiltersValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ColorInterpolationFiltersValueInputFallbacks for Array[
  @properties.ColorInterpolationFiltersValue,
]

///|
pub impl ColorInterpolationFiltersValueInputFallbacks for Array[
  @properties.ColorInterpolationFiltersValue,
] with fn fallback_inputs(self) {
  self.map(value => ColorInterpolationFiltersValueInput::property_input(value))
}

///|
#deprecated("Use ColumnFillValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ColumnFillValueInputFallbacks for Array[@properties.ColumnFillValue]

///|
pub impl ColumnFillValueInputFallbacks for Array[@properties.ColumnFillValue] with fn fallback_inputs(
  self,
) {
  self.map(value => ColumnFillValueInput::property_input(value))
}

///|
#deprecated("Use ColumnSpanValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ColumnSpanValueInputFallbacks for Array[@properties.ColumnSpanValue]

///|
pub impl ColumnSpanValueInputFallbacks for Array[@properties.ColumnSpanValue] with fn fallback_inputs(
  self,
) {
  self.map(value => ColumnSpanValueInput::property_input(value))
}

///|
#deprecated("Use ContainerTypeValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ContainerTypeValueInputFallbacks for Array[
  @properties.ContainerTypeValue,
]

///|
pub impl ContainerTypeValueInputFallbacks for Array[
  @properties.ContainerTypeValue,
] with fn fallback_inputs(self) {
  self.map(value => ContainerTypeValueInput::property_input(value))
}

///|
#deprecated("Use DirectionValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl DirectionValueInputFallbacks for Array[@properties.DirectionValue]

///|
pub impl DirectionValueInputFallbacks for Array[@properties.DirectionValue] with fn fallback_inputs(
  self,
) {
  self.map(value => DirectionValueInput::property_input(value))
}

///|
#deprecated("Use EmptyCellsValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl EmptyCellsValueInputFallbacks for Array[@properties.EmptyCellsValue]

///|
pub impl EmptyCellsValueInputFallbacks for Array[@properties.EmptyCellsValue] with fn fallback_inputs(
  self,
) {
  self.map(value => EmptyCellsValueInput::property_input(value))
}

///|
#deprecated("Use FieldSizingValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FieldSizingValueInputFallbacks for Array[@properties.FieldSizingValue]

///|
pub impl FieldSizingValueInputFallbacks for Array[@properties.FieldSizingValue] with fn fallback_inputs(
  self,
) {
  self.map(value => FieldSizingValueInput::property_input(value))
}

///|
#deprecated("Use FillRuleValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FillRuleValueInputFallbacks for Array[@properties.FillRuleValue]

///|
pub impl FillRuleValueInputFallbacks for Array[@properties.FillRuleValue] with fn fallback_inputs(
  self,
) {
  self.map(value => FillRuleValueInput::property_input(value))
}

///|
#deprecated("Use FontSynthesisValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontSynthesisValueInputFallbacks for Array[
  @properties.FontSynthesisValue,
]

///|
pub impl FontSynthesisValueInputFallbacks for Array[
  @properties.FontSynthesisValue,
] with fn fallback_inputs(self) {
  self.map(value => FontSynthesisValueInput::property_input(value))
}

///|
#deprecated("Use FontSynthesisSmallCapsValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontSynthesisSmallCapsValueInputFallbacks for Array[
  @properties.FontSynthesisSmallCapsValue,
]

///|
pub impl FontSynthesisSmallCapsValueInputFallbacks for Array[
  @properties.FontSynthesisSmallCapsValue,
] with fn fallback_inputs(self) {
  self.map(value => FontSynthesisSmallCapsValueInput::property_input(value))
}

///|
#deprecated("Use FontSynthesisStyleValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontSynthesisStyleValueInputFallbacks for Array[
  @properties.FontSynthesisStyleValue,
]

///|
pub impl FontSynthesisStyleValueInputFallbacks for Array[
  @properties.FontSynthesisStyleValue,
] with fn fallback_inputs(self) {
  self.map(value => FontSynthesisStyleValueInput::property_input(value))
}

///|
#deprecated("Use FontSynthesisWeightValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontSynthesisWeightValueInputFallbacks for Array[
  @properties.FontSynthesisWeightValue,
]

///|
pub impl FontSynthesisWeightValueInputFallbacks for Array[
  @properties.FontSynthesisWeightValue,
] with fn fallback_inputs(self) {
  self.map(value => FontSynthesisWeightValueInput::property_input(value))
}

///|
#deprecated("Use FontVariantEmojiValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontVariantEmojiValueInputFallbacks for Array[
  @properties.FontVariantEmojiValue,
]

///|
pub impl FontVariantEmojiValueInputFallbacks for Array[
  @properties.FontVariantEmojiValue,
] with fn fallback_inputs(self) {
  self.map(value => FontVariantEmojiValueInput::property_input(value))
}

///|
#deprecated("Use FontVariantPositionValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl FontVariantPositionValueInputFallbacks for Array[
  @properties.FontVariantPositionValue,
]

///|
pub impl FontVariantPositionValueInputFallbacks for Array[
  @properties.FontVariantPositionValue,
] with fn fallback_inputs(self) {
  self.map(value => FontVariantPositionValueInput::property_input(value))
}

///|
#deprecated("Use PercentageFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PercentageInputFallbacks for Array[@values.Percentage]

///|
pub impl PercentageInputFallbacks for Array[@values.Percentage] with fn fallback_inputs(
  self,
) {
  self.map(value => PercentageInput::percentage_input(value))
}

///|
#deprecated("Use ForcedColorAdjustValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ForcedColorAdjustValueInputFallbacks for Array[
  @properties.ForcedColorAdjustValue,
]

///|
pub impl ForcedColorAdjustValueInputFallbacks for Array[
  @properties.ForcedColorAdjustValue,
] with fn fallback_inputs(self) {
  self.map(value => ForcedColorAdjustValueInput::property_input(value))
}

///|
#deprecated("Use HangingPunctuationValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl HangingPunctuationValueInputFallbacks for Array[
  @properties.HangingPunctuationValue,
]

///|
pub impl HangingPunctuationValueInputFallbacks for Array[
  @properties.HangingPunctuationValue,
] with fn fallback_inputs(self) {
  self.map(value => HangingPunctuationValueInput::property_input(value))
}

///|
#deprecated("Use LineBreakValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl LineBreakValueInputFallbacks for Array[@properties.LineBreakValue]

///|
pub impl LineBreakValueInputFallbacks for Array[@properties.LineBreakValue] with fn fallback_inputs(
  self,
) {
  self.map(value => LineBreakValueInput::property_input(value))
}

///|
#deprecated("Use MaskTypeValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MaskTypeValueInputFallbacks for Array[@properties.MaskTypeValue]

///|
pub impl MaskTypeValueInputFallbacks for Array[@properties.MaskTypeValue] with fn fallback_inputs(
  self,
) {
  self.map(value => MaskTypeValueInput::property_input(value))
}

///|
#deprecated("Use MathShiftValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MathShiftValueInputFallbacks for Array[@properties.MathShiftValue]

///|
pub impl MathShiftValueInputFallbacks for Array[@properties.MathShiftValue] with fn fallback_inputs(
  self,
) {
  self.map(value => MathShiftValueInput::property_input(value))
}

///|
#deprecated("Use MathStyleValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MathStyleValueInputFallbacks for Array[@properties.MathStyleValue]

///|
pub impl MathStyleValueInputFallbacks for Array[@properties.MathStyleValue] with fn fallback_inputs(
  self,
) {
  self.map(value => MathStyleValueInput::property_input(value))
}

///|
#deprecated("Use OffsetRotateFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OffsetRotateInputFallbacks for Array[@values.OffsetRotate]

///|
pub impl OffsetRotateInputFallbacks for Array[@values.OffsetRotate] with fn fallback_inputs(
  self,
) {
  self.map(value => OffsetRotateInput::property_input(value))
}

///|
#deprecated("Use OverflowAnchorValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverflowAnchorValueInputFallbacks for Array[
  @properties.OverflowAnchorValue,
]

///|
pub impl OverflowAnchorValueInputFallbacks for Array[
  @properties.OverflowAnchorValue,
] with fn fallback_inputs(self) {
  self.map(value => OverflowAnchorValueInput::property_input(value))
}

///|
#deprecated("Use OverscrollBehaviorValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverscrollBehaviorValueInputFallbacks for Array[
  @properties.OverscrollBehaviorValue,
]

///|
pub impl OverscrollBehaviorValueInputFallbacks for Array[
  @properties.OverscrollBehaviorValue,
] with fn fallback_inputs(self) {
  self.map(value => OverscrollBehaviorValueInput::property_input(value))
}

///|
#deprecated("Use OverscrollBehaviorBlockValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverscrollBehaviorBlockValueInputFallbacks for Array[
  @properties.OverscrollBehaviorBlockValue,
]

///|
pub impl OverscrollBehaviorBlockValueInputFallbacks for Array[
  @properties.OverscrollBehaviorBlockValue,
] with fn fallback_inputs(self) {
  self.map(value => OverscrollBehaviorBlockValueInput::property_input(value))
}

///|
#deprecated("Use OverscrollBehaviorInlineValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OverscrollBehaviorInlineValueInputFallbacks for Array[
  @properties.OverscrollBehaviorInlineValue,
]

///|
pub impl OverscrollBehaviorInlineValueInputFallbacks for Array[
  @properties.OverscrollBehaviorInlineValue,
] with fn fallback_inputs(self) {
  self.map(value => OverscrollBehaviorInlineValueInput::property_input(value))
}

///|
#deprecated("Use PaintOrderValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PaintOrderValueInputFallbacks for Array[@properties.PaintOrderValue]

///|
pub impl PaintOrderValueInputFallbacks for Array[@properties.PaintOrderValue] with fn fallback_inputs(
  self,
) {
  self.map(value => PaintOrderValueInput::property_input(value))
}

///|
#deprecated("Use PositionVisibilityValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PositionVisibilityValueInputFallbacks for Array[
  @properties.PositionVisibilityValue,
]

///|
pub impl PositionVisibilityValueInputFallbacks for Array[
  @properties.PositionVisibilityValue,
] with fn fallback_inputs(self) {
  self.map(value => PositionVisibilityValueInput::property_input(value))
}

///|
#deprecated("Use PrintColorAdjustValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PrintColorAdjustValueInputFallbacks for Array[
  @properties.PrintColorAdjustValue,
]

///|
pub impl PrintColorAdjustValueInputFallbacks for Array[
  @properties.PrintColorAdjustValue,
] with fn fallback_inputs(self) {
  self.map(value => PrintColorAdjustValueInput::property_input(value))
}

///|
#deprecated("Use RubyAlignValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl RubyAlignValueInputFallbacks for Array[@properties.RubyAlignValue]

///|
pub impl RubyAlignValueInputFallbacks for Array[@properties.RubyAlignValue] with fn fallback_inputs(
  self,
) {
  self.map(value => RubyAlignValueInput::property_input(value))
}

///|
#deprecated("Use RubyPositionValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl RubyPositionValueInputFallbacks for Array[
  @properties.RubyPositionValue,
]

///|
pub impl RubyPositionValueInputFallbacks for Array[
  @properties.RubyPositionValue,
] with fn fallback_inputs(self) {
  self.map(value => RubyPositionValueInput::property_input(value))
}

///|
#deprecated("Use ScrollSnapAlignValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollSnapAlignValueInputFallbacks for Array[
  @properties.ScrollSnapAlignValue,
]

///|
pub impl ScrollSnapAlignValueInputFallbacks for Array[
  @properties.ScrollSnapAlignValue,
] with fn fallback_inputs(self) {
  self.map(value => ScrollSnapAlignValueInput::property_input(value))
}

///|
#deprecated("Use ScrollSnapStopValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollSnapStopValueInputFallbacks for Array[
  @properties.ScrollSnapStopValue,
]

///|
pub impl ScrollSnapStopValueInputFallbacks for Array[
  @properties.ScrollSnapStopValue,
] with fn fallback_inputs(self) {
  self.map(value => ScrollSnapStopValueInput::property_input(value))
}

///|
#deprecated("Use ScrollSnapTypeValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollSnapTypeValueInputFallbacks for Array[
  @properties.ScrollSnapTypeValue,
]

///|
pub impl ScrollSnapTypeValueInputFallbacks for Array[
  @properties.ScrollSnapTypeValue,
] with fn fallback_inputs(self) {
  self.map(value => ScrollSnapTypeValueInput::property_input(value))
}

///|
#deprecated("Use ScrollTimelineAxisValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollTimelineAxisValueInputFallbacks for Array[
  @properties.ScrollTimelineAxisValue,
]

///|
pub impl ScrollTimelineAxisValueInputFallbacks for Array[
  @properties.ScrollTimelineAxisValue,
] with fn fallback_inputs(self) {
  self.map(value => ScrollTimelineAxisValueInput::property_input(value))
}

///|
#deprecated("Use ScrollbarWidthValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollbarWidthValueInputFallbacks for Array[
  @properties.ScrollbarWidthValue,
]

///|
pub impl ScrollbarWidthValueInputFallbacks for Array[
  @properties.ScrollbarWidthValue,
] with fn fallback_inputs(self) {
  self.map(value => ScrollbarWidthValueInput::property_input(value))
}

///|
#deprecated("Use ShapeRenderingValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ShapeRenderingValueInputFallbacks for Array[
  @properties.ShapeRenderingValue,
]

///|
pub impl ShapeRenderingValueInputFallbacks for Array[
  @properties.ShapeRenderingValue,
] with fn fallback_inputs(self) {
  self.map(value => ShapeRenderingValueInput::property_input(value))
}

///|
#deprecated("Use SpeakValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl SpeakValueInputFallbacks for Array[@properties.SpeakValue]

///|
pub impl SpeakValueInputFallbacks for Array[@properties.SpeakValue] with fn fallback_inputs(
  self,
) {
  self.map(value => SpeakValueInput::property_input(value))
}

///|
#deprecated("Use StrokeLinecapValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl StrokeLinecapValueInputFallbacks for Array[
  @properties.StrokeLinecapValue,
]

///|
pub impl StrokeLinecapValueInputFallbacks for Array[
  @properties.StrokeLinecapValue,
] with fn fallback_inputs(self) {
  self.map(value => StrokeLinecapValueInput::property_input(value))
}

///|
#deprecated("Use StrokeLinejoinValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl StrokeLinejoinValueInputFallbacks for Array[
  @properties.StrokeLinejoinValue,
]

///|
pub impl StrokeLinejoinValueInputFallbacks for Array[
  @properties.StrokeLinejoinValue,
] with fn fallback_inputs(self) {
  self.map(value => StrokeLinejoinValueInput::property_input(value))
}

///|
#deprecated("Use TableLayoutValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TableLayoutValueInputFallbacks for Array[@properties.TableLayoutValue]

///|
pub impl TableLayoutValueInputFallbacks for Array[@properties.TableLayoutValue] with fn fallback_inputs(
  self,
) {
  self.map(value => TableLayoutValueInput::property_input(value))
}

///|
#deprecated("Use TextAnchorValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextAnchorValueInputFallbacks for Array[@properties.TextAnchorValue]

///|
pub impl TextAnchorValueInputFallbacks for Array[@properties.TextAnchorValue] with fn fallback_inputs(
  self,
) {
  self.map(value => TextAnchorValueInput::property_input(value))
}

///|
#deprecated("Use TextBoxTrimValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextBoxTrimValueInputFallbacks for Array[@properties.TextBoxTrimValue]

///|
pub impl TextBoxTrimValueInputFallbacks for Array[@properties.TextBoxTrimValue] with fn fallback_inputs(
  self,
) {
  self.map(value => TextBoxTrimValueInput::property_input(value))
}

///|
#deprecated("Use TextCombineUprightValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextCombineUprightValueInputFallbacks for Array[
  @properties.TextCombineUprightValue,
]

///|
pub impl TextCombineUprightValueInputFallbacks for Array[
  @properties.TextCombineUprightValue,
] with fn fallback_inputs(self) {
  self.map(value => TextCombineUprightValueInput::property_input(value))
}

///|
#deprecated("Use TextDecorationSkipInkValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextDecorationSkipInkValueInputFallbacks for Array[
  @properties.TextDecorationSkipInkValue,
]

///|
pub impl TextDecorationSkipInkValueInputFallbacks for Array[
  @properties.TextDecorationSkipInkValue,
] with fn fallback_inputs(self) {
  self.map(value => TextDecorationSkipInkValueInput::property_input(value))
}

///|
#deprecated("Use TextJustifyValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextJustifyValueInputFallbacks for Array[@properties.TextJustifyValue]

///|
pub impl TextJustifyValueInputFallbacks for Array[@properties.TextJustifyValue] with fn fallback_inputs(
  self,
) {
  self.map(value => TextJustifyValueInput::property_input(value))
}

///|
#deprecated("Use TextOrientationValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextOrientationValueInputFallbacks for Array[
  @properties.TextOrientationValue,
]

///|
pub impl TextOrientationValueInputFallbacks for Array[
  @properties.TextOrientationValue,
] with fn fallback_inputs(self) {
  self.map(value => TextOrientationValueInput::property_input(value))
}

///|
#deprecated("Use TextRenderingValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TextRenderingValueInputFallbacks for Array[
  @properties.TextRenderingValue,
]

///|
pub impl TextRenderingValueInputFallbacks for Array[
  @properties.TextRenderingValue,
] with fn fallback_inputs(self) {
  self.map(value => TextRenderingValueInput::property_input(value))
}

///|
#deprecated("Use TransformBoxValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TransformBoxValueInputFallbacks for Array[
  @properties.TransformBoxValue,
]

///|
pub impl TransformBoxValueInputFallbacks for Array[
  @properties.TransformBoxValue,
] with fn fallback_inputs(self) {
  self.map(value => TransformBoxValueInput::property_input(value))
}

///|
#deprecated("Use UnicodeBidiValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl UnicodeBidiValueInputFallbacks for Array[@properties.UnicodeBidiValue]

///|
pub impl UnicodeBidiValueInputFallbacks for Array[@properties.UnicodeBidiValue] with fn fallback_inputs(
  self,
) {
  self.map(value => UnicodeBidiValueInput::property_input(value))
}

///|
#deprecated("Use VectorEffectValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl VectorEffectValueInputFallbacks for Array[
  @properties.VectorEffectValue,
]

///|
pub impl VectorEffectValueInputFallbacks for Array[
  @properties.VectorEffectValue,
] with fn fallback_inputs(self) {
  self.map(value => VectorEffectValueInput::property_input(value))
}

///|
#deprecated("Use ViewTimelineAxisValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ViewTimelineAxisValueInputFallbacks for Array[
  @properties.ViewTimelineAxisValue,
]

///|
pub impl ViewTimelineAxisValueInputFallbacks for Array[
  @properties.ViewTimelineAxisValue,
] with fn fallback_inputs(self) {
  self.map(value => ViewTimelineAxisValueInput::property_input(value))
}

///|
#deprecated("Use WritingModeValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl WritingModeValueInputFallbacks for Array[@properties.WritingModeValue]

///|
pub impl WritingModeValueInputFallbacks for Array[@properties.WritingModeValue] with fn fallback_inputs(
  self,
) {
  self.map(value => WritingModeValueInput::property_input(value))
}

///|
#deprecated("Use BorderSideFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderSideInputFallbacks for Array[@values.BorderSide]

///|
pub impl BorderSideInputFallbacks for Array[@values.BorderSide] with fn fallback_inputs(
  self,
) {
  self.map(value => BorderSideInput::property_input(value))
}

///|
#deprecated("Use BorderColorsFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderColorsInputFallbacks for Array[@values.BorderColors]

///|
pub impl BorderColorsInputFallbacks for Array[@values.BorderColors] with fn fallback_inputs(
  self,
) {
  self.map(value => BorderColorsInput::property_input(value))
}

///|
#deprecated("Use LineStyleFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl LineStyleInputFallbacks for Array[@values.LineStyle]

///|
pub impl LineStyleInputFallbacks for Array[@values.LineStyle] with fn fallback_inputs(
  self,
) {
  self.map(value => LineStyleInput::property_input(value))
}

///|
#deprecated("Use LineWidthFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl LineWidthInputFallbacks for Array[@values.LineWidth]

///|
pub impl LineWidthInputFallbacks for Array[@values.LineWidth] with fn fallback_inputs(
  self,
) {
  self.map(value => LineWidthInput::property_input(value))
}

///|
#deprecated("Use BorderStylesFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderStylesInputFallbacks for Array[@values.BorderStyles]

///|
pub impl BorderStylesInputFallbacks for Array[@values.BorderStyles] with fn fallback_inputs(
  self,
) {
  self.map(value => BorderStylesInput::property_input(value))
}

///|
#deprecated("Use BorderWidthsFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl BorderWidthsInputFallbacks for Array[@values.BorderWidths]

///|
pub impl BorderWidthsInputFallbacks for Array[@values.BorderWidths] with fn fallback_inputs(
  self,
) {
  self.map(value => BorderWidthsInput::property_input(value))
}

///|
#deprecated("Use OutlineFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OutlineInputFallbacks for Array[@values.Outline]

///|
pub impl OutlineInputFallbacks for Array[@values.Outline] with fn fallback_inputs(
  self,
) {
  self.map(value => OutlineInput::property_input(value))
}

///|
#deprecated("Use PageValueFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl PageValueInputFallbacks for Array[@values.PageValue]

///|
pub impl PageValueInputFallbacks for Array[@values.PageValue] with fn fallback_inputs(
  self,
) {
  self.map(value => PageValueInput::property_input(value))
}

///|
#deprecated("Use MaskBoxFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MaskBoxInputFallbacks for Array[@values.MaskBox]

///|
pub impl MaskBoxInputFallbacks for Array[@values.MaskBox] with fn fallback_inputs(
  self,
) {
  self.map(value => MaskBoxInput::property_input(value))
}

///|
#deprecated("Use MaskClipFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MaskClipInputFallbacks for Array[@values.MaskClip]

///|
pub impl MaskClipInputFallbacks for Array[@values.MaskClip] with fn fallback_inputs(
  self,
) {
  self.map(value => MaskClipInput::property_input(value))
}

///|
#deprecated("Use MaskModeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MaskModeInputFallbacks for Array[@values.MaskMode]

///|
pub impl MaskModeInputFallbacks for Array[@values.MaskMode] with fn fallback_inputs(
  self,
) {
  self.map(value => MaskModeInput::property_input(value))
}

///|
#deprecated("Use MaskCompositeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MaskCompositeInputFallbacks for Array[@values.MaskComposite]

///|
pub impl MaskCompositeInputFallbacks for Array[@values.MaskComposite] with fn fallback_inputs(
  self,
) {
  self.map(value => MaskCompositeInput::property_input(value))
}

///|
#deprecated("Use CounterChangesFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl CounterChangesInputFallbacks for Array[@values.CounterChanges]

///|
pub impl CounterChangesInputFallbacks for Array[@values.CounterChanges] with fn fallback_inputs(
  self,
) {
  self.map(value => CounterChangesInput::property_input(value))
}

///|
#deprecated("Use TimelineNamesFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TimelineNamesInputFallbacks for Array[@values.TimelineNames]

///|
pub impl TimelineNamesInputFallbacks for Array[@values.TimelineNames] with fn fallback_inputs(
  self,
) {
  self.map(value => TimelineNamesInput::property_input(value))
}

///|
#deprecated("Use AnimationTimelinesFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl AnimationTimelinesInputFallbacks for Array[@values.AnimationTimelines]

///|
pub impl AnimationTimelinesInputFallbacks for Array[@values.AnimationTimelines] with fn fallback_inputs(
  self,
) {
  self.map(value => AnimationTimelinesInput::property_input(value))
}

///|
#deprecated("Use TimelineRangeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TimelineRangeInputFallbacks for Array[@values.TimelineRange]

///|
pub impl TimelineRangeInputFallbacks for Array[@values.TimelineRange] with fn fallback_inputs(
  self,
) {
  self.map(value => TimelineRangeInput::property_input(value))
}

///|
#deprecated("Use TimelineScopeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl TimelineScopeInputFallbacks for Array[@values.TimelineScope]

///|
pub impl TimelineScopeInputFallbacks for Array[@values.TimelineScope] with fn fallback_inputs(
  self,
) {
  self.map(value => TimelineScopeInput::property_input(value))
}

///|
#deprecated("Use MotionPathFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl MotionPathInputFallbacks for Array[@values.MotionPath]

///|
pub impl MotionPathInputFallbacks for Array[@values.MotionPath] with fn fallback_inputs(
  self,
) {
  self.map(value => MotionPathInput::property_input(value))
}

///|
#deprecated("Use OffsetPositionFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OffsetPositionInputFallbacks for Array[@values.OffsetPosition]

///|
pub impl OffsetPositionInputFallbacks for Array[@values.OffsetPosition] with fn fallback_inputs(
  self,
) {
  self.map(value => OffsetPositionInput::property_input(value))
}

///|
#deprecated("Use OffsetAnchorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl OffsetAnchorInputFallbacks for Array[@values.OffsetAnchor]

///|
pub impl OffsetAnchorInputFallbacks for Array[@values.OffsetAnchor] with fn fallback_inputs(
  self,
) {
  self.map(value => OffsetAnchorInput::property_input(value))
}

///|
#deprecated("Use ColorSchemeFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ColorSchemeInputFallbacks for Array[@values.ColorScheme]

///|
pub impl ColorSchemeInputFallbacks for Array[@values.ColorScheme] with fn fallback_inputs(
  self,
) {
  self.map(value => ColorSchemeInput::property_input(value))
}

///|
#deprecated("Use ScrollbarColorFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl ScrollbarColorInputFallbacks for Array[@values.ScrollbarColor]

///|
pub impl ScrollbarColorInputFallbacks for Array[@values.ScrollbarColor] with fn fallback_inputs(
  self,
) {
  self.map(value => ScrollbarColorInput::property_input(value))
}

///|
#deprecated("Use SvgPaintFallbacks::new().add(...) for ordered fallbacks", skip_current_package=true)
pub impl SvgPaintInputFallbacks for Array[@values.SvgPaint]

///|
pub impl SvgPaintInputFallbacks for Array[@values.SvgPaint] with fn fallback_inputs(
  self,
) {
  self.map(value => SvgPaintInput::property_input(value))
}

///|
pub impl BoxSizeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait BoxSizeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BoxSizeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BoxSizeFallbacks::new() -> BoxSizeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BoxSizeInput] BoxSizeFallbacks::add(
  self : BoxSizeFallbacks,
  value : T,
) -> BoxSizeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BoxSizeInputFallbacks for BoxSizeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BoxSizeFallbacks with BoxSizeInputFallbacks::{fallback_inputs}

///|
pub impl LengthInput for @values.CssWideKeyword with fn length_input(self) {
  static_input(self.to_css())
}

///|
pub trait LengthInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct LengthFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn LengthFallbacks::new() -> LengthFallbacks {
  { inputs: [], }
}

///|
pub fn[T : LengthInput] LengthFallbacks::add(
  self : LengthFallbacks,
  value : T,
) -> LengthFallbacks {
  { inputs: [..self.inputs, value.length_input()], }
}

///|
pub impl LengthInputFallbacks for LengthFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend LengthFallbacks with LengthInputFallbacks::{fallback_inputs}

///|
pub trait DisplayInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl DisplayInput for @properties.Display with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl DisplayInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait DisplayInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct DisplayFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn DisplayFallbacks::new() -> DisplayFallbacks {
  { inputs: [], }
}

///|
pub fn[T : DisplayInput] DisplayFallbacks::add(
  self : DisplayFallbacks,
  value : T,
) -> DisplayFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl DisplayInputFallbacks for DisplayFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend DisplayFallbacks with DisplayInputFallbacks::{fallback_inputs}

///|
pub trait PlaceItemsInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PlaceItemsInput for @properties.PlaceItems with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PlaceItemsInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait PlaceItemsInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PlaceItemsFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PlaceItemsFallbacks::new() -> PlaceItemsFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PlaceItemsInput] PlaceItemsFallbacks::add(
  self : PlaceItemsFallbacks,
  value : T,
) -> PlaceItemsFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PlaceItemsInputFallbacks for PlaceItemsFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PlaceItemsFallbacks with PlaceItemsInputFallbacks::{fallback_inputs}

///|
pub trait OverflowInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverflowInput for @properties.Overflow with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverflowInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait OverflowInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverflowFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverflowFallbacks::new() -> OverflowFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverflowInput] OverflowFallbacks::add(
  self : OverflowFallbacks,
  value : T,
) -> OverflowFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverflowInputFallbacks for OverflowFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverflowFallbacks with OverflowInputFallbacks::{fallback_inputs}

///|
pub trait CursorInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl CursorInput for @properties.Cursor with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl CursorInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait CursorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct CursorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn CursorFallbacks::new() -> CursorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : CursorInput] CursorFallbacks::add(
  self : CursorFallbacks,
  value : T,
) -> CursorFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl CursorInputFallbacks for CursorFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend CursorFallbacks with CursorInputFallbacks::{fallback_inputs}

///|
pub impl ColorInput for @values.CssWideKeyword with fn color_input(self) {
  static_input(self.to_css())
}

///|
pub trait ColorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ColorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ColorFallbacks::new() -> ColorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ColorInput] ColorFallbacks::add(
  self : ColorFallbacks,
  value : T,
) -> ColorFallbacks {
  { inputs: [..self.inputs, value.color_input()], }
}

///|
pub impl ColorInputFallbacks for ColorFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend ColorFallbacks with ColorInputFallbacks::{fallback_inputs}

///|
pub impl BorderRadiiInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderRadiiInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderRadiiFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderRadiiFallbacks::new() -> BorderRadiiFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderRadiiInput] BorderRadiiFallbacks::add(
  self : BorderRadiiFallbacks,
  value : T,
) -> BorderRadiiFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderRadiiInputFallbacks for BorderRadiiFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderRadiiFallbacks with BorderRadiiInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BorderStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderStyleInput for @properties.BorderStyle with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderStyleInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderStyleFallbacks::new() -> BorderStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderStyleInput] BorderStyleFallbacks::add(
  self : BorderStyleFallbacks,
  value : T,
) -> BorderStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderStyleInputFallbacks for BorderStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderStyleFallbacks with BorderStyleInputFallbacks::{
  fallback_inputs,
}

///|
pub impl CornerRadiusInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait CornerRadiusInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct CornerRadiusFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn CornerRadiusFallbacks::new() -> CornerRadiusFallbacks {
  { inputs: [], }
}

///|
pub fn[T : CornerRadiusInput] CornerRadiusFallbacks::add(
  self : CornerRadiusFallbacks,
  value : T,
) -> CornerRadiusFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl CornerRadiusInputFallbacks for CornerRadiusFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend CornerRadiusFallbacks with CornerRadiusInputFallbacks::{
  fallback_inputs,
}

///|
pub impl FontSizeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait FontSizeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontSizeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontSizeFallbacks::new() -> FontSizeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontSizeInput] FontSizeFallbacks::add(
  self : FontSizeFallbacks,
  value : T,
) -> FontSizeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontSizeInputFallbacks for FontSizeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontSizeFallbacks with FontSizeInputFallbacks::{fallback_inputs}

///|
pub trait IntInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl IntInput for Int32 with fn property_input(self) {
  let value = self
  static_input(value.to_string())
}

///|
pub impl IntInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait IntInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct IntFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn IntFallbacks::new() -> IntFallbacks {
  { inputs: [], }
}

///|
pub fn[T : IntInput] IntFallbacks::add(
  self : IntFallbacks,
  value : T,
) -> IntFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl IntInputFallbacks for IntFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend IntFallbacks with IntInputFallbacks::{fallback_inputs}

///|
pub impl LineHeightInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait LineHeightInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct LineHeightFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn LineHeightFallbacks::new() -> LineHeightFallbacks {
  { inputs: [], }
}

///|
pub fn[T : LineHeightInput] LineHeightFallbacks::add(
  self : LineHeightFallbacks,
  value : T,
) -> LineHeightFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl LineHeightInputFallbacks for LineHeightFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend LineHeightFallbacks with LineHeightInputFallbacks::{fallback_inputs}

///|
pub trait DoubleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl DoubleInput for Double with fn property_input(self) {
  let value = self
  static_input(value.to_string())
}

///|
pub impl DoubleInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait DoubleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct DoubleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn DoubleFallbacks::new() -> DoubleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : DoubleInput] DoubleFallbacks::add(
  self : DoubleFallbacks,
  value : T,
) -> DoubleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl DoubleInputFallbacks for DoubleFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend DoubleFallbacks with DoubleInputFallbacks::{fallback_inputs}

///|
pub trait StringInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl StringInput for String with fn property_input(self) {
  let value = self
  static_input(value)
}

///|
pub impl StringInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait StringInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct StringFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn StringFallbacks::new() -> StringFallbacks {
  { inputs: [], }
}

///|
pub fn[T : StringInput] StringFallbacks::add(
  self : StringFallbacks,
  value : T,
) -> StringFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl StringInputFallbacks for StringFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend StringFallbacks with StringInputFallbacks::{fallback_inputs}

///|
pub trait BoxShadowListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BoxShadowListInput for @values.BoxShadowList with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl BoxShadowListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BoxShadowListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BoxShadowListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BoxShadowListFallbacks::new() -> BoxShadowListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BoxShadowListInput] BoxShadowListFallbacks::add(
  self : BoxShadowListFallbacks,
  value : T,
) -> BoxShadowListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BoxShadowListInputFallbacks for BoxShadowListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BoxShadowListFallbacks with BoxShadowListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FilterListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FilterListInput for @values.FilterList with fn property_input(self) {
  expression_input(self.expression())
}

///|
pub impl FilterListInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait FilterListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FilterListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FilterListFallbacks::new() -> FilterListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FilterListInput] FilterListFallbacks::add(
  self : FilterListFallbacks,
  value : T,
) -> FilterListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FilterListInputFallbacks for FilterListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FilterListFallbacks with FilterListInputFallbacks::{fallback_inputs}

///|
pub trait TextShadowListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextShadowListInput for @values.TextShadowList with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl TextShadowListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextShadowListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextShadowListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextShadowListFallbacks::new() -> TextShadowListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextShadowListInput] TextShadowListFallbacks::add(
  self : TextShadowListFallbacks,
  value : T,
) -> TextShadowListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextShadowListInputFallbacks for TextShadowListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextShadowListFallbacks with TextShadowListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait GridTemplateAreasInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl GridTemplateAreasInput for @values.GridTemplateAreas with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl GridTemplateAreasInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait GridTemplateAreasInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct GridTemplateAreasFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn GridTemplateAreasFallbacks::new() -> GridTemplateAreasFallbacks {
  { inputs: [], }
}

///|
pub fn[T : GridTemplateAreasInput] GridTemplateAreasFallbacks::add(
  self : GridTemplateAreasFallbacks,
  value : T,
) -> GridTemplateAreasFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl GridTemplateAreasInputFallbacks for GridTemplateAreasFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend GridTemplateAreasFallbacks with GridTemplateAreasInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ContainerNamesInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ContainerNamesInput for @values.ContainerNames with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ContainerNamesInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ContainerNamesInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ContainerNamesFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ContainerNamesFallbacks::new() -> ContainerNamesFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ContainerNamesInput] ContainerNamesFallbacks::add(
  self : ContainerNamesFallbacks,
  value : T,
) -> ContainerNamesFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ContainerNamesInputFallbacks for ContainerNamesFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ContainerNamesFallbacks with ContainerNamesInputFallbacks::{
  fallback_inputs,
}

///|
pub trait MaskImageListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MaskImageListInput for @values.MaskImageList with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MaskImageListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait MaskImageListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MaskImageListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MaskImageListFallbacks::new() -> MaskImageListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MaskImageListInput] MaskImageListFallbacks::add(
  self : MaskImageListFallbacks,
  value : T,
) -> MaskImageListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MaskImageListInputFallbacks for MaskImageListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MaskImageListFallbacks with MaskImageListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionListInput for @values.PositionList with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionListFallbacks::new() -> PositionListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionListInput] PositionListFallbacks::add(
  self : PositionListFallbacks,
  value : T,
) -> PositionListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionListInputFallbacks for PositionListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionListFallbacks with PositionListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait RepeatStyleListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl RepeatStyleListInput for @values.RepeatStyleList with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl RepeatStyleListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait RepeatStyleListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct RepeatStyleListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn RepeatStyleListFallbacks::new() -> RepeatStyleListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : RepeatStyleListInput] RepeatStyleListFallbacks::add(
  self : RepeatStyleListFallbacks,
  value : T,
) -> RepeatStyleListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl RepeatStyleListInputFallbacks for RepeatStyleListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend RepeatStyleListFallbacks with RepeatStyleListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BackgroundSizeListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BackgroundSizeListInput for @values.BackgroundSizeList with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BackgroundSizeListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BackgroundSizeListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BackgroundSizeListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BackgroundSizeListFallbacks::new() -> BackgroundSizeListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BackgroundSizeListInput] BackgroundSizeListFallbacks::add(
  self : BackgroundSizeListFallbacks,
  value : T,
) -> BackgroundSizeListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BackgroundSizeListInputFallbacks for BackgroundSizeListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BackgroundSizeListFallbacks with BackgroundSizeListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ClipPathInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ClipPathInput for @values.ClipPath with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ClipPathInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait ClipPathInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ClipPathFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ClipPathFallbacks::new() -> ClipPathFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ClipPathInput] ClipPathFallbacks::add(
  self : ClipPathFallbacks,
  value : T,
) -> ClipPathFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ClipPathInputFallbacks for ClipPathFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ClipPathFallbacks with ClipPathInputFallbacks::{fallback_inputs}

///|
pub trait ContentValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ContentValueInput for @values.ContentValue with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ContentValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ContentValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ContentValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ContentValueFallbacks::new() -> ContentValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ContentValueInput] ContentValueFallbacks::add(
  self : ContentValueFallbacks,
  value : T,
) -> ContentValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ContentValueInputFallbacks for ContentValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ContentValueFallbacks with ContentValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait AnchorNamesInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AnchorNamesInput for @values.AnchorNames with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl AnchorNamesInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait AnchorNamesInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AnchorNamesFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AnchorNamesFallbacks::new() -> AnchorNamesFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AnchorNamesInput] AnchorNamesFallbacks::add(
  self : AnchorNamesFallbacks,
  value : T,
) -> AnchorNamesFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AnchorNamesInputFallbacks for AnchorNamesFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AnchorNamesFallbacks with AnchorNamesInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionAnchorInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionAnchorInput for @values.PositionAnchor with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionAnchorInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionAnchorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionAnchorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionAnchorFallbacks::new() -> PositionAnchorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionAnchorInput] PositionAnchorFallbacks::add(
  self : PositionAnchorFallbacks,
  value : T,
) -> PositionAnchorFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionAnchorInputFallbacks for PositionAnchorFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionAnchorFallbacks with PositionAnchorInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionAreaInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionAreaInput for @values.PositionArea with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionAreaInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionAreaInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionAreaFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionAreaFallbacks::new() -> PositionAreaFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionAreaInput] PositionAreaFallbacks::add(
  self : PositionAreaFallbacks,
  value : T,
) -> PositionAreaFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionAreaInputFallbacks for PositionAreaFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionAreaFallbacks with PositionAreaInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionTryValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionTryValueInput for @values.PositionTryValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionTryValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionTryValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionTryValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionTryValueFallbacks::new() -> PositionTryValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionTryValueInput] PositionTryValueFallbacks::add(
  self : PositionTryValueFallbacks,
  value : T,
) -> PositionTryValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionTryValueInputFallbacks for PositionTryValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionTryValueFallbacks with PositionTryValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionTryFallbacksInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionTryFallbacksInput for @values.PositionTryFallbacks with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionTryFallbacksInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionTryFallbacksInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionTryFallbacksFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionTryFallbacksFallbacks::new() -> PositionTryFallbacksFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionTryFallbacksInput] PositionTryFallbacksFallbacks::add(
  self : PositionTryFallbacksFallbacks,
  value : T,
) -> PositionTryFallbacksFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionTryFallbacksInputFallbacks for PositionTryFallbacksFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionTryFallbacksFallbacks with PositionTryFallbacksInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionTryOrderInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionTryOrderInput for @values.PositionTryOrder with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionTryOrderInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionTryOrderInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionTryOrderFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionTryOrderFallbacks::new() -> PositionTryOrderFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionTryOrderInput] PositionTryOrderFallbacks::add(
  self : PositionTryOrderFallbacks,
  value : T,
) -> PositionTryOrderFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionTryOrderInputFallbacks for PositionTryOrderFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionTryOrderFallbacks with PositionTryOrderInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ViewTransitionNameInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ViewTransitionNameInput for @values.ViewTransitionName with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ViewTransitionNameInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ViewTransitionNameInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ViewTransitionNameFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ViewTransitionNameFallbacks::new() -> ViewTransitionNameFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ViewTransitionNameInput] ViewTransitionNameFallbacks::add(
  self : ViewTransitionNameFallbacks,
  value : T,
) -> ViewTransitionNameFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ViewTransitionNameInputFallbacks for ViewTransitionNameFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ViewTransitionNameFallbacks with ViewTransitionNameInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ViewTransitionClassInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ViewTransitionClassInput for @values.ViewTransitionClass with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ViewTransitionClassInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ViewTransitionClassInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ViewTransitionClassFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ViewTransitionClassFallbacks::new() -> ViewTransitionClassFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ViewTransitionClassInput] ViewTransitionClassFallbacks::add(
  self : ViewTransitionClassFallbacks,
  value : T,
) -> ViewTransitionClassFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ViewTransitionClassInputFallbacks for ViewTransitionClassFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ViewTransitionClassFallbacks with ViewTransitionClassInputFallbacks::{
  fallback_inputs,
}

///|
pub impl TimeInput for @values.CssWideKeyword with fn time_input(self) {
  static_input(self.to_css())
}

///|
pub trait TimeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TimeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TimeFallbacks::new() -> TimeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TimeInput] TimeFallbacks::add(
  self : TimeFallbacks,
  value : T,
) -> TimeFallbacks {
  { inputs: [..self.inputs, value.time_input()], }
}

///|
pub impl TimeInputFallbacks for TimeFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend TimeFallbacks with TimeInputFallbacks::{fallback_inputs}

///|
pub impl FlexBasisInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait FlexBasisInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FlexBasisFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FlexBasisFallbacks::new() -> FlexBasisFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FlexBasisInput] FlexBasisFallbacks::add(
  self : FlexBasisFallbacks,
  value : T,
) -> FlexBasisFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FlexBasisInputFallbacks for FlexBasisFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FlexBasisFallbacks with FlexBasisInputFallbacks::{fallback_inputs}

///|
pub impl IntegerInput for @values.CssWideKeyword with fn integer_input(self) {
  static_input(self.to_css())
}

///|
pub trait IntegerInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct IntegerFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn IntegerFallbacks::new() -> IntegerFallbacks {
  { inputs: [], }
}

///|
pub fn[T : IntegerInput] IntegerFallbacks::add(
  self : IntegerFallbacks,
  value : T,
) -> IntegerFallbacks {
  { inputs: [..self.inputs, value.integer_input()], }
}

///|
pub impl IntegerInputFallbacks for IntegerFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend IntegerFallbacks with IntegerInputFallbacks::{fallback_inputs}

///|
pub impl NumberInput for @values.CssWideKeyword with fn number_input(self) {
  static_input(self.to_css())
}

///|
pub trait NumberInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct NumberFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn NumberFallbacks::new() -> NumberFallbacks {
  { inputs: [], }
}

///|
pub fn[T : NumberInput] NumberFallbacks::add(
  self : NumberFallbacks,
  value : T,
) -> NumberFallbacks {
  { inputs: [..self.inputs, value.number_input()], }
}

///|
pub impl NumberInputFallbacks for NumberFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend NumberFallbacks with NumberInputFallbacks::{fallback_inputs}

///|
pub impl AngleInput for @values.CssWideKeyword with fn angle_input(self) {
  static_input(self.to_css())
}

///|
pub trait AngleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AngleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AngleFallbacks::new() -> AngleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AngleInput] AngleFallbacks::add(
  self : AngleFallbacks,
  value : T,
) -> AngleFallbacks {
  { inputs: [..self.inputs, value.angle_input()], }
}

///|
pub impl AngleInputFallbacks for AngleFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend AngleFallbacks with AngleInputFallbacks::{fallback_inputs}

///|
pub impl ImageInput for @values.CssWideKeyword with fn image_input(self) {
  static_input(self.to_css())
}

///|
pub trait ImageInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ImageFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ImageFallbacks::new() -> ImageFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ImageInput] ImageFallbacks::add(
  self : ImageFallbacks,
  value : T,
) -> ImageFallbacks {
  { inputs: [..self.inputs, value.image_input()], }
}

///|
pub impl ImageInputFallbacks for ImageFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend ImageFallbacks with ImageInputFallbacks::{fallback_inputs}

///|
pub trait PositionModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionModeInput for @properties.PositionMode with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionModeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionModeFallbacks::new() -> PositionModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionModeInput] PositionModeFallbacks::add(
  self : PositionModeFallbacks,
  value : T,
) -> PositionModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionModeInputFallbacks for PositionModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionModeFallbacks with PositionModeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BoxSizingInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BoxSizingInput for @properties.BoxSizing with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BoxSizingInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait BoxSizingInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BoxSizingFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BoxSizingFallbacks::new() -> BoxSizingFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BoxSizingInput] BoxSizingFallbacks::add(
  self : BoxSizingFallbacks,
  value : T,
) -> BoxSizingFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BoxSizingInputFallbacks for BoxSizingFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BoxSizingFallbacks with BoxSizingInputFallbacks::{fallback_inputs}

///|
pub trait VisibilityInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl VisibilityInput for @properties.Visibility with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl VisibilityInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait VisibilityInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct VisibilityFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn VisibilityFallbacks::new() -> VisibilityFallbacks {
  { inputs: [], }
}

///|
pub fn[T : VisibilityInput] VisibilityFallbacks::add(
  self : VisibilityFallbacks,
  value : T,
) -> VisibilityFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl VisibilityInputFallbacks for VisibilityFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend VisibilityFallbacks with VisibilityInputFallbacks::{fallback_inputs}

///|
pub trait FlexDirectionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FlexDirectionInput for @properties.FlexDirection with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FlexDirectionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FlexDirectionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FlexDirectionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FlexDirectionFallbacks::new() -> FlexDirectionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FlexDirectionInput] FlexDirectionFallbacks::add(
  self : FlexDirectionFallbacks,
  value : T,
) -> FlexDirectionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FlexDirectionInputFallbacks for FlexDirectionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FlexDirectionFallbacks with FlexDirectionInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FlexWrapInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FlexWrapInput for @properties.FlexWrap with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FlexWrapInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait FlexWrapInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FlexWrapFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FlexWrapFallbacks::new() -> FlexWrapFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FlexWrapInput] FlexWrapFallbacks::add(
  self : FlexWrapFallbacks,
  value : T,
) -> FlexWrapFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FlexWrapInputFallbacks for FlexWrapFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FlexWrapFallbacks with FlexWrapInputFallbacks::{fallback_inputs}

///|
pub trait AlignmentInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AlignmentInput for @properties.Alignment with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl AlignmentInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait AlignmentInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AlignmentFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AlignmentFallbacks::new() -> AlignmentFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AlignmentInput] AlignmentFallbacks::add(
  self : AlignmentFallbacks,
  value : T,
) -> AlignmentFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AlignmentInputFallbacks for AlignmentFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AlignmentFallbacks with AlignmentInputFallbacks::{fallback_inputs}

///|
pub trait RatioInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl RatioInput for @values.Ratio with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl RatioInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait RatioInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct RatioFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn RatioFallbacks::new() -> RatioFallbacks {
  { inputs: [], }
}

///|
pub fn[T : RatioInput] RatioFallbacks::add(
  self : RatioFallbacks,
  value : T,
) -> RatioFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl RatioInputFallbacks for RatioFallbacks with fn fallback_inputs(self) {
  self.inputs.copy()
}

///|
pub extend RatioFallbacks with RatioInputFallbacks::{fallback_inputs}

///|
pub trait ObjectFitInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ObjectFitInput for @properties.ObjectFit with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ObjectFitInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait ObjectFitInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ObjectFitFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ObjectFitFallbacks::new() -> ObjectFitFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ObjectFitInput] ObjectFitFallbacks::add(
  self : ObjectFitFallbacks,
  value : T,
) -> ObjectFitFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ObjectFitInputFallbacks for ObjectFitFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ObjectFitFallbacks with ObjectFitInputFallbacks::{fallback_inputs}

///|
pub trait FloatModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FloatModeInput for @properties.FloatMode with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FloatModeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait FloatModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FloatModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FloatModeFallbacks::new() -> FloatModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FloatModeInput] FloatModeFallbacks::add(
  self : FloatModeFallbacks,
  value : T,
) -> FloatModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FloatModeInputFallbacks for FloatModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FloatModeFallbacks with FloatModeInputFallbacks::{fallback_inputs}

///|
pub trait ClearModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ClearModeInput for @properties.ClearMode with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ClearModeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait ClearModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ClearModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ClearModeFallbacks::new() -> ClearModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ClearModeInput] ClearModeFallbacks::add(
  self : ClearModeFallbacks,
  value : T,
) -> ClearModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ClearModeInputFallbacks for ClearModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ClearModeFallbacks with ClearModeInputFallbacks::{fallback_inputs}

///|
pub trait ResizeModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ResizeModeInput for @properties.ResizeMode with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ResizeModeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait ResizeModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ResizeModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ResizeModeFallbacks::new() -> ResizeModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ResizeModeInput] ResizeModeFallbacks::add(
  self : ResizeModeFallbacks,
  value : T,
) -> ResizeModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ResizeModeInputFallbacks for ResizeModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ResizeModeFallbacks with ResizeModeInputFallbacks::{fallback_inputs}

///|
pub trait ContainInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ContainInput for @values.Contain with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ContainInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait ContainInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ContainFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ContainFallbacks::new() -> ContainFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ContainInput] ContainFallbacks::add(
  self : ContainFallbacks,
  value : T,
) -> ContainFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ContainInputFallbacks for ContainFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ContainFallbacks with ContainInputFallbacks::{fallback_inputs}

///|
pub trait GridAutoFlowInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl GridAutoFlowInput for @properties.GridAutoFlow with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl GridAutoFlowInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait GridAutoFlowInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct GridAutoFlowFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn GridAutoFlowFallbacks::new() -> GridAutoFlowFallbacks {
  { inputs: [], }
}

///|
pub fn[T : GridAutoFlowInput] GridAutoFlowFallbacks::add(
  self : GridAutoFlowFallbacks,
  value : T,
) -> GridAutoFlowFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl GridAutoFlowInputFallbacks for GridAutoFlowFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend GridAutoFlowFallbacks with GridAutoFlowInputFallbacks::{
  fallback_inputs,
}

///|
pub impl GridTrackListInput for @values.CssWideKeyword with fn grid_track_list_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait GridTrackListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct GridTrackListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn GridTrackListFallbacks::new() -> GridTrackListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : GridTrackListInput] GridTrackListFallbacks::add(
  self : GridTrackListFallbacks,
  value : T,
) -> GridTrackListFallbacks {
  { inputs: [..self.inputs, value.grid_track_list_input()], }
}

///|
pub impl GridTrackListInputFallbacks for GridTrackListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend GridTrackListFallbacks with GridTrackListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait GridLineInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl GridLineInput for @values.GridLine with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl GridLineInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait GridLineInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct GridLineFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn GridLineFallbacks::new() -> GridLineFallbacks {
  { inputs: [], }
}

///|
pub fn[T : GridLineInput] GridLineFallbacks::add(
  self : GridLineFallbacks,
  value : T,
) -> GridLineFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl GridLineInputFallbacks for GridLineFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend GridLineFallbacks with GridLineInputFallbacks::{fallback_inputs}

///|
pub trait TextAlignInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextAlignInput for @properties.TextAlign with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextAlignInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait TextAlignInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextAlignFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextAlignFallbacks::new() -> TextAlignFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextAlignInput] TextAlignFallbacks::add(
  self : TextAlignFallbacks,
  value : T,
) -> TextAlignFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextAlignInputFallbacks for TextAlignFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextAlignFallbacks with TextAlignInputFallbacks::{fallback_inputs}

///|
pub trait TextTransformInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextTransformInput for @properties.TextTransform with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextTransformInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextTransformInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextTransformFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextTransformFallbacks::new() -> TextTransformFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextTransformInput] TextTransformFallbacks::add(
  self : TextTransformFallbacks,
  value : T,
) -> TextTransformFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextTransformInputFallbacks for TextTransformFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextTransformFallbacks with TextTransformInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextDecorationLineInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextDecorationLineInput for @properties.TextDecorationLine with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextDecorationLineInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextDecorationLineInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextDecorationLineFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextDecorationLineFallbacks::new() -> TextDecorationLineFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextDecorationLineInput] TextDecorationLineFallbacks::add(
  self : TextDecorationLineFallbacks,
  value : T,
) -> TextDecorationLineFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextDecorationLineInputFallbacks for TextDecorationLineFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextDecorationLineFallbacks with TextDecorationLineInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextDecorationStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextDecorationStyleInput for @properties.TextDecorationStyle with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextDecorationStyleInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextDecorationStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextDecorationStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextDecorationStyleFallbacks::new() -> TextDecorationStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextDecorationStyleInput] TextDecorationStyleFallbacks::add(
  self : TextDecorationStyleFallbacks,
  value : T,
) -> TextDecorationStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextDecorationStyleInputFallbacks for TextDecorationStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextDecorationStyleFallbacks with TextDecorationStyleInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextUnderlinePositionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextUnderlinePositionInput for @properties.TextUnderlinePosition with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextUnderlinePositionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextUnderlinePositionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextUnderlinePositionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextUnderlinePositionFallbacks::new() -> TextUnderlinePositionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextUnderlinePositionInput] TextUnderlinePositionFallbacks::add(
  self : TextUnderlinePositionFallbacks,
  value : T,
) -> TextUnderlinePositionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextUnderlinePositionInputFallbacks for TextUnderlinePositionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextUnderlinePositionFallbacks with TextUnderlinePositionInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OverflowWrapInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverflowWrapInput for @properties.OverflowWrap with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverflowWrapInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OverflowWrapInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverflowWrapFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverflowWrapFallbacks::new() -> OverflowWrapFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverflowWrapInput] OverflowWrapFallbacks::add(
  self : OverflowWrapFallbacks,
  value : T,
) -> OverflowWrapFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverflowWrapInputFallbacks for OverflowWrapFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverflowWrapFallbacks with OverflowWrapInputFallbacks::{
  fallback_inputs,
}

///|
pub trait WordBreakInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl WordBreakInput for @properties.WordBreak with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl WordBreakInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait WordBreakInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct WordBreakFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn WordBreakFallbacks::new() -> WordBreakFallbacks {
  { inputs: [], }
}

///|
pub fn[T : WordBreakInput] WordBreakFallbacks::add(
  self : WordBreakFallbacks,
  value : T,
) -> WordBreakFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl WordBreakInputFallbacks for WordBreakFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend WordBreakFallbacks with WordBreakInputFallbacks::{fallback_inputs}

///|
pub trait HyphensInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl HyphensInput for @properties.Hyphens with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl HyphensInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait HyphensInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct HyphensFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn HyphensFallbacks::new() -> HyphensFallbacks {
  { inputs: [], }
}

///|
pub fn[T : HyphensInput] HyphensFallbacks::add(
  self : HyphensFallbacks,
  value : T,
) -> HyphensFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl HyphensInputFallbacks for HyphensFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend HyphensFallbacks with HyphensInputFallbacks::{fallback_inputs}

///|
pub trait TextOverflowInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextOverflowInput for @properties.TextOverflow with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextOverflowInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextOverflowInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextOverflowFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextOverflowFallbacks::new() -> TextOverflowFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextOverflowInput] TextOverflowFallbacks::add(
  self : TextOverflowFallbacks,
  value : T,
) -> TextOverflowFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextOverflowInputFallbacks for TextOverflowFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextOverflowFallbacks with TextOverflowInputFallbacks::{
  fallback_inputs,
}

///|
pub trait WhiteSpaceCollapseInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl WhiteSpaceCollapseInput for @properties.WhiteSpaceCollapse with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl WhiteSpaceCollapseInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait WhiteSpaceCollapseInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct WhiteSpaceCollapseFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn WhiteSpaceCollapseFallbacks::new() -> WhiteSpaceCollapseFallbacks {
  { inputs: [], }
}

///|
pub fn[T : WhiteSpaceCollapseInput] WhiteSpaceCollapseFallbacks::add(
  self : WhiteSpaceCollapseFallbacks,
  value : T,
) -> WhiteSpaceCollapseFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl WhiteSpaceCollapseInputFallbacks for WhiteSpaceCollapseFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend WhiteSpaceCollapseFallbacks with WhiteSpaceCollapseInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextWrapModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextWrapModeInput for @properties.TextWrapMode with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextWrapModeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextWrapModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextWrapModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextWrapModeFallbacks::new() -> TextWrapModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextWrapModeInput] TextWrapModeFallbacks::add(
  self : TextWrapModeFallbacks,
  value : T,
) -> TextWrapModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextWrapModeInputFallbacks for TextWrapModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextWrapModeFallbacks with TextWrapModeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextWrapStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextWrapStyleInput for @properties.TextWrapStyle with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextWrapStyleInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextWrapStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextWrapStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextWrapStyleFallbacks::new() -> TextWrapStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextWrapStyleInput] TextWrapStyleFallbacks::add(
  self : TextWrapStyleFallbacks,
  value : T,
) -> TextWrapStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextWrapStyleInputFallbacks for TextWrapStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextWrapStyleFallbacks with TextWrapStyleInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontStyleInput for @properties.FontStyle with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontStyleInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait FontStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontStyleFallbacks::new() -> FontStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontStyleInput] FontStyleFallbacks::add(
  self : FontStyleFallbacks,
  value : T,
) -> FontStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontStyleInputFallbacks for FontStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontStyleFallbacks with FontStyleInputFallbacks::{fallback_inputs}

///|
pub trait FontStretchInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontStretchInput for @properties.FontStretch with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontStretchInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontStretchInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontStretchFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontStretchFallbacks::new() -> FontStretchFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontStretchInput] FontStretchFallbacks::add(
  self : FontStretchFallbacks,
  value : T,
) -> FontStretchFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontStretchInputFallbacks for FontStretchFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontStretchFallbacks with FontStretchInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontKerningInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontKerningInput for @properties.FontKerning with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontKerningInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontKerningInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontKerningFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontKerningFallbacks::new() -> FontKerningFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontKerningInput] FontKerningFallbacks::add(
  self : FontKerningFallbacks,
  value : T,
) -> FontKerningFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontKerningInputFallbacks for FontKerningFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontKerningFallbacks with FontKerningInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontOpticalSizingInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontOpticalSizingInput for @properties.FontOpticalSizing with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontOpticalSizingInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontOpticalSizingInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontOpticalSizingFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontOpticalSizingFallbacks::new() -> FontOpticalSizingFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontOpticalSizingInput] FontOpticalSizingFallbacks::add(
  self : FontOpticalSizingFallbacks,
  value : T,
) -> FontOpticalSizingFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontOpticalSizingInputFallbacks for FontOpticalSizingFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontOpticalSizingFallbacks with FontOpticalSizingInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontVariantCapsInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontVariantCapsInput for @properties.FontVariantCaps with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontVariantCapsInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontVariantCapsInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontVariantCapsFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontVariantCapsFallbacks::new() -> FontVariantCapsFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontVariantCapsInput] FontVariantCapsFallbacks::add(
  self : FontVariantCapsFallbacks,
  value : T,
) -> FontVariantCapsFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontVariantCapsInputFallbacks for FontVariantCapsFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontVariantCapsFallbacks with FontVariantCapsInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontVariantNumericInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontVariantNumericInput for @values.FontVariantNumeric with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontVariantNumericInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontVariantNumericInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontVariantNumericFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontVariantNumericFallbacks::new() -> FontVariantNumericFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontVariantNumericInput] FontVariantNumericFallbacks::add(
  self : FontVariantNumericFallbacks,
  value : T,
) -> FontVariantNumericFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontVariantNumericInputFallbacks for FontVariantNumericFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontVariantNumericFallbacks with FontVariantNumericInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ListStylePositionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ListStylePositionInput for @properties.ListStylePosition with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ListStylePositionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ListStylePositionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ListStylePositionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ListStylePositionFallbacks::new() -> ListStylePositionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ListStylePositionInput] ListStylePositionFallbacks::add(
  self : ListStylePositionFallbacks,
  value : T,
) -> ListStylePositionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ListStylePositionInputFallbacks for ListStylePositionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ListStylePositionFallbacks with ListStylePositionInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BackgroundAttachmentInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BackgroundAttachmentInput for @properties.BackgroundAttachment with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BackgroundAttachmentInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BackgroundAttachmentInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BackgroundAttachmentFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BackgroundAttachmentFallbacks::new() -> BackgroundAttachmentFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BackgroundAttachmentInput] BackgroundAttachmentFallbacks::add(
  self : BackgroundAttachmentFallbacks,
  value : T,
) -> BackgroundAttachmentFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BackgroundAttachmentInputFallbacks for BackgroundAttachmentFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BackgroundAttachmentFallbacks with BackgroundAttachmentInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BackgroundBoxInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BackgroundBoxInput for @properties.BackgroundBox with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BackgroundBoxInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BackgroundBoxInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BackgroundBoxFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BackgroundBoxFallbacks::new() -> BackgroundBoxFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BackgroundBoxInput] BackgroundBoxFallbacks::add(
  self : BackgroundBoxFallbacks,
  value : T,
) -> BackgroundBoxFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BackgroundBoxInputFallbacks for BackgroundBoxFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BackgroundBoxFallbacks with BackgroundBoxInputFallbacks::{
  fallback_inputs,
}

///|
pub trait RepeatStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl RepeatStyleInput for @values.RepeatStyle with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl RepeatStyleInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait RepeatStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct RepeatStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn RepeatStyleFallbacks::new() -> RepeatStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : RepeatStyleInput] RepeatStyleFallbacks::add(
  self : RepeatStyleFallbacks,
  value : T,
) -> RepeatStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl RepeatStyleInputFallbacks for RepeatStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend RepeatStyleFallbacks with RepeatStyleInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionInput for @values.Position with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait PositionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionFallbacks::new() -> PositionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionInput] PositionFallbacks::add(
  self : PositionFallbacks,
  value : T,
) -> PositionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionInputFallbacks for PositionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionFallbacks with PositionInputFallbacks::{fallback_inputs}

///|
pub trait BackgroundSizeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BackgroundSizeInput for @values.BackgroundSize with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BackgroundSizeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BackgroundSizeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BackgroundSizeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BackgroundSizeFallbacks::new() -> BackgroundSizeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BackgroundSizeInput] BackgroundSizeFallbacks::add(
  self : BackgroundSizeFallbacks,
  value : T,
) -> BackgroundSizeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BackgroundSizeInputFallbacks for BackgroundSizeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BackgroundSizeFallbacks with BackgroundSizeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BlendModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BlendModeInput for @properties.BlendMode with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BlendModeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait BlendModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BlendModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BlendModeFallbacks::new() -> BlendModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BlendModeInput] BlendModeFallbacks::add(
  self : BlendModeFallbacks,
  value : T,
) -> BlendModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BlendModeInputFallbacks for BlendModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BlendModeFallbacks with BlendModeInputFallbacks::{fallback_inputs}

///|
pub trait ImageRenderingInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ImageRenderingInput for @properties.ImageRendering with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ImageRenderingInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ImageRenderingInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ImageRenderingFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ImageRenderingFallbacks::new() -> ImageRenderingFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ImageRenderingInput] ImageRenderingFallbacks::add(
  self : ImageRenderingFallbacks,
  value : T,
) -> ImageRenderingFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ImageRenderingInputFallbacks for ImageRenderingFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ImageRenderingFallbacks with ImageRenderingInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TransformListInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TransformListInput for @values.TransformList with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl TransformListInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TransformListInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TransformListFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TransformListFallbacks::new() -> TransformListFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TransformListInput] TransformListFallbacks::add(
  self : TransformListFallbacks,
  value : T,
) -> TransformListFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TransformListInputFallbacks for TransformListFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TransformListFallbacks with TransformListInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TransformOriginInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TransformOriginInput for @values.TransformOrigin with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TransformOriginInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TransformOriginInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TransformOriginFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TransformOriginFallbacks::new() -> TransformOriginFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TransformOriginInput] TransformOriginFallbacks::add(
  self : TransformOriginFallbacks,
  value : T,
) -> TransformOriginFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TransformOriginInputFallbacks for TransformOriginFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TransformOriginFallbacks with TransformOriginInputFallbacks::{
  fallback_inputs,
}

///|
pub trait AnimationIterationsInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AnimationIterationsInput for @values.AnimationIterations with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl AnimationIterationsInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait AnimationIterationsInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AnimationIterationsFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AnimationIterationsFallbacks::new() -> AnimationIterationsFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AnimationIterationsInput] AnimationIterationsFallbacks::add(
  self : AnimationIterationsFallbacks,
  value : T,
) -> AnimationIterationsFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AnimationIterationsInputFallbacks for AnimationIterationsFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AnimationIterationsFallbacks with AnimationIterationsInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BackfaceVisibilityInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BackfaceVisibilityInput for @properties.BackfaceVisibility with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BackfaceVisibilityInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BackfaceVisibilityInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BackfaceVisibilityFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BackfaceVisibilityFallbacks::new() -> BackfaceVisibilityFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BackfaceVisibilityInput] BackfaceVisibilityFallbacks::add(
  self : BackfaceVisibilityFallbacks,
  value : T,
) -> BackfaceVisibilityFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BackfaceVisibilityInputFallbacks for BackfaceVisibilityFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BackfaceVisibilityFallbacks with BackfaceVisibilityInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TransformStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TransformStyleInput for @properties.TransformStyle with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TransformStyleInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TransformStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TransformStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TransformStyleFallbacks::new() -> TransformStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TransformStyleInput] TransformStyleFallbacks::add(
  self : TransformStyleFallbacks,
  value : T,
) -> TransformStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TransformStyleInputFallbacks for TransformStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TransformStyleFallbacks with TransformStyleInputFallbacks::{
  fallback_inputs,
}

///|
pub struct AnimationDirectionList {
  values : Array[@properties.AnimationDirection]
}

///|
pub fn AnimationDirectionList::new(
  values : Array[@properties.AnimationDirection],
) -> AnimationDirectionList {
  { values: values.copy(), }
}

///|
pub fn AnimationDirectionList::to_css(self : AnimationDirectionList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "AnimationDirection-list",
  ).to_css()
}

///|
pub impl AnimationDirectionInput for AnimationDirectionList with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub extend AnimationDirectionList with AnimationDirectionInput::{property_input}

///|
pub trait AnimationDirectionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AnimationDirectionInput for @properties.AnimationDirection with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl AnimationDirectionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait AnimationDirectionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AnimationDirectionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AnimationDirectionFallbacks::new() -> AnimationDirectionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AnimationDirectionInput] AnimationDirectionFallbacks::add(
  self : AnimationDirectionFallbacks,
  value : T,
) -> AnimationDirectionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AnimationDirectionInputFallbacks for AnimationDirectionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AnimationDirectionFallbacks with AnimationDirectionInputFallbacks::{
  fallback_inputs,
}

///|
pub struct AnimationFillModeList {
  values : Array[@properties.AnimationFillMode]
}

///|
pub fn AnimationFillModeList::new(
  values : Array[@properties.AnimationFillMode],
) -> AnimationFillModeList {
  { values: values.copy(), }
}

///|
pub fn AnimationFillModeList::to_css(self : AnimationFillModeList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "AnimationFillMode-list",
  ).to_css()
}

///|
pub impl AnimationFillModeInput for AnimationFillModeList with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub extend AnimationFillModeList with AnimationFillModeInput::{property_input}

///|
pub trait AnimationFillModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AnimationFillModeInput for @properties.AnimationFillMode with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl AnimationFillModeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait AnimationFillModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AnimationFillModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AnimationFillModeFallbacks::new() -> AnimationFillModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AnimationFillModeInput] AnimationFillModeFallbacks::add(
  self : AnimationFillModeFallbacks,
  value : T,
) -> AnimationFillModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AnimationFillModeInputFallbacks for AnimationFillModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AnimationFillModeFallbacks with AnimationFillModeInputFallbacks::{
  fallback_inputs,
}

///|
pub struct AnimationPlayStateList {
  values : Array[@properties.AnimationPlayState]
}

///|
pub fn AnimationPlayStateList::new(
  values : Array[@properties.AnimationPlayState],
) -> AnimationPlayStateList {
  { values: values.copy(), }
}

///|
pub fn AnimationPlayStateList::to_css(self : AnimationPlayStateList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "AnimationPlayState-list",
  ).to_css()
}

///|
pub impl AnimationPlayStateInput for AnimationPlayStateList with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub extend AnimationPlayStateList with AnimationPlayStateInput::{property_input}

///|
pub trait AnimationPlayStateInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AnimationPlayStateInput for @properties.AnimationPlayState with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl AnimationPlayStateInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait AnimationPlayStateInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AnimationPlayStateFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AnimationPlayStateFallbacks::new() -> AnimationPlayStateFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AnimationPlayStateInput] AnimationPlayStateFallbacks::add(
  self : AnimationPlayStateFallbacks,
  value : T,
) -> AnimationPlayStateFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AnimationPlayStateInputFallbacks for AnimationPlayStateFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AnimationPlayStateFallbacks with AnimationPlayStateInputFallbacks::{
  fallback_inputs,
}

///|
pub struct EasingFunctionList {
  values : Array[@values.EasingFunction]
}

///|
pub fn EasingFunctionList::new(
  values : Array[@values.EasingFunction],
) -> EasingFunctionList {
  { values: values.copy(), }
}

///|
pub fn EasingFunctionList::to_css(self : EasingFunctionList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "EasingFunction-list",
  ).to_css()
}

///|
pub impl EasingFunctionInput for EasingFunctionList with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub extend EasingFunctionList with EasingFunctionInput::{property_input}

///|
pub trait EasingFunctionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl EasingFunctionInput for @values.EasingFunction with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl EasingFunctionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait EasingFunctionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct EasingFunctionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn EasingFunctionFallbacks::new() -> EasingFunctionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : EasingFunctionInput] EasingFunctionFallbacks::add(
  self : EasingFunctionFallbacks,
  value : T,
) -> EasingFunctionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl EasingFunctionInputFallbacks for EasingFunctionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend EasingFunctionFallbacks with EasingFunctionInputFallbacks::{
  fallback_inputs,
}

///|
pub struct TransitionPropertyList {
  values : Array[@properties.TransitionProperty]
}

///|
pub fn TransitionPropertyList::new(
  values : Array[@properties.TransitionProperty],
) -> TransitionPropertyList {
  { values: values.copy(), }
}

///|
pub fn TransitionPropertyList::to_css(self : TransitionPropertyList) -> String {
  if self.values.length() > 1 &&
    self.values.contains(@properties.TransitionPropertyNone) {
    return @values.declaration_list([], "transition-property").to_css()
  }
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "TransitionProperty-list",
  ).to_css()
}

///|
pub impl TransitionPropertyInput for TransitionPropertyList with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub extend TransitionPropertyList with TransitionPropertyInput::{property_input}

///|
pub trait TransitionPropertyInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TransitionPropertyInput for @properties.TransitionProperty with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TransitionPropertyInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TransitionPropertyInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TransitionPropertyFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TransitionPropertyFallbacks::new() -> TransitionPropertyFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TransitionPropertyInput] TransitionPropertyFallbacks::add(
  self : TransitionPropertyFallbacks,
  value : T,
) -> TransitionPropertyFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TransitionPropertyInputFallbacks for TransitionPropertyFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TransitionPropertyFallbacks with TransitionPropertyInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PointerEventsInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PointerEventsInput for @properties.PointerEvents with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PointerEventsInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PointerEventsInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PointerEventsFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PointerEventsFallbacks::new() -> PointerEventsFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PointerEventsInput] PointerEventsFallbacks::add(
  self : PointerEventsFallbacks,
  value : T,
) -> PointerEventsFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PointerEventsInputFallbacks for PointerEventsFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PointerEventsFallbacks with PointerEventsInputFallbacks::{
  fallback_inputs,
}

///|
pub trait UserSelectInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl UserSelectInput for @properties.UserSelect with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl UserSelectInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait UserSelectInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct UserSelectFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn UserSelectFallbacks::new() -> UserSelectFallbacks {
  { inputs: [], }
}

///|
pub fn[T : UserSelectInput] UserSelectFallbacks::add(
  self : UserSelectFallbacks,
  value : T,
) -> UserSelectFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl UserSelectInputFallbacks for UserSelectFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend UserSelectFallbacks with UserSelectInputFallbacks::{fallback_inputs}

///|
pub trait TouchActionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TouchActionInput for @values.TouchAction with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TouchActionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TouchActionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TouchActionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TouchActionFallbacks::new() -> TouchActionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TouchActionInput] TouchActionFallbacks::add(
  self : TouchActionFallbacks,
  value : T,
) -> TouchActionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TouchActionInputFallbacks for TouchActionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TouchActionFallbacks with TouchActionInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollBehaviorInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollBehaviorInput for @properties.ScrollBehavior with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ScrollBehaviorInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollBehaviorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollBehaviorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollBehaviorFallbacks::new() -> ScrollBehaviorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollBehaviorInput] ScrollBehaviorFallbacks::add(
  self : ScrollBehaviorFallbacks,
  value : T,
) -> ScrollBehaviorFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollBehaviorInputFallbacks for ScrollBehaviorFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollBehaviorFallbacks with ScrollBehaviorInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OverscrollBehaviorInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverscrollBehaviorInput for @properties.OverscrollBehavior with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverscrollBehaviorInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OverscrollBehaviorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverscrollBehaviorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverscrollBehaviorFallbacks::new() -> OverscrollBehaviorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverscrollBehaviorInput] OverscrollBehaviorFallbacks::add(
  self : OverscrollBehaviorFallbacks,
  value : T,
) -> OverscrollBehaviorFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverscrollBehaviorInputFallbacks for OverscrollBehaviorFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverscrollBehaviorFallbacks with OverscrollBehaviorInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ContentVisibilityInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ContentVisibilityInput for @properties.ContentVisibility with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ContentVisibilityInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ContentVisibilityInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ContentVisibilityFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ContentVisibilityFallbacks::new() -> ContentVisibilityFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ContentVisibilityInput] ContentVisibilityFallbacks::add(
  self : ContentVisibilityFallbacks,
  value : T,
) -> ContentVisibilityFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ContentVisibilityInputFallbacks for ContentVisibilityFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ContentVisibilityFallbacks with ContentVisibilityInputFallbacks::{
  fallback_inputs,
}

///|
pub impl LengthPercentageInput for @values.CssWideKeyword with fn length_percentage_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait LengthPercentageInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct LengthPercentageFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn LengthPercentageFallbacks::new() -> LengthPercentageFallbacks {
  { inputs: [], }
}

///|
pub fn[T : LengthPercentageInput] LengthPercentageFallbacks::add(
  self : LengthPercentageFallbacks,
  value : T,
) -> LengthPercentageFallbacks {
  { inputs: [..self.inputs, value.length_percentage_input()], }
}

///|
pub impl LengthPercentageInputFallbacks for LengthPercentageFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend LengthPercentageFallbacks with LengthPercentageInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BaselineSourceValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BaselineSourceValueInput for @properties.BaselineSourceValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BaselineSourceValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BaselineSourceValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BaselineSourceValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BaselineSourceValueFallbacks::new() -> BaselineSourceValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BaselineSourceValueInput] BaselineSourceValueFallbacks::add(
  self : BaselineSourceValueFallbacks,
  value : T,
) -> BaselineSourceValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BaselineSourceValueInputFallbacks for BaselineSourceValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BaselineSourceValueFallbacks with BaselineSourceValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BorderCollapseValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderCollapseValueInput for @properties.BorderCollapseValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderCollapseValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderCollapseValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderCollapseValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderCollapseValueFallbacks::new() -> BorderCollapseValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderCollapseValueInput] BorderCollapseValueFallbacks::add(
  self : BorderCollapseValueFallbacks,
  value : T,
) -> BorderCollapseValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderCollapseValueInputFallbacks for BorderCollapseValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderCollapseValueFallbacks with BorderCollapseValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BorderImageRepeatValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderImageRepeatValueInput for @properties.BorderImageRepeatValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderImageRepeatValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderImageRepeatValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderImageRepeatValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderImageRepeatValueFallbacks::new() -> BorderImageRepeatValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderImageRepeatValueInput] BorderImageRepeatValueFallbacks::add(
  self : BorderImageRepeatValueFallbacks,
  value : T,
) -> BorderImageRepeatValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderImageRepeatValueInputFallbacks for BorderImageRepeatValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderImageRepeatValueFallbacks with BorderImageRepeatValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BoxDecorationBreakValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BoxDecorationBreakValueInput for @properties.BoxDecorationBreakValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BoxDecorationBreakValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BoxDecorationBreakValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BoxDecorationBreakValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BoxDecorationBreakValueFallbacks::new() -> BoxDecorationBreakValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BoxDecorationBreakValueInput] BoxDecorationBreakValueFallbacks::add(
  self : BoxDecorationBreakValueFallbacks,
  value : T,
) -> BoxDecorationBreakValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BoxDecorationBreakValueInputFallbacks for BoxDecorationBreakValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BoxDecorationBreakValueFallbacks with BoxDecorationBreakValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BreakAfterValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BreakAfterValueInput for @properties.BreakAfterValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BreakAfterValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BreakAfterValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BreakAfterValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BreakAfterValueFallbacks::new() -> BreakAfterValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BreakAfterValueInput] BreakAfterValueFallbacks::add(
  self : BreakAfterValueFallbacks,
  value : T,
) -> BreakAfterValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BreakAfterValueInputFallbacks for BreakAfterValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BreakAfterValueFallbacks with BreakAfterValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BreakBeforeValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BreakBeforeValueInput for @properties.BreakBeforeValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BreakBeforeValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BreakBeforeValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BreakBeforeValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BreakBeforeValueFallbacks::new() -> BreakBeforeValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BreakBeforeValueInput] BreakBeforeValueFallbacks::add(
  self : BreakBeforeValueFallbacks,
  value : T,
) -> BreakBeforeValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BreakBeforeValueInputFallbacks for BreakBeforeValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BreakBeforeValueFallbacks with BreakBeforeValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BreakInsideValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BreakInsideValueInput for @properties.BreakInsideValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BreakInsideValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BreakInsideValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BreakInsideValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BreakInsideValueFallbacks::new() -> BreakInsideValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BreakInsideValueInput] BreakInsideValueFallbacks::add(
  self : BreakInsideValueFallbacks,
  value : T,
) -> BreakInsideValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BreakInsideValueInputFallbacks for BreakInsideValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BreakInsideValueFallbacks with BreakInsideValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait CaptionSideValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl CaptionSideValueInput for @properties.CaptionSideValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl CaptionSideValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait CaptionSideValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct CaptionSideValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn CaptionSideValueFallbacks::new() -> CaptionSideValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : CaptionSideValueInput] CaptionSideValueFallbacks::add(
  self : CaptionSideValueFallbacks,
  value : T,
) -> CaptionSideValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl CaptionSideValueInputFallbacks for CaptionSideValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend CaptionSideValueFallbacks with CaptionSideValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ClipRuleValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ClipRuleValueInput for @properties.ClipRuleValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ClipRuleValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ClipRuleValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ClipRuleValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ClipRuleValueFallbacks::new() -> ClipRuleValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ClipRuleValueInput] ClipRuleValueFallbacks::add(
  self : ClipRuleValueFallbacks,
  value : T,
) -> ClipRuleValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ClipRuleValueInputFallbacks for ClipRuleValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ClipRuleValueFallbacks with ClipRuleValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ColorInterpolationFiltersValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ColorInterpolationFiltersValueInput for @properties.ColorInterpolationFiltersValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ColorInterpolationFiltersValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ColorInterpolationFiltersValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ColorInterpolationFiltersValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ColorInterpolationFiltersValueFallbacks::new() -> ColorInterpolationFiltersValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ColorInterpolationFiltersValueInput] ColorInterpolationFiltersValueFallbacks::add(
  self : ColorInterpolationFiltersValueFallbacks,
  value : T,
) -> ColorInterpolationFiltersValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ColorInterpolationFiltersValueInputFallbacks for ColorInterpolationFiltersValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ColorInterpolationFiltersValueFallbacks with ColorInterpolationFiltersValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ColumnFillValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ColumnFillValueInput for @properties.ColumnFillValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ColumnFillValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ColumnFillValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ColumnFillValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ColumnFillValueFallbacks::new() -> ColumnFillValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ColumnFillValueInput] ColumnFillValueFallbacks::add(
  self : ColumnFillValueFallbacks,
  value : T,
) -> ColumnFillValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ColumnFillValueInputFallbacks for ColumnFillValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ColumnFillValueFallbacks with ColumnFillValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ColumnSpanValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ColumnSpanValueInput for @properties.ColumnSpanValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ColumnSpanValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ColumnSpanValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ColumnSpanValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ColumnSpanValueFallbacks::new() -> ColumnSpanValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ColumnSpanValueInput] ColumnSpanValueFallbacks::add(
  self : ColumnSpanValueFallbacks,
  value : T,
) -> ColumnSpanValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ColumnSpanValueInputFallbacks for ColumnSpanValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ColumnSpanValueFallbacks with ColumnSpanValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ContainerTypeValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ContainerTypeValueInput for @properties.ContainerTypeValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ContainerTypeValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ContainerTypeValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ContainerTypeValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ContainerTypeValueFallbacks::new() -> ContainerTypeValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ContainerTypeValueInput] ContainerTypeValueFallbacks::add(
  self : ContainerTypeValueFallbacks,
  value : T,
) -> ContainerTypeValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ContainerTypeValueInputFallbacks for ContainerTypeValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ContainerTypeValueFallbacks with ContainerTypeValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait DirectionValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl DirectionValueInput for @properties.DirectionValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl DirectionValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait DirectionValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct DirectionValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn DirectionValueFallbacks::new() -> DirectionValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : DirectionValueInput] DirectionValueFallbacks::add(
  self : DirectionValueFallbacks,
  value : T,
) -> DirectionValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl DirectionValueInputFallbacks for DirectionValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend DirectionValueFallbacks with DirectionValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait EmptyCellsValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl EmptyCellsValueInput for @properties.EmptyCellsValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl EmptyCellsValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait EmptyCellsValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct EmptyCellsValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn EmptyCellsValueFallbacks::new() -> EmptyCellsValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : EmptyCellsValueInput] EmptyCellsValueFallbacks::add(
  self : EmptyCellsValueFallbacks,
  value : T,
) -> EmptyCellsValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl EmptyCellsValueInputFallbacks for EmptyCellsValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend EmptyCellsValueFallbacks with EmptyCellsValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FieldSizingValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FieldSizingValueInput for @properties.FieldSizingValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FieldSizingValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FieldSizingValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FieldSizingValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FieldSizingValueFallbacks::new() -> FieldSizingValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FieldSizingValueInput] FieldSizingValueFallbacks::add(
  self : FieldSizingValueFallbacks,
  value : T,
) -> FieldSizingValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FieldSizingValueInputFallbacks for FieldSizingValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FieldSizingValueFallbacks with FieldSizingValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FillRuleValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FillRuleValueInput for @properties.FillRuleValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FillRuleValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FillRuleValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FillRuleValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FillRuleValueFallbacks::new() -> FillRuleValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FillRuleValueInput] FillRuleValueFallbacks::add(
  self : FillRuleValueFallbacks,
  value : T,
) -> FillRuleValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FillRuleValueInputFallbacks for FillRuleValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FillRuleValueFallbacks with FillRuleValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontSynthesisValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontSynthesisValueInput for @properties.FontSynthesisValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontSynthesisValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontSynthesisValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontSynthesisValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontSynthesisValueFallbacks::new() -> FontSynthesisValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontSynthesisValueInput] FontSynthesisValueFallbacks::add(
  self : FontSynthesisValueFallbacks,
  value : T,
) -> FontSynthesisValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontSynthesisValueInputFallbacks for FontSynthesisValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontSynthesisValueFallbacks with FontSynthesisValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontSynthesisSmallCapsValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontSynthesisSmallCapsValueInput for @properties.FontSynthesisSmallCapsValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontSynthesisSmallCapsValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontSynthesisSmallCapsValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontSynthesisSmallCapsValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontSynthesisSmallCapsValueFallbacks::new() -> FontSynthesisSmallCapsValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontSynthesisSmallCapsValueInput] FontSynthesisSmallCapsValueFallbacks::add(
  self : FontSynthesisSmallCapsValueFallbacks,
  value : T,
) -> FontSynthesisSmallCapsValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontSynthesisSmallCapsValueInputFallbacks for FontSynthesisSmallCapsValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontSynthesisSmallCapsValueFallbacks with FontSynthesisSmallCapsValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontSynthesisStyleValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontSynthesisStyleValueInput for @properties.FontSynthesisStyleValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontSynthesisStyleValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontSynthesisStyleValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontSynthesisStyleValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontSynthesisStyleValueFallbacks::new() -> FontSynthesisStyleValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontSynthesisStyleValueInput] FontSynthesisStyleValueFallbacks::add(
  self : FontSynthesisStyleValueFallbacks,
  value : T,
) -> FontSynthesisStyleValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontSynthesisStyleValueInputFallbacks for FontSynthesisStyleValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontSynthesisStyleValueFallbacks with FontSynthesisStyleValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontSynthesisWeightValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontSynthesisWeightValueInput for @properties.FontSynthesisWeightValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontSynthesisWeightValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontSynthesisWeightValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontSynthesisWeightValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontSynthesisWeightValueFallbacks::new() -> FontSynthesisWeightValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontSynthesisWeightValueInput] FontSynthesisWeightValueFallbacks::add(
  self : FontSynthesisWeightValueFallbacks,
  value : T,
) -> FontSynthesisWeightValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontSynthesisWeightValueInputFallbacks for FontSynthesisWeightValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontSynthesisWeightValueFallbacks with FontSynthesisWeightValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontVariantEmojiValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontVariantEmojiValueInput for @properties.FontVariantEmojiValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontVariantEmojiValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontVariantEmojiValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontVariantEmojiValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontVariantEmojiValueFallbacks::new() -> FontVariantEmojiValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontVariantEmojiValueInput] FontVariantEmojiValueFallbacks::add(
  self : FontVariantEmojiValueFallbacks,
  value : T,
) -> FontVariantEmojiValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontVariantEmojiValueInputFallbacks for FontVariantEmojiValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontVariantEmojiValueFallbacks with FontVariantEmojiValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait FontVariantPositionValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl FontVariantPositionValueInput for @properties.FontVariantPositionValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl FontVariantPositionValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait FontVariantPositionValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct FontVariantPositionValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn FontVariantPositionValueFallbacks::new() -> FontVariantPositionValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : FontVariantPositionValueInput] FontVariantPositionValueFallbacks::add(
  self : FontVariantPositionValueFallbacks,
  value : T,
) -> FontVariantPositionValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl FontVariantPositionValueInputFallbacks for FontVariantPositionValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend FontVariantPositionValueFallbacks with FontVariantPositionValueInputFallbacks::{
  fallback_inputs,
}

///|
pub impl PercentageInput for @values.CssWideKeyword with fn percentage_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PercentageInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PercentageFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PercentageFallbacks::new() -> PercentageFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PercentageInput] PercentageFallbacks::add(
  self : PercentageFallbacks,
  value : T,
) -> PercentageFallbacks {
  { inputs: [..self.inputs, value.percentage_input()], }
}

///|
pub impl PercentageInputFallbacks for PercentageFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PercentageFallbacks with PercentageInputFallbacks::{fallback_inputs}

///|
pub trait ForcedColorAdjustValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ForcedColorAdjustValueInput for @properties.ForcedColorAdjustValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ForcedColorAdjustValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ForcedColorAdjustValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ForcedColorAdjustValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ForcedColorAdjustValueFallbacks::new() -> ForcedColorAdjustValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ForcedColorAdjustValueInput] ForcedColorAdjustValueFallbacks::add(
  self : ForcedColorAdjustValueFallbacks,
  value : T,
) -> ForcedColorAdjustValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ForcedColorAdjustValueInputFallbacks for ForcedColorAdjustValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ForcedColorAdjustValueFallbacks with ForcedColorAdjustValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait HangingPunctuationValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl HangingPunctuationValueInput for @properties.HangingPunctuationValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl HangingPunctuationValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait HangingPunctuationValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct HangingPunctuationValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn HangingPunctuationValueFallbacks::new() -> HangingPunctuationValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : HangingPunctuationValueInput] HangingPunctuationValueFallbacks::add(
  self : HangingPunctuationValueFallbacks,
  value : T,
) -> HangingPunctuationValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl HangingPunctuationValueInputFallbacks for HangingPunctuationValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend HangingPunctuationValueFallbacks with HangingPunctuationValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait LineBreakValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl LineBreakValueInput for @properties.LineBreakValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl LineBreakValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait LineBreakValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct LineBreakValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn LineBreakValueFallbacks::new() -> LineBreakValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : LineBreakValueInput] LineBreakValueFallbacks::add(
  self : LineBreakValueFallbacks,
  value : T,
) -> LineBreakValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl LineBreakValueInputFallbacks for LineBreakValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend LineBreakValueFallbacks with LineBreakValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait MaskTypeValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MaskTypeValueInput for @properties.MaskTypeValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MaskTypeValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait MaskTypeValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MaskTypeValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MaskTypeValueFallbacks::new() -> MaskTypeValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MaskTypeValueInput] MaskTypeValueFallbacks::add(
  self : MaskTypeValueFallbacks,
  value : T,
) -> MaskTypeValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MaskTypeValueInputFallbacks for MaskTypeValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MaskTypeValueFallbacks with MaskTypeValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait MathShiftValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MathShiftValueInput for @properties.MathShiftValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MathShiftValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait MathShiftValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MathShiftValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MathShiftValueFallbacks::new() -> MathShiftValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MathShiftValueInput] MathShiftValueFallbacks::add(
  self : MathShiftValueFallbacks,
  value : T,
) -> MathShiftValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MathShiftValueInputFallbacks for MathShiftValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MathShiftValueFallbacks with MathShiftValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait MathStyleValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MathStyleValueInput for @properties.MathStyleValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MathStyleValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait MathStyleValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MathStyleValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MathStyleValueFallbacks::new() -> MathStyleValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MathStyleValueInput] MathStyleValueFallbacks::add(
  self : MathStyleValueFallbacks,
  value : T,
) -> MathStyleValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MathStyleValueInputFallbacks for MathStyleValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MathStyleValueFallbacks with MathStyleValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OffsetRotateInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OffsetRotateInput for @values.OffsetRotate with fn property_input(self) {
  expression_input(self.expression())
}

///|
pub impl OffsetRotateInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OffsetRotateInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OffsetRotateFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OffsetRotateFallbacks::new() -> OffsetRotateFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OffsetRotateInput] OffsetRotateFallbacks::add(
  self : OffsetRotateFallbacks,
  value : T,
) -> OffsetRotateFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OffsetRotateInputFallbacks for OffsetRotateFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OffsetRotateFallbacks with OffsetRotateInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OverflowAnchorValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverflowAnchorValueInput for @properties.OverflowAnchorValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverflowAnchorValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OverflowAnchorValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverflowAnchorValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverflowAnchorValueFallbacks::new() -> OverflowAnchorValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverflowAnchorValueInput] OverflowAnchorValueFallbacks::add(
  self : OverflowAnchorValueFallbacks,
  value : T,
) -> OverflowAnchorValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverflowAnchorValueInputFallbacks for OverflowAnchorValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverflowAnchorValueFallbacks with OverflowAnchorValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OverscrollBehaviorValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverscrollBehaviorValueInput for @properties.OverscrollBehaviorValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverscrollBehaviorValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OverscrollBehaviorValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverscrollBehaviorValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverscrollBehaviorValueFallbacks::new() -> OverscrollBehaviorValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverscrollBehaviorValueInput] OverscrollBehaviorValueFallbacks::add(
  self : OverscrollBehaviorValueFallbacks,
  value : T,
) -> OverscrollBehaviorValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverscrollBehaviorValueInputFallbacks for OverscrollBehaviorValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverscrollBehaviorValueFallbacks with OverscrollBehaviorValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OverscrollBehaviorBlockValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverscrollBehaviorBlockValueInput for @properties.OverscrollBehaviorBlockValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverscrollBehaviorBlockValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OverscrollBehaviorBlockValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverscrollBehaviorBlockValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverscrollBehaviorBlockValueFallbacks::new() -> OverscrollBehaviorBlockValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverscrollBehaviorBlockValueInput] OverscrollBehaviorBlockValueFallbacks::add(
  self : OverscrollBehaviorBlockValueFallbacks,
  value : T,
) -> OverscrollBehaviorBlockValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverscrollBehaviorBlockValueInputFallbacks for OverscrollBehaviorBlockValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverscrollBehaviorBlockValueFallbacks with OverscrollBehaviorBlockValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OverscrollBehaviorInlineValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OverscrollBehaviorInlineValueInput for @properties.OverscrollBehaviorInlineValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OverscrollBehaviorInlineValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OverscrollBehaviorInlineValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OverscrollBehaviorInlineValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OverscrollBehaviorInlineValueFallbacks::new() -> OverscrollBehaviorInlineValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OverscrollBehaviorInlineValueInput] OverscrollBehaviorInlineValueFallbacks::add(
  self : OverscrollBehaviorInlineValueFallbacks,
  value : T,
) -> OverscrollBehaviorInlineValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OverscrollBehaviorInlineValueInputFallbacks for OverscrollBehaviorInlineValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OverscrollBehaviorInlineValueFallbacks with OverscrollBehaviorInlineValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PaintOrderValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PaintOrderValueInput for @properties.PaintOrderValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PaintOrderValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PaintOrderValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PaintOrderValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PaintOrderValueFallbacks::new() -> PaintOrderValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PaintOrderValueInput] PaintOrderValueFallbacks::add(
  self : PaintOrderValueFallbacks,
  value : T,
) -> PaintOrderValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PaintOrderValueInputFallbacks for PaintOrderValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PaintOrderValueFallbacks with PaintOrderValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PositionVisibilityValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PositionVisibilityValueInput for @properties.PositionVisibilityValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PositionVisibilityValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PositionVisibilityValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PositionVisibilityValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PositionVisibilityValueFallbacks::new() -> PositionVisibilityValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PositionVisibilityValueInput] PositionVisibilityValueFallbacks::add(
  self : PositionVisibilityValueFallbacks,
  value : T,
) -> PositionVisibilityValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PositionVisibilityValueInputFallbacks for PositionVisibilityValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PositionVisibilityValueFallbacks with PositionVisibilityValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait PrintColorAdjustValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PrintColorAdjustValueInput for @properties.PrintColorAdjustValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PrintColorAdjustValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait PrintColorAdjustValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PrintColorAdjustValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PrintColorAdjustValueFallbacks::new() -> PrintColorAdjustValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PrintColorAdjustValueInput] PrintColorAdjustValueFallbacks::add(
  self : PrintColorAdjustValueFallbacks,
  value : T,
) -> PrintColorAdjustValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PrintColorAdjustValueInputFallbacks for PrintColorAdjustValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PrintColorAdjustValueFallbacks with PrintColorAdjustValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait RubyAlignValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl RubyAlignValueInput for @properties.RubyAlignValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl RubyAlignValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait RubyAlignValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct RubyAlignValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn RubyAlignValueFallbacks::new() -> RubyAlignValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : RubyAlignValueInput] RubyAlignValueFallbacks::add(
  self : RubyAlignValueFallbacks,
  value : T,
) -> RubyAlignValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl RubyAlignValueInputFallbacks for RubyAlignValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend RubyAlignValueFallbacks with RubyAlignValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait RubyPositionValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl RubyPositionValueInput for @properties.RubyPositionValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl RubyPositionValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait RubyPositionValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct RubyPositionValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn RubyPositionValueFallbacks::new() -> RubyPositionValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : RubyPositionValueInput] RubyPositionValueFallbacks::add(
  self : RubyPositionValueFallbacks,
  value : T,
) -> RubyPositionValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl RubyPositionValueInputFallbacks for RubyPositionValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend RubyPositionValueFallbacks with RubyPositionValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollSnapAlignValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollSnapAlignValueInput for @properties.ScrollSnapAlignValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ScrollSnapAlignValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollSnapAlignValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollSnapAlignValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollSnapAlignValueFallbacks::new() -> ScrollSnapAlignValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollSnapAlignValueInput] ScrollSnapAlignValueFallbacks::add(
  self : ScrollSnapAlignValueFallbacks,
  value : T,
) -> ScrollSnapAlignValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollSnapAlignValueInputFallbacks for ScrollSnapAlignValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollSnapAlignValueFallbacks with ScrollSnapAlignValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollSnapStopValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollSnapStopValueInput for @properties.ScrollSnapStopValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ScrollSnapStopValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollSnapStopValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollSnapStopValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollSnapStopValueFallbacks::new() -> ScrollSnapStopValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollSnapStopValueInput] ScrollSnapStopValueFallbacks::add(
  self : ScrollSnapStopValueFallbacks,
  value : T,
) -> ScrollSnapStopValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollSnapStopValueInputFallbacks for ScrollSnapStopValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollSnapStopValueFallbacks with ScrollSnapStopValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollSnapTypeValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollSnapTypeValueInput for @properties.ScrollSnapTypeValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ScrollSnapTypeValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollSnapTypeValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollSnapTypeValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollSnapTypeValueFallbacks::new() -> ScrollSnapTypeValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollSnapTypeValueInput] ScrollSnapTypeValueFallbacks::add(
  self : ScrollSnapTypeValueFallbacks,
  value : T,
) -> ScrollSnapTypeValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollSnapTypeValueInputFallbacks for ScrollSnapTypeValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollSnapTypeValueFallbacks with ScrollSnapTypeValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollTimelineAxisValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollTimelineAxisValueInput for @properties.ScrollTimelineAxisValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ScrollTimelineAxisValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollTimelineAxisValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollTimelineAxisValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollTimelineAxisValueFallbacks::new() -> ScrollTimelineAxisValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollTimelineAxisValueInput] ScrollTimelineAxisValueFallbacks::add(
  self : ScrollTimelineAxisValueFallbacks,
  value : T,
) -> ScrollTimelineAxisValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollTimelineAxisValueInputFallbacks for ScrollTimelineAxisValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollTimelineAxisValueFallbacks with ScrollTimelineAxisValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollbarWidthValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollbarWidthValueInput for @properties.ScrollbarWidthValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ScrollbarWidthValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollbarWidthValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollbarWidthValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollbarWidthValueFallbacks::new() -> ScrollbarWidthValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollbarWidthValueInput] ScrollbarWidthValueFallbacks::add(
  self : ScrollbarWidthValueFallbacks,
  value : T,
) -> ScrollbarWidthValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollbarWidthValueInputFallbacks for ScrollbarWidthValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollbarWidthValueFallbacks with ScrollbarWidthValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ShapeRenderingValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ShapeRenderingValueInput for @properties.ShapeRenderingValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ShapeRenderingValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ShapeRenderingValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ShapeRenderingValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ShapeRenderingValueFallbacks::new() -> ShapeRenderingValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ShapeRenderingValueInput] ShapeRenderingValueFallbacks::add(
  self : ShapeRenderingValueFallbacks,
  value : T,
) -> ShapeRenderingValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ShapeRenderingValueInputFallbacks for ShapeRenderingValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ShapeRenderingValueFallbacks with ShapeRenderingValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait SpeakValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl SpeakValueInput for @properties.SpeakValue with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl SpeakValueInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait SpeakValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct SpeakValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn SpeakValueFallbacks::new() -> SpeakValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : SpeakValueInput] SpeakValueFallbacks::add(
  self : SpeakValueFallbacks,
  value : T,
) -> SpeakValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl SpeakValueInputFallbacks for SpeakValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend SpeakValueFallbacks with SpeakValueInputFallbacks::{fallback_inputs}

///|
pub trait StrokeLinecapValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl StrokeLinecapValueInput for @properties.StrokeLinecapValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl StrokeLinecapValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait StrokeLinecapValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct StrokeLinecapValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn StrokeLinecapValueFallbacks::new() -> StrokeLinecapValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : StrokeLinecapValueInput] StrokeLinecapValueFallbacks::add(
  self : StrokeLinecapValueFallbacks,
  value : T,
) -> StrokeLinecapValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl StrokeLinecapValueInputFallbacks for StrokeLinecapValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend StrokeLinecapValueFallbacks with StrokeLinecapValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait StrokeLinejoinValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl StrokeLinejoinValueInput for @properties.StrokeLinejoinValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl StrokeLinejoinValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait StrokeLinejoinValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct StrokeLinejoinValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn StrokeLinejoinValueFallbacks::new() -> StrokeLinejoinValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : StrokeLinejoinValueInput] StrokeLinejoinValueFallbacks::add(
  self : StrokeLinejoinValueFallbacks,
  value : T,
) -> StrokeLinejoinValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl StrokeLinejoinValueInputFallbacks for StrokeLinejoinValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend StrokeLinejoinValueFallbacks with StrokeLinejoinValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TableLayoutValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TableLayoutValueInput for @properties.TableLayoutValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TableLayoutValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TableLayoutValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TableLayoutValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TableLayoutValueFallbacks::new() -> TableLayoutValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TableLayoutValueInput] TableLayoutValueFallbacks::add(
  self : TableLayoutValueFallbacks,
  value : T,
) -> TableLayoutValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TableLayoutValueInputFallbacks for TableLayoutValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TableLayoutValueFallbacks with TableLayoutValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextAnchorValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextAnchorValueInput for @properties.TextAnchorValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextAnchorValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextAnchorValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextAnchorValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextAnchorValueFallbacks::new() -> TextAnchorValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextAnchorValueInput] TextAnchorValueFallbacks::add(
  self : TextAnchorValueFallbacks,
  value : T,
) -> TextAnchorValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextAnchorValueInputFallbacks for TextAnchorValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextAnchorValueFallbacks with TextAnchorValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextBoxTrimValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextBoxTrimValueInput for @properties.TextBoxTrimValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextBoxTrimValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextBoxTrimValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextBoxTrimValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextBoxTrimValueFallbacks::new() -> TextBoxTrimValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextBoxTrimValueInput] TextBoxTrimValueFallbacks::add(
  self : TextBoxTrimValueFallbacks,
  value : T,
) -> TextBoxTrimValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextBoxTrimValueInputFallbacks for TextBoxTrimValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextBoxTrimValueFallbacks with TextBoxTrimValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextCombineUprightValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextCombineUprightValueInput for @properties.TextCombineUprightValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextCombineUprightValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextCombineUprightValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextCombineUprightValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextCombineUprightValueFallbacks::new() -> TextCombineUprightValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextCombineUprightValueInput] TextCombineUprightValueFallbacks::add(
  self : TextCombineUprightValueFallbacks,
  value : T,
) -> TextCombineUprightValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextCombineUprightValueInputFallbacks for TextCombineUprightValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextCombineUprightValueFallbacks with TextCombineUprightValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextDecorationSkipInkValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextDecorationSkipInkValueInput for @properties.TextDecorationSkipInkValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextDecorationSkipInkValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextDecorationSkipInkValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextDecorationSkipInkValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextDecorationSkipInkValueFallbacks::new() -> TextDecorationSkipInkValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextDecorationSkipInkValueInput] TextDecorationSkipInkValueFallbacks::add(
  self : TextDecorationSkipInkValueFallbacks,
  value : T,
) -> TextDecorationSkipInkValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextDecorationSkipInkValueInputFallbacks for TextDecorationSkipInkValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextDecorationSkipInkValueFallbacks with TextDecorationSkipInkValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextJustifyValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextJustifyValueInput for @properties.TextJustifyValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextJustifyValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextJustifyValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextJustifyValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextJustifyValueFallbacks::new() -> TextJustifyValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextJustifyValueInput] TextJustifyValueFallbacks::add(
  self : TextJustifyValueFallbacks,
  value : T,
) -> TextJustifyValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextJustifyValueInputFallbacks for TextJustifyValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextJustifyValueFallbacks with TextJustifyValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextOrientationValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextOrientationValueInput for @properties.TextOrientationValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextOrientationValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextOrientationValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextOrientationValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextOrientationValueFallbacks::new() -> TextOrientationValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextOrientationValueInput] TextOrientationValueFallbacks::add(
  self : TextOrientationValueFallbacks,
  value : T,
) -> TextOrientationValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextOrientationValueInputFallbacks for TextOrientationValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextOrientationValueFallbacks with TextOrientationValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TextRenderingValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TextRenderingValueInput for @properties.TextRenderingValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TextRenderingValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TextRenderingValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TextRenderingValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TextRenderingValueFallbacks::new() -> TextRenderingValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TextRenderingValueInput] TextRenderingValueFallbacks::add(
  self : TextRenderingValueFallbacks,
  value : T,
) -> TextRenderingValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TextRenderingValueInputFallbacks for TextRenderingValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TextRenderingValueFallbacks with TextRenderingValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TransformBoxValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TransformBoxValueInput for @properties.TransformBoxValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TransformBoxValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TransformBoxValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TransformBoxValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TransformBoxValueFallbacks::new() -> TransformBoxValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TransformBoxValueInput] TransformBoxValueFallbacks::add(
  self : TransformBoxValueFallbacks,
  value : T,
) -> TransformBoxValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TransformBoxValueInputFallbacks for TransformBoxValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TransformBoxValueFallbacks with TransformBoxValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait UnicodeBidiValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl UnicodeBidiValueInput for @properties.UnicodeBidiValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl UnicodeBidiValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait UnicodeBidiValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct UnicodeBidiValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn UnicodeBidiValueFallbacks::new() -> UnicodeBidiValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : UnicodeBidiValueInput] UnicodeBidiValueFallbacks::add(
  self : UnicodeBidiValueFallbacks,
  value : T,
) -> UnicodeBidiValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl UnicodeBidiValueInputFallbacks for UnicodeBidiValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend UnicodeBidiValueFallbacks with UnicodeBidiValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait VectorEffectValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl VectorEffectValueInput for @properties.VectorEffectValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl VectorEffectValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait VectorEffectValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct VectorEffectValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn VectorEffectValueFallbacks::new() -> VectorEffectValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : VectorEffectValueInput] VectorEffectValueFallbacks::add(
  self : VectorEffectValueFallbacks,
  value : T,
) -> VectorEffectValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl VectorEffectValueInputFallbacks for VectorEffectValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend VectorEffectValueFallbacks with VectorEffectValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ViewTimelineAxisValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ViewTimelineAxisValueInput for @properties.ViewTimelineAxisValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ViewTimelineAxisValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ViewTimelineAxisValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ViewTimelineAxisValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ViewTimelineAxisValueFallbacks::new() -> ViewTimelineAxisValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ViewTimelineAxisValueInput] ViewTimelineAxisValueFallbacks::add(
  self : ViewTimelineAxisValueFallbacks,
  value : T,
) -> ViewTimelineAxisValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ViewTimelineAxisValueInputFallbacks for ViewTimelineAxisValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ViewTimelineAxisValueFallbacks with ViewTimelineAxisValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait WritingModeValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl WritingModeValueInput for @properties.WritingModeValue with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl WritingModeValueInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait WritingModeValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct WritingModeValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn WritingModeValueFallbacks::new() -> WritingModeValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : WritingModeValueInput] WritingModeValueFallbacks::add(
  self : WritingModeValueFallbacks,
  value : T,
) -> WritingModeValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl WritingModeValueInputFallbacks for WritingModeValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend WritingModeValueFallbacks with WritingModeValueInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BorderSideInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderSideInput for @values.BorderSide with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderSideInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait BorderSideInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderSideFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderSideFallbacks::new() -> BorderSideFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderSideInput] BorderSideFallbacks::add(
  self : BorderSideFallbacks,
  value : T,
) -> BorderSideFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderSideInputFallbacks for BorderSideFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderSideFallbacks with BorderSideInputFallbacks::{fallback_inputs}

///|
pub trait BorderColorsInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderColorsInput for @values.BorderColors with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderColorsInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderColorsInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderColorsFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderColorsFallbacks::new() -> BorderColorsFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderColorsInput] BorderColorsFallbacks::add(
  self : BorderColorsFallbacks,
  value : T,
) -> BorderColorsFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderColorsInputFallbacks for BorderColorsFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderColorsFallbacks with BorderColorsInputFallbacks::{
  fallback_inputs,
}

///|
pub trait LineStyleInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl LineStyleInput for @values.LineStyle with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl LineStyleInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait LineStyleInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct LineStyleFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn LineStyleFallbacks::new() -> LineStyleFallbacks {
  { inputs: [], }
}

///|
pub fn[T : LineStyleInput] LineStyleFallbacks::add(
  self : LineStyleFallbacks,
  value : T,
) -> LineStyleFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl LineStyleInputFallbacks for LineStyleFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend LineStyleFallbacks with LineStyleInputFallbacks::{fallback_inputs}

///|
pub trait LineWidthInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl LineWidthInput for @values.LineWidth with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl LineWidthInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait LineWidthInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct LineWidthFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn LineWidthFallbacks::new() -> LineWidthFallbacks {
  { inputs: [], }
}

///|
pub fn[T : LineWidthInput] LineWidthFallbacks::add(
  self : LineWidthFallbacks,
  value : T,
) -> LineWidthFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl LineWidthInputFallbacks for LineWidthFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend LineWidthFallbacks with LineWidthInputFallbacks::{fallback_inputs}

///|
pub trait BorderStylesInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderStylesInput for @values.BorderStyles with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderStylesInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderStylesInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderStylesFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderStylesFallbacks::new() -> BorderStylesFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderStylesInput] BorderStylesFallbacks::add(
  self : BorderStylesFallbacks,
  value : T,
) -> BorderStylesFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderStylesInputFallbacks for BorderStylesFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderStylesFallbacks with BorderStylesInputFallbacks::{
  fallback_inputs,
}

///|
pub trait BorderWidthsInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl BorderWidthsInput for @values.BorderWidths with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl BorderWidthsInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait BorderWidthsInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct BorderWidthsFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn BorderWidthsFallbacks::new() -> BorderWidthsFallbacks {
  { inputs: [], }
}

///|
pub fn[T : BorderWidthsInput] BorderWidthsFallbacks::add(
  self : BorderWidthsFallbacks,
  value : T,
) -> BorderWidthsFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl BorderWidthsInputFallbacks for BorderWidthsFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend BorderWidthsFallbacks with BorderWidthsInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OutlineInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OutlineInput for @values.Outline with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl OutlineInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait OutlineInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OutlineFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OutlineFallbacks::new() -> OutlineFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OutlineInput] OutlineFallbacks::add(
  self : OutlineFallbacks,
  value : T,
) -> OutlineFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OutlineInputFallbacks for OutlineFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OutlineFallbacks with OutlineInputFallbacks::{fallback_inputs}

///|
pub trait PageValueInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl PageValueInput for @values.PageValue with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl PageValueInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait PageValueInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct PageValueFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn PageValueFallbacks::new() -> PageValueFallbacks {
  { inputs: [], }
}

///|
pub fn[T : PageValueInput] PageValueFallbacks::add(
  self : PageValueFallbacks,
  value : T,
) -> PageValueFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl PageValueInputFallbacks for PageValueFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend PageValueFallbacks with PageValueInputFallbacks::{fallback_inputs}

///|
pub struct MaskBoxList {
  values : Array[@values.MaskBox]
}

///|
pub fn MaskBoxList::new(values : Array[@values.MaskBox]) -> MaskBoxList {
  { values: values.copy(), }
}

///|
pub fn MaskBoxList::to_css(self : MaskBoxList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "MaskBox-list",
  ).to_css()
}

///|
pub impl MaskBoxInput for MaskBoxList with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub extend MaskBoxList with MaskBoxInput::{property_input}

///|
pub trait MaskBoxInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MaskBoxInput for @values.MaskBox with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MaskBoxInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait MaskBoxInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MaskBoxFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MaskBoxFallbacks::new() -> MaskBoxFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MaskBoxInput] MaskBoxFallbacks::add(
  self : MaskBoxFallbacks,
  value : T,
) -> MaskBoxFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MaskBoxInputFallbacks for MaskBoxFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MaskBoxFallbacks with MaskBoxInputFallbacks::{fallback_inputs}

///|
pub struct MaskClipList {
  values : Array[@values.MaskClip]
}

///|
pub fn MaskClipList::new(values : Array[@values.MaskClip]) -> MaskClipList {
  { values: values.copy(), }
}

///|
pub fn MaskClipList::to_css(self : MaskClipList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "MaskClip-list",
  ).to_css()
}

///|
pub impl MaskClipInput for MaskClipList with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub extend MaskClipList with MaskClipInput::{property_input}

///|
pub trait MaskClipInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MaskClipInput for @values.MaskClip with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MaskClipInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait MaskClipInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MaskClipFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MaskClipFallbacks::new() -> MaskClipFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MaskClipInput] MaskClipFallbacks::add(
  self : MaskClipFallbacks,
  value : T,
) -> MaskClipFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MaskClipInputFallbacks for MaskClipFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MaskClipFallbacks with MaskClipInputFallbacks::{fallback_inputs}

///|
pub struct MaskModeList {
  values : Array[@values.MaskMode]
}

///|
pub fn MaskModeList::new(values : Array[@values.MaskMode]) -> MaskModeList {
  { values: values.copy(), }
}

///|
pub fn MaskModeList::to_css(self : MaskModeList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "MaskMode-list",
  ).to_css()
}

///|
pub impl MaskModeInput for MaskModeList with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub extend MaskModeList with MaskModeInput::{property_input}

///|
pub trait MaskModeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MaskModeInput for @values.MaskMode with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MaskModeInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait MaskModeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MaskModeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MaskModeFallbacks::new() -> MaskModeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MaskModeInput] MaskModeFallbacks::add(
  self : MaskModeFallbacks,
  value : T,
) -> MaskModeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MaskModeInputFallbacks for MaskModeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MaskModeFallbacks with MaskModeInputFallbacks::{fallback_inputs}

///|
pub struct MaskCompositeList {
  values : Array[@values.MaskComposite]
}

///|
pub fn MaskCompositeList::new(
  values : Array[@values.MaskComposite],
) -> MaskCompositeList {
  { values: values.copy(), }
}

///|
pub fn MaskCompositeList::to_css(self : MaskCompositeList) -> String {
  @values.declaration_list(
    self.values.map(value => {
      @values.declaration_expression(value.to_css(), None)
    }),
    "MaskComposite-list",
  ).to_css()
}

///|
pub impl MaskCompositeInput for MaskCompositeList with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub extend MaskCompositeList with MaskCompositeInput::{property_input}

///|
pub trait MaskCompositeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MaskCompositeInput for @values.MaskComposite with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl MaskCompositeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait MaskCompositeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MaskCompositeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MaskCompositeFallbacks::new() -> MaskCompositeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MaskCompositeInput] MaskCompositeFallbacks::add(
  self : MaskCompositeFallbacks,
  value : T,
) -> MaskCompositeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MaskCompositeInputFallbacks for MaskCompositeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MaskCompositeFallbacks with MaskCompositeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait CounterChangesInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl CounterChangesInput for @values.CounterChanges with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl CounterChangesInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait CounterChangesInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct CounterChangesFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn CounterChangesFallbacks::new() -> CounterChangesFallbacks {
  { inputs: [], }
}

///|
pub fn[T : CounterChangesInput] CounterChangesFallbacks::add(
  self : CounterChangesFallbacks,
  value : T,
) -> CounterChangesFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl CounterChangesInputFallbacks for CounterChangesFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend CounterChangesFallbacks with CounterChangesInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TimelineNamesInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TimelineNamesInput for @values.TimelineNames with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TimelineNamesInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TimelineNamesInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TimelineNamesFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TimelineNamesFallbacks::new() -> TimelineNamesFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TimelineNamesInput] TimelineNamesFallbacks::add(
  self : TimelineNamesFallbacks,
  value : T,
) -> TimelineNamesFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TimelineNamesInputFallbacks for TimelineNamesFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TimelineNamesFallbacks with TimelineNamesInputFallbacks::{
  fallback_inputs,
}

///|
pub trait AnimationTimelinesInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl AnimationTimelinesInput for @values.AnimationTimelines with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl AnimationTimelinesInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait AnimationTimelinesInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct AnimationTimelinesFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn AnimationTimelinesFallbacks::new() -> AnimationTimelinesFallbacks {
  { inputs: [], }
}

///|
pub fn[T : AnimationTimelinesInput] AnimationTimelinesFallbacks::add(
  self : AnimationTimelinesFallbacks,
  value : T,
) -> AnimationTimelinesFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl AnimationTimelinesInputFallbacks for AnimationTimelinesFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend AnimationTimelinesFallbacks with AnimationTimelinesInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TimelineRangeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TimelineRangeInput for @values.TimelineRange with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl TimelineRangeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TimelineRangeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TimelineRangeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TimelineRangeFallbacks::new() -> TimelineRangeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TimelineRangeInput] TimelineRangeFallbacks::add(
  self : TimelineRangeFallbacks,
  value : T,
) -> TimelineRangeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TimelineRangeInputFallbacks for TimelineRangeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TimelineRangeFallbacks with TimelineRangeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait TimelineScopeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl TimelineScopeInput for @values.TimelineScope with fn property_input(
  self,
) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl TimelineScopeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait TimelineScopeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct TimelineScopeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn TimelineScopeFallbacks::new() -> TimelineScopeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : TimelineScopeInput] TimelineScopeFallbacks::add(
  self : TimelineScopeFallbacks,
  value : T,
) -> TimelineScopeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl TimelineScopeInputFallbacks for TimelineScopeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend TimelineScopeFallbacks with TimelineScopeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait MotionPathInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl MotionPathInput for @values.MotionPath with fn property_input(self) {
  expression_input(self.expression())
}

///|
pub impl MotionPathInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait MotionPathInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct MotionPathFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn MotionPathFallbacks::new() -> MotionPathFallbacks {
  { inputs: [], }
}

///|
pub fn[T : MotionPathInput] MotionPathFallbacks::add(
  self : MotionPathFallbacks,
  value : T,
) -> MotionPathFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl MotionPathInputFallbacks for MotionPathFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend MotionPathFallbacks with MotionPathInputFallbacks::{fallback_inputs}

///|
pub trait OffsetPositionInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OffsetPositionInput for @values.OffsetPosition with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl OffsetPositionInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OffsetPositionInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OffsetPositionFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OffsetPositionFallbacks::new() -> OffsetPositionFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OffsetPositionInput] OffsetPositionFallbacks::add(
  self : OffsetPositionFallbacks,
  value : T,
) -> OffsetPositionFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OffsetPositionInputFallbacks for OffsetPositionFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OffsetPositionFallbacks with OffsetPositionInputFallbacks::{
  fallback_inputs,
}

///|
pub trait OffsetAnchorInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl OffsetAnchorInput for @values.OffsetAnchor with fn property_input(self) {
  expression_input(self.expression())
}

///|
pub impl OffsetAnchorInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait OffsetAnchorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct OffsetAnchorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn OffsetAnchorFallbacks::new() -> OffsetAnchorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : OffsetAnchorInput] OffsetAnchorFallbacks::add(
  self : OffsetAnchorFallbacks,
  value : T,
) -> OffsetAnchorFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl OffsetAnchorInputFallbacks for OffsetAnchorFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend OffsetAnchorFallbacks with OffsetAnchorInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ColorSchemeInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ColorSchemeInput for @values.ColorScheme with fn property_input(self) {
  let value = self
  static_input(value.to_css())
}

///|
pub impl ColorSchemeInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ColorSchemeInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ColorSchemeFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ColorSchemeFallbacks::new() -> ColorSchemeFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ColorSchemeInput] ColorSchemeFallbacks::add(
  self : ColorSchemeFallbacks,
  value : T,
) -> ColorSchemeFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ColorSchemeInputFallbacks for ColorSchemeFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ColorSchemeFallbacks with ColorSchemeInputFallbacks::{
  fallback_inputs,
}

///|
pub trait ScrollbarColorInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl ScrollbarColorInput for @values.ScrollbarColor with fn property_input(
  self,
) {
  expression_input(self.expression())
}

///|
pub impl ScrollbarColorInput for @values.CssWideKeyword with fn property_input(
  self,
) {
  static_input(self.to_css())
}

///|
pub trait ScrollbarColorInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct ScrollbarColorFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn ScrollbarColorFallbacks::new() -> ScrollbarColorFallbacks {
  { inputs: [], }
}

///|
pub fn[T : ScrollbarColorInput] ScrollbarColorFallbacks::add(
  self : ScrollbarColorFallbacks,
  value : T,
) -> ScrollbarColorFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl ScrollbarColorInputFallbacks for ScrollbarColorFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend ScrollbarColorFallbacks with ScrollbarColorInputFallbacks::{
  fallback_inputs,
}

///|
pub trait SvgPaintInput {
  fn property_input(Self) -> PropertyInput
}

///|
pub impl SvgPaintInput for @values.SvgPaint with fn property_input(self) {
  expression_input(self.expression())
}

///|
pub impl SvgPaintInput for @values.CssWideKeyword with fn property_input(self) {
  static_input(self.to_css())
}

///|
pub trait SvgPaintInputFallbacks {
  fn fallback_inputs(Self) -> Array[PropertyInput]
}

///|
pub struct SvgPaintFallbacks {
  inputs : Array[PropertyInput]
}

///|
pub fn SvgPaintFallbacks::new() -> SvgPaintFallbacks {
  { inputs: [], }
}

///|
pub fn[T : SvgPaintInput] SvgPaintFallbacks::add(
  self : SvgPaintFallbacks,
  value : T,
) -> SvgPaintFallbacks {
  { inputs: [..self.inputs, value.property_input()], }
}

///|
pub impl SvgPaintInputFallbacks for SvgPaintFallbacks with fn fallback_inputs(
  self,
) {
  self.inputs.copy()
}

///|
pub extend SvgPaintFallbacks with SvgPaintInputFallbacks::{fallback_inputs}