// Generated by tools/generate-properties.mjs from @webref/css 8.7.8 and @mdn/browser-compat-data 8.1.7. Do not edit.

///|
pub(all) enum Display {
  Block
  Flex
  Grid
  Inline
  InlineBlock
  InlineFlex
  None
} derive(Eq, Debug)

///|
pub extend Display with Eq::{equal, not_equal}

///|
pub extend Display with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn Display::to_css(self : Display) -> String {
  match self {
    Block => "block"
    Flex => "flex"
    Grid => "grid"
    Inline => "inline"
    InlineBlock => "inline-block"
    InlineFlex => "inline-flex"
    None => "none"
  }
}

///|
pub(all) enum Overflow {
  Visible
  Hidden
  Auto
  Scroll
} derive(Eq, Debug)

///|
pub extend Overflow with Eq::{equal, not_equal}

///|
pub extend Overflow with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn Overflow::to_css(self : Overflow) -> String {
  match self {
    Visible => "visible"
    Hidden => "hidden"
    Auto => "auto"
    Scroll => "scroll"
  }
}

///|
pub(all) enum Cursor {
  Default
  Pointer
  Text
  NotAllowed
  Wait
} derive(Eq, Debug)

///|
pub extend Cursor with Eq::{equal, not_equal}

///|
pub extend Cursor with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn Cursor::to_css(self : Cursor) -> String {
  match self {
    Default => "default"
    Pointer => "pointer"
    Text => "text"
    NotAllowed => "not-allowed"
    Wait => "wait"
  }
}

///|
pub(all) enum BorderStyle {
  Solid
  Dashed
  Dotted
  Double
  BorderNone
} derive(Eq, Debug)

///|
pub extend BorderStyle with Eq::{equal, not_equal}

///|
pub extend BorderStyle with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BorderStyle::to_css(self : BorderStyle) -> String {
  match self {
    Solid => "solid"
    Dashed => "dashed"
    Dotted => "dotted"
    Double => "double"
    BorderNone => "none"
  }
}

///|
pub(all) enum PlaceItems {
  Start
  Center
  End
  Stretch
} derive(Eq, Debug)

///|
pub extend PlaceItems with Eq::{equal, not_equal}

///|
pub extend PlaceItems with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn PlaceItems::to_css(self : PlaceItems) -> String {
  match self {
    Start => "start"
    Center => "center"
    End => "end"
    Stretch => "stretch"
  }
}

///|
pub(all) enum PositionMode {
  PositionModeStatic
  PositionModeRelative
  PositionModeAbsolute
  PositionModeFixed
  PositionModeSticky
} derive(Eq, Debug)

///|
pub extend PositionMode with Eq::{equal, not_equal}

///|
pub extend PositionMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn PositionMode::to_css(self : PositionMode) -> String {
  match self {
    PositionModeStatic => "static"
    PositionModeRelative => "relative"
    PositionModeAbsolute => "absolute"
    PositionModeFixed => "fixed"
    PositionModeSticky => "sticky"
  }
}

///|
pub(all) enum BoxSizing {
  BoxSizingContentBox
  BoxSizingBorderBox
} derive(Eq, Debug)

///|
pub extend BoxSizing with Eq::{equal, not_equal}

///|
pub extend BoxSizing with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BoxSizing::to_css(self : BoxSizing) -> String {
  match self {
    BoxSizingContentBox => "content-box"
    BoxSizingBorderBox => "border-box"
  }
}

///|
pub(all) enum Visibility {
  VisibilityVisible
  VisibilityHidden
  VisibilityCollapse
} derive(Eq, Debug)

///|
pub extend Visibility with Eq::{equal, not_equal}

///|
pub extend Visibility with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn Visibility::to_css(self : Visibility) -> String {
  match self {
    VisibilityVisible => "visible"
    VisibilityHidden => "hidden"
    VisibilityCollapse => "collapse"
  }
}

///|
pub(all) enum FlexDirection {
  FlexDirectionRow
  FlexDirectionRowReverse
  FlexDirectionColumn
  FlexDirectionColumnReverse
} derive(Eq, Debug)

///|
pub extend FlexDirection with Eq::{equal, not_equal}

///|
pub extend FlexDirection with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FlexDirection::to_css(self : FlexDirection) -> String {
  match self {
    FlexDirectionRow => "row"
    FlexDirectionRowReverse => "row-reverse"
    FlexDirectionColumn => "column"
    FlexDirectionColumnReverse => "column-reverse"
  }
}

///|
pub(all) enum FlexWrap {
  FlexWrapNowrap
  FlexWrapWrap
  FlexWrapWrapReverse
} derive(Eq, Debug)

///|
pub extend FlexWrap with Eq::{equal, not_equal}

///|
pub extend FlexWrap with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FlexWrap::to_css(self : FlexWrap) -> String {
  match self {
    FlexWrapNowrap => "nowrap"
    FlexWrapWrap => "wrap"
    FlexWrapWrapReverse => "wrap-reverse"
  }
}

///|
pub(all) enum Alignment {
  AlignmentNormal
  AlignmentStart
  AlignmentEnd
  AlignmentCenter
  AlignmentStretch
  AlignmentBaseline
  AlignmentSpaceBetween
  AlignmentSpaceAround
  AlignmentSpaceEvenly
} derive(Eq, Debug)

///|
pub extend Alignment with Eq::{equal, not_equal}

///|
pub extend Alignment with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn Alignment::to_css(self : Alignment) -> String {
  match self {
    AlignmentNormal => "normal"
    AlignmentStart => "start"
    AlignmentEnd => "end"
    AlignmentCenter => "center"
    AlignmentStretch => "stretch"
    AlignmentBaseline => "baseline"
    AlignmentSpaceBetween => "space-between"
    AlignmentSpaceAround => "space-around"
    AlignmentSpaceEvenly => "space-evenly"
  }
}

///|
pub(all) enum ObjectFit {
  ObjectFitFill
  ObjectFitContain
  ObjectFitCover
  ObjectFitNone
  ObjectFitScaleDown
} derive(Eq, Debug)

///|
pub extend ObjectFit with Eq::{equal, not_equal}

///|
pub extend ObjectFit with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ObjectFit::to_css(self : ObjectFit) -> String {
  match self {
    ObjectFitFill => "fill"
    ObjectFitContain => "contain"
    ObjectFitCover => "cover"
    ObjectFitNone => "none"
    ObjectFitScaleDown => "scale-down"
  }
}

///|
pub(all) enum FloatMode {
  FloatModeNone
  FloatModeLeft
  FloatModeRight
  FloatModeInlineStart
  FloatModeInlineEnd
} derive(Eq, Debug)

///|
pub extend FloatMode with Eq::{equal, not_equal}

///|
pub extend FloatMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FloatMode::to_css(self : FloatMode) -> String {
  match self {
    FloatModeNone => "none"
    FloatModeLeft => "left"
    FloatModeRight => "right"
    FloatModeInlineStart => "inline-start"
    FloatModeInlineEnd => "inline-end"
  }
}

///|
pub(all) enum ClearMode {
  ClearModeNone
  ClearModeLeft
  ClearModeRight
  ClearModeBoth
  ClearModeInlineStart
  ClearModeInlineEnd
} derive(Eq, Debug)

///|
pub extend ClearMode with Eq::{equal, not_equal}

///|
pub extend ClearMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ClearMode::to_css(self : ClearMode) -> String {
  match self {
    ClearModeNone => "none"
    ClearModeLeft => "left"
    ClearModeRight => "right"
    ClearModeBoth => "both"
    ClearModeInlineStart => "inline-start"
    ClearModeInlineEnd => "inline-end"
  }
}

///|
pub(all) enum ResizeMode {
  ResizeModeNone
  ResizeModeBoth
  ResizeModeHorizontal
  ResizeModeVertical
  ResizeModeBlock
  ResizeModeInline
} derive(Eq, Debug)

///|
pub extend ResizeMode with Eq::{equal, not_equal}

///|
pub extend ResizeMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ResizeMode::to_css(self : ResizeMode) -> String {
  match self {
    ResizeModeNone => "none"
    ResizeModeBoth => "both"
    ResizeModeHorizontal => "horizontal"
    ResizeModeVertical => "vertical"
    ResizeModeBlock => "block"
    ResizeModeInline => "inline"
  }
}

///|
pub(all) enum GridAutoFlow {
  GridAutoFlowRow
  GridAutoFlowColumn
  GridAutoFlowDense
  GridAutoFlowRowDense
  GridAutoFlowColumnDense
} derive(Eq, Debug)

///|
pub extend GridAutoFlow with Eq::{equal, not_equal}

///|
pub extend GridAutoFlow with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn GridAutoFlow::to_css(self : GridAutoFlow) -> String {
  match self {
    GridAutoFlowRow => "row"
    GridAutoFlowColumn => "column"
    GridAutoFlowDense => "dense"
    GridAutoFlowRowDense => "row-dense"
    GridAutoFlowColumnDense => "column-dense"
  }
}

///|
pub(all) enum TextAlign {
  TextAlignStart
  TextAlignEnd
  TextAlignLeft
  TextAlignRight
  TextAlignCenter
  TextAlignJustify
  TextAlignMatchParent
} derive(Eq, Debug)

///|
pub extend TextAlign with Eq::{equal, not_equal}

///|
pub extend TextAlign with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextAlign::to_css(self : TextAlign) -> String {
  match self {
    TextAlignStart => "start"
    TextAlignEnd => "end"
    TextAlignLeft => "left"
    TextAlignRight => "right"
    TextAlignCenter => "center"
    TextAlignJustify => "justify"
    TextAlignMatchParent => "match-parent"
  }
}

///|
pub(all) enum TextTransform {
  TextTransformNone
  TextTransformCapitalize
  TextTransformUppercase
  TextTransformLowercase
  TextTransformFullWidth
  TextTransformFullSizeKana
} derive(Eq, Debug)

///|
pub extend TextTransform with Eq::{equal, not_equal}

///|
pub extend TextTransform with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextTransform::to_css(self : TextTransform) -> String {
  match self {
    TextTransformNone => "none"
    TextTransformCapitalize => "capitalize"
    TextTransformUppercase => "uppercase"
    TextTransformLowercase => "lowercase"
    TextTransformFullWidth => "full-width"
    TextTransformFullSizeKana => "full-size-kana"
  }
}

///|
pub(all) enum TextDecorationLine {
  TextDecorationLineNone
  TextDecorationLineUnderline
  TextDecorationLineOverline
  TextDecorationLineLineThrough
} derive(Eq, Debug)

///|
pub extend TextDecorationLine with Eq::{equal, not_equal}

///|
pub extend TextDecorationLine with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextDecorationLine::to_css(self : TextDecorationLine) -> String {
  match self {
    TextDecorationLineNone => "none"
    TextDecorationLineUnderline => "underline"
    TextDecorationLineOverline => "overline"
    TextDecorationLineLineThrough => "line-through"
  }
}

///|
pub(all) enum TextDecorationStyle {
  TextDecorationStyleSolid
  TextDecorationStyleDouble
  TextDecorationStyleDotted
  TextDecorationStyleDashed
  TextDecorationStyleWavy
} derive(Eq, Debug)

///|
pub extend TextDecorationStyle with Eq::{equal, not_equal}

///|
pub extend TextDecorationStyle with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextDecorationStyle::to_css(self : TextDecorationStyle) -> String {
  match self {
    TextDecorationStyleSolid => "solid"
    TextDecorationStyleDouble => "double"
    TextDecorationStyleDotted => "dotted"
    TextDecorationStyleDashed => "dashed"
    TextDecorationStyleWavy => "wavy"
  }
}

///|
pub(all) enum TextUnderlinePosition {
  TextUnderlinePositionAuto
  TextUnderlinePositionUnder
  TextUnderlinePositionLeft
  TextUnderlinePositionRight
} derive(Eq, Debug)

///|
pub extend TextUnderlinePosition with Eq::{equal, not_equal}

///|
pub extend TextUnderlinePosition with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextUnderlinePosition::to_css(self : TextUnderlinePosition) -> String {
  match self {
    TextUnderlinePositionAuto => "auto"
    TextUnderlinePositionUnder => "under"
    TextUnderlinePositionLeft => "left"
    TextUnderlinePositionRight => "right"
  }
}

///|
pub(all) enum OverflowWrap {
  OverflowWrapNormal
  OverflowWrapBreakWord
  OverflowWrapAnywhere
} derive(Eq, Debug)

///|
pub extend OverflowWrap with Eq::{equal, not_equal}

///|
pub extend OverflowWrap with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn OverflowWrap::to_css(self : OverflowWrap) -> String {
  match self {
    OverflowWrapNormal => "normal"
    OverflowWrapBreakWord => "break-word"
    OverflowWrapAnywhere => "anywhere"
  }
}

///|
pub(all) enum WordBreak {
  WordBreakNormal
  WordBreakBreakAll
  WordBreakKeepAll
  WordBreakBreakWord
} derive(Eq, Debug)

///|
pub extend WordBreak with Eq::{equal, not_equal}

///|
pub extend WordBreak with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn WordBreak::to_css(self : WordBreak) -> String {
  match self {
    WordBreakNormal => "normal"
    WordBreakBreakAll => "break-all"
    WordBreakKeepAll => "keep-all"
    WordBreakBreakWord => "break-word"
  }
}

///|
pub(all) enum Hyphens {
  HyphensNone
  HyphensManual
  HyphensAuto
} derive(Eq, Debug)

///|
pub extend Hyphens with Eq::{equal, not_equal}

///|
pub extend Hyphens with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn Hyphens::to_css(self : Hyphens) -> String {
  match self {
    HyphensNone => "none"
    HyphensManual => "manual"
    HyphensAuto => "auto"
  }
}

///|
pub(all) enum TextOverflow {
  TextOverflowClip
  TextOverflowEllipsis
} derive(Eq, Debug)

///|
pub extend TextOverflow with Eq::{equal, not_equal}

///|
pub extend TextOverflow with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextOverflow::to_css(self : TextOverflow) -> String {
  match self {
    TextOverflowClip => "clip"
    TextOverflowEllipsis => "ellipsis"
  }
}

///|
pub(all) enum WhiteSpaceCollapse {
  WhiteSpaceCollapseCollapse
  WhiteSpaceCollapsePreserve
  WhiteSpaceCollapsePreserveBreaks
  WhiteSpaceCollapsePreserveSpaces
  WhiteSpaceCollapseBreakSpaces
} derive(Eq, Debug)

///|
pub extend WhiteSpaceCollapse with Eq::{equal, not_equal}

///|
pub extend WhiteSpaceCollapse with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn WhiteSpaceCollapse::to_css(self : WhiteSpaceCollapse) -> String {
  match self {
    WhiteSpaceCollapseCollapse => "collapse"
    WhiteSpaceCollapsePreserve => "preserve"
    WhiteSpaceCollapsePreserveBreaks => "preserve-breaks"
    WhiteSpaceCollapsePreserveSpaces => "preserve-spaces"
    WhiteSpaceCollapseBreakSpaces => "break-spaces"
  }
}

///|
pub(all) enum TextWrapMode {
  TextWrapModeWrap
  TextWrapModeNowrap
} derive(Eq, Debug)

///|
pub extend TextWrapMode with Eq::{equal, not_equal}

///|
pub extend TextWrapMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextWrapMode::to_css(self : TextWrapMode) -> String {
  match self {
    TextWrapModeWrap => "wrap"
    TextWrapModeNowrap => "nowrap"
  }
}

///|
pub(all) enum TextWrapStyle {
  TextWrapStyleAuto
  TextWrapStyleBalance
  TextWrapStylePretty
  TextWrapStyleStable
} derive(Eq, Debug)

///|
pub extend TextWrapStyle with Eq::{equal, not_equal}

///|
pub extend TextWrapStyle with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextWrapStyle::to_css(self : TextWrapStyle) -> String {
  match self {
    TextWrapStyleAuto => "auto"
    TextWrapStyleBalance => "balance"
    TextWrapStylePretty => "pretty"
    TextWrapStyleStable => "stable"
  }
}

///|
pub(all) enum FontStyle {
  FontStyleNormal
  FontStyleItalic
  FontStyleOblique
} derive(Eq, Debug)

///|
pub extend FontStyle with Eq::{equal, not_equal}

///|
pub extend FontStyle with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontStyle::to_css(self : FontStyle) -> String {
  match self {
    FontStyleNormal => "normal"
    FontStyleItalic => "italic"
    FontStyleOblique => "oblique"
  }
}

///|
pub(all) enum FontStretch {
  FontStretchNormal
  FontStretchUltraCondensed
  FontStretchExtraCondensed
  FontStretchCondensed
  FontStretchSemiCondensed
  FontStretchSemiExpanded
  FontStretchExpanded
  FontStretchExtraExpanded
  FontStretchUltraExpanded
} derive(Eq, Debug)

///|
pub extend FontStretch with Eq::{equal, not_equal}

///|
pub extend FontStretch with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontStretch::to_css(self : FontStretch) -> String {
  match self {
    FontStretchNormal => "normal"
    FontStretchUltraCondensed => "ultra-condensed"
    FontStretchExtraCondensed => "extra-condensed"
    FontStretchCondensed => "condensed"
    FontStretchSemiCondensed => "semi-condensed"
    FontStretchSemiExpanded => "semi-expanded"
    FontStretchExpanded => "expanded"
    FontStretchExtraExpanded => "extra-expanded"
    FontStretchUltraExpanded => "ultra-expanded"
  }
}

///|
pub(all) enum FontKerning {
  FontKerningAuto
  FontKerningNormal
  FontKerningNone
} derive(Eq, Debug)

///|
pub extend FontKerning with Eq::{equal, not_equal}

///|
pub extend FontKerning with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontKerning::to_css(self : FontKerning) -> String {
  match self {
    FontKerningAuto => "auto"
    FontKerningNormal => "normal"
    FontKerningNone => "none"
  }
}

///|
pub(all) enum FontOpticalSizing {
  FontOpticalSizingAuto
  FontOpticalSizingNone
} derive(Eq, Debug)

///|
pub extend FontOpticalSizing with Eq::{equal, not_equal}

///|
pub extend FontOpticalSizing with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontOpticalSizing::to_css(self : FontOpticalSizing) -> String {
  match self {
    FontOpticalSizingAuto => "auto"
    FontOpticalSizingNone => "none"
  }
}

///|
pub(all) enum FontVariantCaps {
  FontVariantCapsNormal
  FontVariantCapsSmallCaps
  FontVariantCapsAllSmallCaps
  FontVariantCapsPetiteCaps
  FontVariantCapsAllPetiteCaps
  FontVariantCapsUnicase
  FontVariantCapsTitlingCaps
} derive(Eq, Debug)

///|
pub extend FontVariantCaps with Eq::{equal, not_equal}

///|
pub extend FontVariantCaps with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontVariantCaps::to_css(self : FontVariantCaps) -> String {
  match self {
    FontVariantCapsNormal => "normal"
    FontVariantCapsSmallCaps => "small-caps"
    FontVariantCapsAllSmallCaps => "all-small-caps"
    FontVariantCapsPetiteCaps => "petite-caps"
    FontVariantCapsAllPetiteCaps => "all-petite-caps"
    FontVariantCapsUnicase => "unicase"
    FontVariantCapsTitlingCaps => "titling-caps"
  }
}

///|
pub(all) enum ListStylePosition {
  ListStylePositionInside
  ListStylePositionOutside
} derive(Eq, Debug)

///|
pub extend ListStylePosition with Eq::{equal, not_equal}

///|
pub extend ListStylePosition with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ListStylePosition::to_css(self : ListStylePosition) -> String {
  match self {
    ListStylePositionInside => "inside"
    ListStylePositionOutside => "outside"
  }
}

///|
pub(all) enum BackgroundAttachment {
  BackgroundAttachmentScroll
  BackgroundAttachmentFixed
  BackgroundAttachmentLocal
} derive(Eq, Debug)

///|
pub extend BackgroundAttachment with Eq::{equal, not_equal}

///|
pub extend BackgroundAttachment with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BackgroundAttachment::to_css(self : BackgroundAttachment) -> String {
  match self {
    BackgroundAttachmentScroll => "scroll"
    BackgroundAttachmentFixed => "fixed"
    BackgroundAttachmentLocal => "local"
  }
}

///|
pub(all) enum BackgroundBox {
  BackgroundBoxBorderBox
  BackgroundBoxPaddingBox
  BackgroundBoxContentBox
} derive(Eq, Debug)

///|
pub extend BackgroundBox with Eq::{equal, not_equal}

///|
pub extend BackgroundBox with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BackgroundBox::to_css(self : BackgroundBox) -> String {
  match self {
    BackgroundBoxBorderBox => "border-box"
    BackgroundBoxPaddingBox => "padding-box"
    BackgroundBoxContentBox => "content-box"
  }
}

///|
pub(all) enum BlendMode {
  BlendModeNormal
  BlendModeMultiply
  BlendModeScreen
  BlendModeOverlay
  BlendModeDarken
  BlendModeLighten
  BlendModeColorDodge
  BlendModeColorBurn
  BlendModeHardLight
  BlendModeSoftLight
  BlendModeDifference
  BlendModeExclusion
  BlendModeHue
  BlendModeSaturation
  BlendModeColor
  BlendModeLuminosity
} derive(Eq, Debug)

///|
pub extend BlendMode with Eq::{equal, not_equal}

///|
pub extend BlendMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BlendMode::to_css(self : BlendMode) -> String {
  match self {
    BlendModeNormal => "normal"
    BlendModeMultiply => "multiply"
    BlendModeScreen => "screen"
    BlendModeOverlay => "overlay"
    BlendModeDarken => "darken"
    BlendModeLighten => "lighten"
    BlendModeColorDodge => "color-dodge"
    BlendModeColorBurn => "color-burn"
    BlendModeHardLight => "hard-light"
    BlendModeSoftLight => "soft-light"
    BlendModeDifference => "difference"
    BlendModeExclusion => "exclusion"
    BlendModeHue => "hue"
    BlendModeSaturation => "saturation"
    BlendModeColor => "color"
    BlendModeLuminosity => "luminosity"
  }
}

///|
pub(all) enum ImageRendering {
  ImageRenderingAuto
  ImageRenderingSmooth
  ImageRenderingHighQuality
  ImageRenderingCrispEdges
  ImageRenderingPixelated
} derive(Eq, Debug)

///|
pub extend ImageRendering with Eq::{equal, not_equal}

///|
pub extend ImageRendering with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ImageRendering::to_css(self : ImageRendering) -> String {
  match self {
    ImageRenderingAuto => "auto"
    ImageRenderingSmooth => "smooth"
    ImageRenderingHighQuality => "high-quality"
    ImageRenderingCrispEdges => "crisp-edges"
    ImageRenderingPixelated => "pixelated"
  }
}

///|
pub(all) enum BackfaceVisibility {
  BackfaceVisibilityVisible
  BackfaceVisibilityHidden
} derive(Eq, Debug)

///|
pub extend BackfaceVisibility with Eq::{equal, not_equal}

///|
pub extend BackfaceVisibility with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BackfaceVisibility::to_css(self : BackfaceVisibility) -> String {
  match self {
    BackfaceVisibilityVisible => "visible"
    BackfaceVisibilityHidden => "hidden"
  }
}

///|
pub(all) enum TransformStyle {
  TransformStyleFlat
  TransformStylePreserve3d
} derive(Eq, Debug)

///|
pub extend TransformStyle with Eq::{equal, not_equal}

///|
pub extend TransformStyle with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TransformStyle::to_css(self : TransformStyle) -> String {
  match self {
    TransformStyleFlat => "flat"
    TransformStylePreserve3d => "preserve-3d"
  }
}

///|
pub(all) enum AnimationDirection {
  AnimationDirectionNormal
  AnimationDirectionReverse
  AnimationDirectionAlternate
  AnimationDirectionAlternateReverse
} derive(Eq, Debug)

///|
pub extend AnimationDirection with Eq::{equal, not_equal}

///|
pub extend AnimationDirection with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn AnimationDirection::to_css(self : AnimationDirection) -> String {
  match self {
    AnimationDirectionNormal => "normal"
    AnimationDirectionReverse => "reverse"
    AnimationDirectionAlternate => "alternate"
    AnimationDirectionAlternateReverse => "alternate-reverse"
  }
}

///|
pub(all) enum AnimationFillMode {
  AnimationFillModeNone
  AnimationFillModeForwards
  AnimationFillModeBackwards
  AnimationFillModeBoth
} derive(Eq, Debug)

///|
pub extend AnimationFillMode with Eq::{equal, not_equal}

///|
pub extend AnimationFillMode with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn AnimationFillMode::to_css(self : AnimationFillMode) -> String {
  match self {
    AnimationFillModeNone => "none"
    AnimationFillModeForwards => "forwards"
    AnimationFillModeBackwards => "backwards"
    AnimationFillModeBoth => "both"
  }
}

///|
pub(all) enum AnimationPlayState {
  AnimationPlayStateRunning
  AnimationPlayStatePaused
} derive(Eq, Debug)

///|
pub extend AnimationPlayState with Eq::{equal, not_equal}

///|
pub extend AnimationPlayState with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn AnimationPlayState::to_css(self : AnimationPlayState) -> String {
  match self {
    AnimationPlayStateRunning => "running"
    AnimationPlayStatePaused => "paused"
  }
}

///|
pub(all) enum TransitionProperty {
  TransitionPropertyNone
  TransitionPropertyAll
  TransitionPropertyOpacity
  TransitionPropertyTransform
  TransitionPropertyColor
  TransitionPropertyBackgroundColor
} derive(Eq, Debug)

///|
pub extend TransitionProperty with Eq::{equal, not_equal}

///|
pub extend TransitionProperty with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TransitionProperty::to_css(self : TransitionProperty) -> String {
  match self {
    TransitionPropertyNone => "none"
    TransitionPropertyAll => "all"
    TransitionPropertyOpacity => "opacity"
    TransitionPropertyTransform => "transform"
    TransitionPropertyColor => "color"
    TransitionPropertyBackgroundColor => "background-color"
  }
}

///|
pub(all) enum PointerEvents {
  PointerEventsAuto
  PointerEventsNone
} derive(Eq, Debug)

///|
pub extend PointerEvents with Eq::{equal, not_equal}

///|
pub extend PointerEvents with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn PointerEvents::to_css(self : PointerEvents) -> String {
  match self {
    PointerEventsAuto => "auto"
    PointerEventsNone => "none"
  }
}

///|
pub(all) enum UserSelect {
  UserSelectAuto
  UserSelectText
  UserSelectNone
  UserSelectContain
  UserSelectAll
} derive(Eq, Debug)

///|
pub extend UserSelect with Eq::{equal, not_equal}

///|
pub extend UserSelect with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn UserSelect::to_css(self : UserSelect) -> String {
  match self {
    UserSelectAuto => "auto"
    UserSelectText => "text"
    UserSelectNone => "none"
    UserSelectContain => "contain"
    UserSelectAll => "all"
  }
}

///|
pub(all) enum ScrollBehavior {
  ScrollBehaviorAuto
  ScrollBehaviorSmooth
} derive(Eq, Debug)

///|
pub extend ScrollBehavior with Eq::{equal, not_equal}

///|
pub extend ScrollBehavior with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ScrollBehavior::to_css(self : ScrollBehavior) -> String {
  match self {
    ScrollBehaviorAuto => "auto"
    ScrollBehaviorSmooth => "smooth"
  }
}

///|
pub(all) enum OverscrollBehavior {
  OverscrollBehaviorAuto
  OverscrollBehaviorContain
  OverscrollBehaviorNone
} derive(Eq, Debug)

///|
pub extend OverscrollBehavior with Eq::{equal, not_equal}

///|
pub extend OverscrollBehavior with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn OverscrollBehavior::to_css(self : OverscrollBehavior) -> String {
  match self {
    OverscrollBehaviorAuto => "auto"
    OverscrollBehaviorContain => "contain"
    OverscrollBehaviorNone => "none"
  }
}

///|
pub(all) enum ContentVisibility {
  ContentVisibilityVisible
  ContentVisibilityAuto
  ContentVisibilityHidden
} derive(Eq, Debug)

///|
pub extend ContentVisibility with Eq::{equal, not_equal}

///|
pub extend ContentVisibility with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ContentVisibility::to_css(self : ContentVisibility) -> String {
  match self {
    ContentVisibilityVisible => "visible"
    ContentVisibilityAuto => "auto"
    ContentVisibilityHidden => "hidden"
  }
}

///|
pub(all) enum BaselineSourceValue {
  BaselineSourceValueAuto
  BaselineSourceValueFirst
  BaselineSourceValueLast
} derive(Eq, Debug)

///|
pub extend BaselineSourceValue with Eq::{equal, not_equal}

///|
pub extend BaselineSourceValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BaselineSourceValue::to_css(self : BaselineSourceValue) -> String {
  match self {
    BaselineSourceValueAuto => "auto"
    BaselineSourceValueFirst => "first"
    BaselineSourceValueLast => "last"
  }
}

///|
pub(all) enum BorderCollapseValue {
  BorderCollapseValueSeparate
  BorderCollapseValueCollapse
} derive(Eq, Debug)

///|
pub extend BorderCollapseValue with Eq::{equal, not_equal}

///|
pub extend BorderCollapseValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BorderCollapseValue::to_css(self : BorderCollapseValue) -> String {
  match self {
    BorderCollapseValueSeparate => "separate"
    BorderCollapseValueCollapse => "collapse"
  }
}

///|
pub(all) enum BorderImageRepeatValue {
  BorderImageRepeatValueStretch
  BorderImageRepeatValueRepeat
  BorderImageRepeatValueRound
  BorderImageRepeatValueSpace
} derive(Eq, Debug)

///|
pub extend BorderImageRepeatValue with Eq::{equal, not_equal}

///|
pub extend BorderImageRepeatValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BorderImageRepeatValue::to_css(self : BorderImageRepeatValue) -> String {
  match self {
    BorderImageRepeatValueStretch => "stretch"
    BorderImageRepeatValueRepeat => "repeat"
    BorderImageRepeatValueRound => "round"
    BorderImageRepeatValueSpace => "space"
  }
}

///|
pub(all) enum BoxDecorationBreakValue {
  BoxDecorationBreakValueSlice
  BoxDecorationBreakValueClone
} derive(Eq, Debug)

///|
pub extend BoxDecorationBreakValue with Eq::{equal, not_equal}

///|
pub extend BoxDecorationBreakValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BoxDecorationBreakValue::to_css(self : BoxDecorationBreakValue) -> String {
  match self {
    BoxDecorationBreakValueSlice => "slice"
    BoxDecorationBreakValueClone => "clone"
  }
}

///|
pub(all) enum BreakAfterValue {
  BreakAfterValueAuto
  BreakAfterValueAvoid
  BreakAfterValueAlways
  BreakAfterValueAll
  BreakAfterValueAvoidPage
  BreakAfterValuePage
  BreakAfterValueLeft
  BreakAfterValueRight
  BreakAfterValueRecto
  BreakAfterValueVerso
  BreakAfterValueAvoidColumn
  BreakAfterValueColumn
  BreakAfterValueAvoidRegion
  BreakAfterValueRegion
} derive(Eq, Debug)

///|
pub extend BreakAfterValue with Eq::{equal, not_equal}

///|
pub extend BreakAfterValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BreakAfterValue::to_css(self : BreakAfterValue) -> String {
  match self {
    BreakAfterValueAuto => "auto"
    BreakAfterValueAvoid => "avoid"
    BreakAfterValueAlways => "always"
    BreakAfterValueAll => "all"
    BreakAfterValueAvoidPage => "avoid-page"
    BreakAfterValuePage => "page"
    BreakAfterValueLeft => "left"
    BreakAfterValueRight => "right"
    BreakAfterValueRecto => "recto"
    BreakAfterValueVerso => "verso"
    BreakAfterValueAvoidColumn => "avoid-column"
    BreakAfterValueColumn => "column"
    BreakAfterValueAvoidRegion => "avoid-region"
    BreakAfterValueRegion => "region"
  }
}

///|
pub(all) enum BreakBeforeValue {
  BreakBeforeValueAuto
  BreakBeforeValueAvoid
  BreakBeforeValueAlways
  BreakBeforeValueAll
  BreakBeforeValueAvoidPage
  BreakBeforeValuePage
  BreakBeforeValueLeft
  BreakBeforeValueRight
  BreakBeforeValueRecto
  BreakBeforeValueVerso
  BreakBeforeValueAvoidColumn
  BreakBeforeValueColumn
  BreakBeforeValueAvoidRegion
  BreakBeforeValueRegion
} derive(Eq, Debug)

///|
pub extend BreakBeforeValue with Eq::{equal, not_equal}

///|
pub extend BreakBeforeValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BreakBeforeValue::to_css(self : BreakBeforeValue) -> String {
  match self {
    BreakBeforeValueAuto => "auto"
    BreakBeforeValueAvoid => "avoid"
    BreakBeforeValueAlways => "always"
    BreakBeforeValueAll => "all"
    BreakBeforeValueAvoidPage => "avoid-page"
    BreakBeforeValuePage => "page"
    BreakBeforeValueLeft => "left"
    BreakBeforeValueRight => "right"
    BreakBeforeValueRecto => "recto"
    BreakBeforeValueVerso => "verso"
    BreakBeforeValueAvoidColumn => "avoid-column"
    BreakBeforeValueColumn => "column"
    BreakBeforeValueAvoidRegion => "avoid-region"
    BreakBeforeValueRegion => "region"
  }
}

///|
pub(all) enum BreakInsideValue {
  BreakInsideValueAuto
  BreakInsideValueAvoid
  BreakInsideValueAvoidPage
  BreakInsideValueAvoidColumn
  BreakInsideValueAvoidRegion
} derive(Eq, Debug)

///|
pub extend BreakInsideValue with Eq::{equal, not_equal}

///|
pub extend BreakInsideValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn BreakInsideValue::to_css(self : BreakInsideValue) -> String {
  match self {
    BreakInsideValueAuto => "auto"
    BreakInsideValueAvoid => "avoid"
    BreakInsideValueAvoidPage => "avoid-page"
    BreakInsideValueAvoidColumn => "avoid-column"
    BreakInsideValueAvoidRegion => "avoid-region"
  }
}

///|
pub(all) enum CaptionSideValue {
  CaptionSideValueTop
  CaptionSideValueBottom
} derive(Eq, Debug)

///|
pub extend CaptionSideValue with Eq::{equal, not_equal}

///|
pub extend CaptionSideValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn CaptionSideValue::to_css(self : CaptionSideValue) -> String {
  match self {
    CaptionSideValueTop => "top"
    CaptionSideValueBottom => "bottom"
  }
}

///|
pub(all) enum ClipRuleValue {
  ClipRuleValueNonzero
  ClipRuleValueEvenodd
} derive(Eq, Debug)

///|
pub extend ClipRuleValue with Eq::{equal, not_equal}

///|
pub extend ClipRuleValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ClipRuleValue::to_css(self : ClipRuleValue) -> String {
  match self {
    ClipRuleValueNonzero => "nonzero"
    ClipRuleValueEvenodd => "evenodd"
  }
}

///|
pub(all) enum ColorInterpolationFiltersValue {
  ColorInterpolationFiltersValueAuto
  ColorInterpolationFiltersValueSRGB
  ColorInterpolationFiltersValueLinearRGB
} derive(Eq, Debug)

///|
pub extend ColorInterpolationFiltersValue with Eq::{equal, not_equal}

///|
pub extend ColorInterpolationFiltersValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ColorInterpolationFiltersValue::to_css(self : ColorInterpolationFiltersValue) -> String {
  match self {
    ColorInterpolationFiltersValueAuto => "auto"
    ColorInterpolationFiltersValueSRGB => "sRGB"
    ColorInterpolationFiltersValueLinearRGB => "linearRGB"
  }
}

///|
pub(all) enum ColumnFillValue {
  ColumnFillValueAuto
  ColumnFillValueBalance
} derive(Eq, Debug)

///|
pub extend ColumnFillValue with Eq::{equal, not_equal}

///|
pub extend ColumnFillValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ColumnFillValue::to_css(self : ColumnFillValue) -> String {
  match self {
    ColumnFillValueAuto => "auto"
    ColumnFillValueBalance => "balance"
  }
}

///|
pub(all) enum ColumnSpanValue {
  ColumnSpanValueNone
  ColumnSpanValueAll
} derive(Eq, Debug)

///|
pub extend ColumnSpanValue with Eq::{equal, not_equal}

///|
pub extend ColumnSpanValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ColumnSpanValue::to_css(self : ColumnSpanValue) -> String {
  match self {
    ColumnSpanValueNone => "none"
    ColumnSpanValueAll => "all"
  }
}

///|
pub(all) enum ContainerTypeValue {
  ContainerTypeValueNormal
  ContainerTypeValueSize
  ContainerTypeValueInlineSize
} derive(Eq, Debug)

///|
pub extend ContainerTypeValue with Eq::{equal, not_equal}

///|
pub extend ContainerTypeValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ContainerTypeValue::to_css(self : ContainerTypeValue) -> String {
  match self {
    ContainerTypeValueNormal => "normal"
    ContainerTypeValueSize => "size"
    ContainerTypeValueInlineSize => "inline-size"
  }
}

///|
pub(all) enum DirectionValue {
  DirectionValueLtr
  DirectionValueRtl
} derive(Eq, Debug)

///|
pub extend DirectionValue with Eq::{equal, not_equal}

///|
pub extend DirectionValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn DirectionValue::to_css(self : DirectionValue) -> String {
  match self {
    DirectionValueLtr => "ltr"
    DirectionValueRtl => "rtl"
  }
}

///|
pub(all) enum EmptyCellsValue {
  EmptyCellsValueShow
  EmptyCellsValueHide
} derive(Eq, Debug)

///|
pub extend EmptyCellsValue with Eq::{equal, not_equal}

///|
pub extend EmptyCellsValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn EmptyCellsValue::to_css(self : EmptyCellsValue) -> String {
  match self {
    EmptyCellsValueShow => "show"
    EmptyCellsValueHide => "hide"
  }
}

///|
pub(all) enum FieldSizingValue {
  FieldSizingValueFixed
  FieldSizingValueContent
} derive(Eq, Debug)

///|
pub extend FieldSizingValue with Eq::{equal, not_equal}

///|
pub extend FieldSizingValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FieldSizingValue::to_css(self : FieldSizingValue) -> String {
  match self {
    FieldSizingValueFixed => "fixed"
    FieldSizingValueContent => "content"
  }
}

///|
pub(all) enum FillRuleValue {
  FillRuleValueNonzero
  FillRuleValueEvenodd
} derive(Eq, Debug)

///|
pub extend FillRuleValue with Eq::{equal, not_equal}

///|
pub extend FillRuleValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FillRuleValue::to_css(self : FillRuleValue) -> String {
  match self {
    FillRuleValueNonzero => "nonzero"
    FillRuleValueEvenodd => "evenodd"
  }
}

///|
pub(all) enum FontSynthesisValue {
  FontSynthesisValueNone
  FontSynthesisValueWeight
  FontSynthesisValueStyle
  FontSynthesisValueSmallCaps
  FontSynthesisValuePosition
} derive(Eq, Debug)

///|
pub extend FontSynthesisValue with Eq::{equal, not_equal}

///|
pub extend FontSynthesisValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontSynthesisValue::to_css(self : FontSynthesisValue) -> String {
  match self {
    FontSynthesisValueNone => "none"
    FontSynthesisValueWeight => "weight"
    FontSynthesisValueStyle => "style"
    FontSynthesisValueSmallCaps => "small-caps"
    FontSynthesisValuePosition => "position"
  }
}

///|
pub(all) enum FontSynthesisSmallCapsValue {
  FontSynthesisSmallCapsValueAuto
  FontSynthesisSmallCapsValueNone
} derive(Eq, Debug)

///|
pub extend FontSynthesisSmallCapsValue with Eq::{equal, not_equal}

///|
pub extend FontSynthesisSmallCapsValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontSynthesisSmallCapsValue::to_css(self : FontSynthesisSmallCapsValue) -> String {
  match self {
    FontSynthesisSmallCapsValueAuto => "auto"
    FontSynthesisSmallCapsValueNone => "none"
  }
}

///|
pub(all) enum FontSynthesisStyleValue {
  FontSynthesisStyleValueAuto
  FontSynthesisStyleValueNone
} derive(Eq, Debug)

///|
pub extend FontSynthesisStyleValue with Eq::{equal, not_equal}

///|
pub extend FontSynthesisStyleValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontSynthesisStyleValue::to_css(self : FontSynthesisStyleValue) -> String {
  match self {
    FontSynthesisStyleValueAuto => "auto"
    FontSynthesisStyleValueNone => "none"
  }
}

///|
pub(all) enum FontSynthesisWeightValue {
  FontSynthesisWeightValueAuto
  FontSynthesisWeightValueNone
} derive(Eq, Debug)

///|
pub extend FontSynthesisWeightValue with Eq::{equal, not_equal}

///|
pub extend FontSynthesisWeightValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontSynthesisWeightValue::to_css(self : FontSynthesisWeightValue) -> String {
  match self {
    FontSynthesisWeightValueAuto => "auto"
    FontSynthesisWeightValueNone => "none"
  }
}

///|
pub(all) enum FontVariantEmojiValue {
  FontVariantEmojiValueNormal
  FontVariantEmojiValueText
  FontVariantEmojiValueEmoji
  FontVariantEmojiValueUnicode
} derive(Eq, Debug)

///|
pub extend FontVariantEmojiValue with Eq::{equal, not_equal}

///|
pub extend FontVariantEmojiValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontVariantEmojiValue::to_css(self : FontVariantEmojiValue) -> String {
  match self {
    FontVariantEmojiValueNormal => "normal"
    FontVariantEmojiValueText => "text"
    FontVariantEmojiValueEmoji => "emoji"
    FontVariantEmojiValueUnicode => "unicode"
  }
}

///|
pub(all) enum FontVariantPositionValue {
  FontVariantPositionValueNormal
  FontVariantPositionValueSub
  FontVariantPositionValueSuper
} derive(Eq, Debug)

///|
pub extend FontVariantPositionValue with Eq::{equal, not_equal}

///|
pub extend FontVariantPositionValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn FontVariantPositionValue::to_css(self : FontVariantPositionValue) -> String {
  match self {
    FontVariantPositionValueNormal => "normal"
    FontVariantPositionValueSub => "sub"
    FontVariantPositionValueSuper => "super"
  }
}

///|
pub(all) enum ForcedColorAdjustValue {
  ForcedColorAdjustValueAuto
  ForcedColorAdjustValueNone
  ForcedColorAdjustValuePreserveParentColor
} derive(Eq, Debug)

///|
pub extend ForcedColorAdjustValue with Eq::{equal, not_equal}

///|
pub extend ForcedColorAdjustValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ForcedColorAdjustValue::to_css(self : ForcedColorAdjustValue) -> String {
  match self {
    ForcedColorAdjustValueAuto => "auto"
    ForcedColorAdjustValueNone => "none"
    ForcedColorAdjustValuePreserveParentColor => "preserve-parent-color"
  }
}

///|
pub(all) enum HangingPunctuationValue {
  HangingPunctuationValueNone
  HangingPunctuationValueFirst
  HangingPunctuationValueForceEnd
  HangingPunctuationValueAllowEnd
  HangingPunctuationValueLast
} derive(Eq, Debug)

///|
pub extend HangingPunctuationValue with Eq::{equal, not_equal}

///|
pub extend HangingPunctuationValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn HangingPunctuationValue::to_css(self : HangingPunctuationValue) -> String {
  match self {
    HangingPunctuationValueNone => "none"
    HangingPunctuationValueFirst => "first"
    HangingPunctuationValueForceEnd => "force-end"
    HangingPunctuationValueAllowEnd => "allow-end"
    HangingPunctuationValueLast => "last"
  }
}

///|
pub(all) enum LineBreakValue {
  LineBreakValueAuto
  LineBreakValueLoose
  LineBreakValueNormal
  LineBreakValueStrict
  LineBreakValueAnywhere
} derive(Eq, Debug)

///|
pub extend LineBreakValue with Eq::{equal, not_equal}

///|
pub extend LineBreakValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn LineBreakValue::to_css(self : LineBreakValue) -> String {
  match self {
    LineBreakValueAuto => "auto"
    LineBreakValueLoose => "loose"
    LineBreakValueNormal => "normal"
    LineBreakValueStrict => "strict"
    LineBreakValueAnywhere => "anywhere"
  }
}

///|
pub(all) enum MaskTypeValue {
  MaskTypeValueLuminance
  MaskTypeValueAlpha
} derive(Eq, Debug)

///|
pub extend MaskTypeValue with Eq::{equal, not_equal}

///|
pub extend MaskTypeValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn MaskTypeValue::to_css(self : MaskTypeValue) -> String {
  match self {
    MaskTypeValueLuminance => "luminance"
    MaskTypeValueAlpha => "alpha"
  }
}

///|
pub(all) enum MathShiftValue {
  MathShiftValueNormal
  MathShiftValueCompact
} derive(Eq, Debug)

///|
pub extend MathShiftValue with Eq::{equal, not_equal}

///|
pub extend MathShiftValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn MathShiftValue::to_css(self : MathShiftValue) -> String {
  match self {
    MathShiftValueNormal => "normal"
    MathShiftValueCompact => "compact"
  }
}

///|
pub(all) enum MathStyleValue {
  MathStyleValueNormal
  MathStyleValueCompact
} derive(Eq, Debug)

///|
pub extend MathStyleValue with Eq::{equal, not_equal}

///|
pub extend MathStyleValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn MathStyleValue::to_css(self : MathStyleValue) -> String {
  match self {
    MathStyleValueNormal => "normal"
    MathStyleValueCompact => "compact"
  }
}

///|
pub(all) enum OverflowAnchorValue {
  OverflowAnchorValueAuto
  OverflowAnchorValueNone
} derive(Eq, Debug)

///|
pub extend OverflowAnchorValue with Eq::{equal, not_equal}

///|
pub extend OverflowAnchorValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn OverflowAnchorValue::to_css(self : OverflowAnchorValue) -> String {
  match self {
    OverflowAnchorValueAuto => "auto"
    OverflowAnchorValueNone => "none"
  }
}

///|
pub(all) enum OverscrollBehaviorValue {
  OverscrollBehaviorValueContain
  OverscrollBehaviorValueNone
  OverscrollBehaviorValueAuto
} derive(Eq, Debug)

///|
pub extend OverscrollBehaviorValue with Eq::{equal, not_equal}

///|
pub extend OverscrollBehaviorValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn OverscrollBehaviorValue::to_css(self : OverscrollBehaviorValue) -> String {
  match self {
    OverscrollBehaviorValueContain => "contain"
    OverscrollBehaviorValueNone => "none"
    OverscrollBehaviorValueAuto => "auto"
  }
}

///|
pub(all) enum OverscrollBehaviorBlockValue {
  OverscrollBehaviorBlockValueContain
  OverscrollBehaviorBlockValueNone
  OverscrollBehaviorBlockValueAuto
} derive(Eq, Debug)

///|
pub extend OverscrollBehaviorBlockValue with Eq::{equal, not_equal}

///|
pub extend OverscrollBehaviorBlockValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn OverscrollBehaviorBlockValue::to_css(self : OverscrollBehaviorBlockValue) -> String {
  match self {
    OverscrollBehaviorBlockValueContain => "contain"
    OverscrollBehaviorBlockValueNone => "none"
    OverscrollBehaviorBlockValueAuto => "auto"
  }
}

///|
pub(all) enum OverscrollBehaviorInlineValue {
  OverscrollBehaviorInlineValueContain
  OverscrollBehaviorInlineValueNone
  OverscrollBehaviorInlineValueAuto
} derive(Eq, Debug)

///|
pub extend OverscrollBehaviorInlineValue with Eq::{equal, not_equal}

///|
pub extend OverscrollBehaviorInlineValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn OverscrollBehaviorInlineValue::to_css(self : OverscrollBehaviorInlineValue) -> String {
  match self {
    OverscrollBehaviorInlineValueContain => "contain"
    OverscrollBehaviorInlineValueNone => "none"
    OverscrollBehaviorInlineValueAuto => "auto"
  }
}

///|
pub(all) enum PaintOrderValue {
  PaintOrderValueNormal
  PaintOrderValueFill
  PaintOrderValueStroke
  PaintOrderValueMarkers
} derive(Eq, Debug)

///|
pub extend PaintOrderValue with Eq::{equal, not_equal}

///|
pub extend PaintOrderValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn PaintOrderValue::to_css(self : PaintOrderValue) -> String {
  match self {
    PaintOrderValueNormal => "normal"
    PaintOrderValueFill => "fill"
    PaintOrderValueStroke => "stroke"
    PaintOrderValueMarkers => "markers"
  }
}

///|
pub(all) enum PositionVisibilityValue {
  PositionVisibilityValueAlways
  PositionVisibilityValueNoOverflow
} derive(Eq, Debug)

///|
pub extend PositionVisibilityValue with Eq::{equal, not_equal}

///|
pub extend PositionVisibilityValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn PositionVisibilityValue::to_css(self : PositionVisibilityValue) -> String {
  match self {
    PositionVisibilityValueAlways => "always"
    PositionVisibilityValueNoOverflow => "no-overflow"
  }
}

///|
pub(all) enum PrintColorAdjustValue {
  PrintColorAdjustValueEconomy
  PrintColorAdjustValueExact
} derive(Eq, Debug)

///|
pub extend PrintColorAdjustValue with Eq::{equal, not_equal}

///|
pub extend PrintColorAdjustValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn PrintColorAdjustValue::to_css(self : PrintColorAdjustValue) -> String {
  match self {
    PrintColorAdjustValueEconomy => "economy"
    PrintColorAdjustValueExact => "exact"
  }
}

///|
pub(all) enum RubyAlignValue {
  RubyAlignValueStart
  RubyAlignValueCenter
  RubyAlignValueSpaceBetween
  RubyAlignValueSpaceAround
} derive(Eq, Debug)

///|
pub extend RubyAlignValue with Eq::{equal, not_equal}

///|
pub extend RubyAlignValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn RubyAlignValue::to_css(self : RubyAlignValue) -> String {
  match self {
    RubyAlignValueStart => "start"
    RubyAlignValueCenter => "center"
    RubyAlignValueSpaceBetween => "space-between"
    RubyAlignValueSpaceAround => "space-around"
  }
}

///|
pub(all) enum RubyPositionValue {
  RubyPositionValueAlternate
  RubyPositionValueOver
  RubyPositionValueUnder
  RubyPositionValueInterCharacter
} derive(Eq, Debug)

///|
pub extend RubyPositionValue with Eq::{equal, not_equal}

///|
pub extend RubyPositionValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn RubyPositionValue::to_css(self : RubyPositionValue) -> String {
  match self {
    RubyPositionValueAlternate => "alternate"
    RubyPositionValueOver => "over"
    RubyPositionValueUnder => "under"
    RubyPositionValueInterCharacter => "inter-character"
  }
}

///|
pub(all) enum ScrollSnapAlignValue {
  ScrollSnapAlignValueNone
  ScrollSnapAlignValueStart
  ScrollSnapAlignValueEnd
  ScrollSnapAlignValueCenter
} derive(Eq, Debug)

///|
pub extend ScrollSnapAlignValue with Eq::{equal, not_equal}

///|
pub extend ScrollSnapAlignValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ScrollSnapAlignValue::to_css(self : ScrollSnapAlignValue) -> String {
  match self {
    ScrollSnapAlignValueNone => "none"
    ScrollSnapAlignValueStart => "start"
    ScrollSnapAlignValueEnd => "end"
    ScrollSnapAlignValueCenter => "center"
  }
}

///|
pub(all) enum ScrollSnapStopValue {
  ScrollSnapStopValueNormal
  ScrollSnapStopValueAlways
} derive(Eq, Debug)

///|
pub extend ScrollSnapStopValue with Eq::{equal, not_equal}

///|
pub extend ScrollSnapStopValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ScrollSnapStopValue::to_css(self : ScrollSnapStopValue) -> String {
  match self {
    ScrollSnapStopValueNormal => "normal"
    ScrollSnapStopValueAlways => "always"
  }
}

///|
pub(all) enum ScrollSnapTypeValue {
  ScrollSnapTypeValueNone
  ScrollSnapTypeValueX
  ScrollSnapTypeValueY
  ScrollSnapTypeValueBlock
  ScrollSnapTypeValueInline
  ScrollSnapTypeValueBoth
} derive(Eq, Debug)

///|
pub extend ScrollSnapTypeValue with Eq::{equal, not_equal}

///|
pub extend ScrollSnapTypeValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ScrollSnapTypeValue::to_css(self : ScrollSnapTypeValue) -> String {
  match self {
    ScrollSnapTypeValueNone => "none"
    ScrollSnapTypeValueX => "x"
    ScrollSnapTypeValueY => "y"
    ScrollSnapTypeValueBlock => "block"
    ScrollSnapTypeValueInline => "inline"
    ScrollSnapTypeValueBoth => "both"
  }
}

///|
pub(all) enum ScrollTimelineAxisValue {
  ScrollTimelineAxisValueBlock
  ScrollTimelineAxisValueInline
  ScrollTimelineAxisValueX
  ScrollTimelineAxisValueY
} derive(Eq, Debug)

///|
pub extend ScrollTimelineAxisValue with Eq::{equal, not_equal}

///|
pub extend ScrollTimelineAxisValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ScrollTimelineAxisValue::to_css(self : ScrollTimelineAxisValue) -> String {
  match self {
    ScrollTimelineAxisValueBlock => "block"
    ScrollTimelineAxisValueInline => "inline"
    ScrollTimelineAxisValueX => "x"
    ScrollTimelineAxisValueY => "y"
  }
}

///|
pub(all) enum ScrollbarWidthValue {
  ScrollbarWidthValueAuto
  ScrollbarWidthValueThin
  ScrollbarWidthValueNone
} derive(Eq, Debug)

///|
pub extend ScrollbarWidthValue with Eq::{equal, not_equal}

///|
pub extend ScrollbarWidthValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ScrollbarWidthValue::to_css(self : ScrollbarWidthValue) -> String {
  match self {
    ScrollbarWidthValueAuto => "auto"
    ScrollbarWidthValueThin => "thin"
    ScrollbarWidthValueNone => "none"
  }
}

///|
pub(all) enum ShapeRenderingValue {
  ShapeRenderingValueAuto
  ShapeRenderingValueOptimizeSpeed
  ShapeRenderingValueCrispEdges
  ShapeRenderingValueGeometricPrecision
} derive(Eq, Debug)

///|
pub extend ShapeRenderingValue with Eq::{equal, not_equal}

///|
pub extend ShapeRenderingValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ShapeRenderingValue::to_css(self : ShapeRenderingValue) -> String {
  match self {
    ShapeRenderingValueAuto => "auto"
    ShapeRenderingValueOptimizeSpeed => "optimizeSpeed"
    ShapeRenderingValueCrispEdges => "crispEdges"
    ShapeRenderingValueGeometricPrecision => "geometricPrecision"
  }
}

///|
pub(all) enum SpeakValue {
  SpeakValueAuto
  SpeakValueNever
  SpeakValueAlways
} derive(Eq, Debug)

///|
pub extend SpeakValue with Eq::{equal, not_equal}

///|
pub extend SpeakValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn SpeakValue::to_css(self : SpeakValue) -> String {
  match self {
    SpeakValueAuto => "auto"
    SpeakValueNever => "never"
    SpeakValueAlways => "always"
  }
}

///|
pub(all) enum StrokeLinecapValue {
  StrokeLinecapValueButt
  StrokeLinecapValueRound
  StrokeLinecapValueSquare
} derive(Eq, Debug)

///|
pub extend StrokeLinecapValue with Eq::{equal, not_equal}

///|
pub extend StrokeLinecapValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn StrokeLinecapValue::to_css(self : StrokeLinecapValue) -> String {
  match self {
    StrokeLinecapValueButt => "butt"
    StrokeLinecapValueRound => "round"
    StrokeLinecapValueSquare => "square"
  }
}

///|
pub(all) enum StrokeLinejoinValue {
  StrokeLinejoinValueMiter
  StrokeLinejoinValueBevel
  StrokeLinejoinValueRound
} derive(Eq, Debug)

///|
pub extend StrokeLinejoinValue with Eq::{equal, not_equal}

///|
pub extend StrokeLinejoinValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn StrokeLinejoinValue::to_css(self : StrokeLinejoinValue) -> String {
  match self {
    StrokeLinejoinValueMiter => "miter"
    StrokeLinejoinValueBevel => "bevel"
    StrokeLinejoinValueRound => "round"
  }
}

///|
pub(all) enum TableLayoutValue {
  TableLayoutValueAuto
  TableLayoutValueFixed
} derive(Eq, Debug)

///|
pub extend TableLayoutValue with Eq::{equal, not_equal}

///|
pub extend TableLayoutValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TableLayoutValue::to_css(self : TableLayoutValue) -> String {
  match self {
    TableLayoutValueAuto => "auto"
    TableLayoutValueFixed => "fixed"
  }
}

///|
pub(all) enum TextAnchorValue {
  TextAnchorValueStart
  TextAnchorValueMiddle
  TextAnchorValueEnd
} derive(Eq, Debug)

///|
pub extend TextAnchorValue with Eq::{equal, not_equal}

///|
pub extend TextAnchorValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextAnchorValue::to_css(self : TextAnchorValue) -> String {
  match self {
    TextAnchorValueStart => "start"
    TextAnchorValueMiddle => "middle"
    TextAnchorValueEnd => "end"
  }
}

///|
pub(all) enum TextBoxTrimValue {
  TextBoxTrimValueNone
  TextBoxTrimValueTrimStart
  TextBoxTrimValueTrimEnd
  TextBoxTrimValueTrimBoth
} derive(Eq, Debug)

///|
pub extend TextBoxTrimValue with Eq::{equal, not_equal}

///|
pub extend TextBoxTrimValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextBoxTrimValue::to_css(self : TextBoxTrimValue) -> String {
  match self {
    TextBoxTrimValueNone => "none"
    TextBoxTrimValueTrimStart => "trim-start"
    TextBoxTrimValueTrimEnd => "trim-end"
    TextBoxTrimValueTrimBoth => "trim-both"
  }
}

///|
pub(all) enum TextCombineUprightValue {
  TextCombineUprightValueNone
  TextCombineUprightValueAll
  TextCombineUprightValueDigits
} derive(Eq, Debug)

///|
pub extend TextCombineUprightValue with Eq::{equal, not_equal}

///|
pub extend TextCombineUprightValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextCombineUprightValue::to_css(self : TextCombineUprightValue) -> String {
  match self {
    TextCombineUprightValueNone => "none"
    TextCombineUprightValueAll => "all"
    TextCombineUprightValueDigits => "digits"
  }
}

///|
pub(all) enum TextDecorationSkipInkValue {
  TextDecorationSkipInkValueAuto
  TextDecorationSkipInkValueNone
  TextDecorationSkipInkValueAll
} derive(Eq, Debug)

///|
pub extend TextDecorationSkipInkValue with Eq::{equal, not_equal}

///|
pub extend TextDecorationSkipInkValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextDecorationSkipInkValue::to_css(self : TextDecorationSkipInkValue) -> String {
  match self {
    TextDecorationSkipInkValueAuto => "auto"
    TextDecorationSkipInkValueNone => "none"
    TextDecorationSkipInkValueAll => "all"
  }
}

///|
pub(all) enum TextJustifyValue {
  TextJustifyValueAuto
  TextJustifyValueNone
  TextJustifyValueInterWord
  TextJustifyValueInterCharacter
} derive(Eq, Debug)

///|
pub extend TextJustifyValue with Eq::{equal, not_equal}

///|
pub extend TextJustifyValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextJustifyValue::to_css(self : TextJustifyValue) -> String {
  match self {
    TextJustifyValueAuto => "auto"
    TextJustifyValueNone => "none"
    TextJustifyValueInterWord => "inter-word"
    TextJustifyValueInterCharacter => "inter-character"
  }
}

///|
pub(all) enum TextOrientationValue {
  TextOrientationValueMixed
  TextOrientationValueUpright
  TextOrientationValueSideways
} derive(Eq, Debug)

///|
pub extend TextOrientationValue with Eq::{equal, not_equal}

///|
pub extend TextOrientationValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextOrientationValue::to_css(self : TextOrientationValue) -> String {
  match self {
    TextOrientationValueMixed => "mixed"
    TextOrientationValueUpright => "upright"
    TextOrientationValueSideways => "sideways"
  }
}

///|
pub(all) enum TextRenderingValue {
  TextRenderingValueAuto
  TextRenderingValueOptimizeSpeed
  TextRenderingValueOptimizeLegibility
  TextRenderingValueGeometricPrecision
} derive(Eq, Debug)

///|
pub extend TextRenderingValue with Eq::{equal, not_equal}

///|
pub extend TextRenderingValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TextRenderingValue::to_css(self : TextRenderingValue) -> String {
  match self {
    TextRenderingValueAuto => "auto"
    TextRenderingValueOptimizeSpeed => "optimizeSpeed"
    TextRenderingValueOptimizeLegibility => "optimizeLegibility"
    TextRenderingValueGeometricPrecision => "geometricPrecision"
  }
}

///|
pub(all) enum TransformBoxValue {
  TransformBoxValueContentBox
  TransformBoxValueBorderBox
  TransformBoxValueFillBox
  TransformBoxValueStrokeBox
  TransformBoxValueViewBox
} derive(Eq, Debug)

///|
pub extend TransformBoxValue with Eq::{equal, not_equal}

///|
pub extend TransformBoxValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn TransformBoxValue::to_css(self : TransformBoxValue) -> String {
  match self {
    TransformBoxValueContentBox => "content-box"
    TransformBoxValueBorderBox => "border-box"
    TransformBoxValueFillBox => "fill-box"
    TransformBoxValueStrokeBox => "stroke-box"
    TransformBoxValueViewBox => "view-box"
  }
}

///|
pub(all) enum UnicodeBidiValue {
  UnicodeBidiValueNormal
  UnicodeBidiValueEmbed
  UnicodeBidiValueIsolate
  UnicodeBidiValueBidiOverride
  UnicodeBidiValueIsolateOverride
  UnicodeBidiValuePlaintext
} derive(Eq, Debug)

///|
pub extend UnicodeBidiValue with Eq::{equal, not_equal}

///|
pub extend UnicodeBidiValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn UnicodeBidiValue::to_css(self : UnicodeBidiValue) -> String {
  match self {
    UnicodeBidiValueNormal => "normal"
    UnicodeBidiValueEmbed => "embed"
    UnicodeBidiValueIsolate => "isolate"
    UnicodeBidiValueBidiOverride => "bidi-override"
    UnicodeBidiValueIsolateOverride => "isolate-override"
    UnicodeBidiValuePlaintext => "plaintext"
  }
}

///|
pub(all) enum VectorEffectValue {
  VectorEffectValueNone
  VectorEffectValueNonScalingStroke
  VectorEffectValueNonScalingSize
  VectorEffectValueNonRotation
  VectorEffectValueFixedPosition
} derive(Eq, Debug)

///|
pub extend VectorEffectValue with Eq::{equal, not_equal}

///|
pub extend VectorEffectValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn VectorEffectValue::to_css(self : VectorEffectValue) -> String {
  match self {
    VectorEffectValueNone => "none"
    VectorEffectValueNonScalingStroke => "non-scaling-stroke"
    VectorEffectValueNonScalingSize => "non-scaling-size"
    VectorEffectValueNonRotation => "non-rotation"
    VectorEffectValueFixedPosition => "fixed-position"
  }
}

///|
pub(all) enum ViewTimelineAxisValue {
  ViewTimelineAxisValueBlock
  ViewTimelineAxisValueInline
  ViewTimelineAxisValueX
  ViewTimelineAxisValueY
} derive(Eq, Debug)

///|
pub extend ViewTimelineAxisValue with Eq::{equal, not_equal}

///|
pub extend ViewTimelineAxisValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn ViewTimelineAxisValue::to_css(self : ViewTimelineAxisValue) -> String {
  match self {
    ViewTimelineAxisValueBlock => "block"
    ViewTimelineAxisValueInline => "inline"
    ViewTimelineAxisValueX => "x"
    ViewTimelineAxisValueY => "y"
  }
}

///|
pub(all) enum WritingModeValue {
  WritingModeValueHorizontalTb
  WritingModeValueVerticalRl
  WritingModeValueVerticalLr
  WritingModeValueSidewaysRl
  WritingModeValueSidewaysLr
} derive(Eq, Debug)

///|
pub extend WritingModeValue with Eq::{equal, not_equal}

///|
pub extend WritingModeValue with @moonbitlang/core/debug.Debug::{to_repr}

///|
pub fn WritingModeValue::to_css(self : WritingModeValue) -> String {
  match self {
    WritingModeValueHorizontalTb => "horizontal-tb"
    WritingModeValueVerticalRl => "vertical-rl"
    WritingModeValueVerticalLr => "vertical-lr"
    WritingModeValueSidewaysRl => "sideways-rl"
    WritingModeValueSidewaysLr => "sideways-lr"
  }
}

///|
fn declaration(
  property : String,
  value : String,
  conditions : Array[@ir.Condition],
) -> @ir.Declaration {
  @ir.declaration(property, @ir.text(value), conditions~, keyframe_allowed=true)
}

///|
fn animation_declaration(
  property : String,
  value : @ir.AnimationName,
  conditions : Array[@ir.Condition],
) -> @ir.Declaration {
  @ir.declaration(property, @ir.animation(value), conditions~)
}

///|
fn fallback_declaration(
  property : String,
  values : Array[String],
  conditions : Array[@ir.Condition],
) -> @ir.Declaration {
  @ir.declaration(property, @ir.fallbacks(values), conditions~, keyframe_allowed=true)
}

///|
pub fn width(
  value : @values.Length,
  conditions? : Array[@ir.Condition] = [],
) -> LayoutDeclaration {
  layout_declaration(declaration("width", value.to_css(), conditions))
}

///|
pub fn width_fallbacks(
  values : Array[@values.Length],
  conditions? : Array[@ir.Condition] = [],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("width", values.map(value => value.to_css()), conditions))
}

///|
pub fn dynamic_width(
  variable : @values.CssVar[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(@ir.declaration("width", @ir.dynamic(variable.name(), "", category="length")))
}

///|
pub fn height(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("height", value.to_css(), []))
}

///|
pub fn height_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("height", values.map(value => value.to_css()), []))
}

///|
pub fn min_height(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("minHeight", value.to_css(), []))
}

///|
pub fn min_height_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("minHeight", values.map(value => value.to_css()), []))
}

///|
pub fn max_width(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("maxWidth", value.to_css(), []))
}

///|
pub fn max_width_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("maxWidth", values.map(value => value.to_css()), []))
}

///|
pub fn padding(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("padding", value.to_css(), []))
}

///|
pub fn padding_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("padding", values.map(value => value.to_css()), []))
}

///|
pub fn padding_block(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingBlock", value.to_css(), []))
}

///|
pub fn padding_block_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingBlock", values.map(value => value.to_css()), []))
}

///|
pub fn padding_inline(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingInline", value.to_css(), []))
}

///|
pub fn padding_inline_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingInline", values.map(value => value.to_css()), []))
}

///|
pub fn padding_inline_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingInlineStart", value.to_css(), []))
}

///|
pub fn padding_inline_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingInlineStart", values.map(value => value.to_css()), []))
}

///|
pub fn padding_inline_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingInlineEnd", value.to_css(), []))
}

///|
pub fn padding_inline_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingInlineEnd", values.map(value => value.to_css()), []))
}

///|
pub fn margin_top(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginTop", value.to_css(), []))
}

///|
pub fn margin_top_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginTop", values.map(value => value.to_css()), []))
}

///|
pub fn margin_bottom(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginBottom", value.to_css(), []))
}

///|
pub fn margin_bottom_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginBottom", values.map(value => value.to_css()), []))
}

///|
pub fn display(value : Display) -> LayoutDeclaration {
  layout_declaration(declaration("display", value.to_css(), []))
}

///|
pub fn display_fallbacks(
  values : Array[Display],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("display", values.map(value => value.to_css()), []))
}

///|
pub fn place_items(value : PlaceItems) -> LayoutDeclaration {
  layout_declaration(declaration("placeItems", value.to_css(), []))
}

///|
pub fn place_items_fallbacks(
  values : Array[PlaceItems],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("placeItems", values.map(value => value.to_css()), []))
}

///|
pub fn overflow(value : Overflow) -> LayoutDeclaration {
  layout_declaration(declaration("overflow", value.to_css(), []))
}

///|
pub fn overflow_fallbacks(
  values : Array[Overflow],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("overflow", values.map(value => value.to_css()), []))
}

///|
pub fn cursor(value : Cursor) -> InteractionDeclaration {
  interaction_declaration(declaration("cursor", value.to_css(), []))
}

///|
pub fn cursor_fallbacks(
  values : Array[Cursor],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("cursor", values.map(value => value.to_css()), []))
}

///|
pub fn color(
  value : @values.Color,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("color", value.to_css(), conditions))
}

///|
pub fn color_fallbacks(
  values : Array[@values.Color],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("color", values.map(value => value.to_css()), conditions))
}

///|
pub fn dynamic_color(
  variable : @values.CssVar[@values.Color],
) -> VisualDeclaration {
  visual_declaration(@ir.declaration("color", @ir.dynamic(variable.name(), "", category="color")))
}

///|
pub fn background_color(
  value : @values.Color,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("backgroundColor", value.to_css(), conditions))
}

///|
pub fn background_color_fallbacks(
  values : Array[@values.Color],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundColor", values.map(value => value.to_css()), conditions))
}

///|
pub fn dynamic_background_color(
  variable : @values.CssVar[@values.Color],
) -> VisualDeclaration {
  visual_declaration(@ir.declaration("backgroundColor", @ir.dynamic(variable.name(), "", category="color")))
}

///|
pub fn border_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderColor", value.to_css(), []))
}

///|
pub fn border_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_width(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderWidth", value.to_css(), []))
}

///|
pub fn border_width_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_radius(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderRadius", value.to_css(), []))
}

///|
pub fn border_radius_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_style(value : BorderStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderStyle", value.to_css(), []))
}

///|
pub fn border_style_fallbacks(
  values : Array[BorderStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_start_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineStartColor", value.to_css(), []))
}

///|
pub fn border_inline_start_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineStartColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_end_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineEndColor", value.to_css(), []))
}

///|
pub fn border_inline_end_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineEndColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_start_width(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineStartWidth", value.to_css(), []))
}

///|
pub fn border_inline_start_width_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineStartWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_end_width(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineEndWidth", value.to_css(), []))
}

///|
pub fn border_inline_end_width_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineEndWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_start_style(value : BorderStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineStartStyle", value.to_css(), []))
}

///|
pub fn border_inline_start_style_fallbacks(
  values : Array[BorderStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineStartStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_end_style(value : BorderStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineEndStyle", value.to_css(), []))
}

///|
pub fn border_inline_end_style_fallbacks(
  values : Array[BorderStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineEndStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_start_start_radius(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderStartStartRadius", value.to_css(), []))
}

///|
pub fn border_start_start_radius_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderStartStartRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_start_end_radius(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderStartEndRadius", value.to_css(), []))
}

///|
pub fn border_start_end_radius_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderStartEndRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_end_start_radius(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderEndStartRadius", value.to_css(), []))
}

///|
pub fn border_end_start_radius_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderEndStartRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_end_end_radius(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("borderEndEndRadius", value.to_css(), []))
}

///|
pub fn border_end_end_radius_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderEndEndRadius", values.map(value => value.to_css()), []))
}

///|
pub fn font_size(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("fontSize", value.to_css(), []))
}

///|
pub fn font_size_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontSize", values.map(value => value.to_css()), []))
}

///|
pub fn font_weight(value : Int) -> TypographyDeclaration {
  typography_declaration(declaration("fontWeight", value.to_string(), []))
}

///|
pub fn font_weight_fallbacks(
  values : Array[Int],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontWeight", values.map(value => value.to_string()), []))
}

///|
pub fn line_height(value : Double) -> TypographyDeclaration {
  typography_declaration(declaration("lineHeight", value.to_string(), []))
}

///|
pub fn line_height_fallbacks(
  values : Array[Double],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("lineHeight", values.map(value => value.to_string()), []))
}

///|
pub fn opacity(value : Double) -> VisualDeclaration {
  visual_declaration(declaration("opacity", value.to_string(), []))
}

///|
pub fn opacity_fallbacks(
  values : Array[Double],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("opacity", values.map(value => value.to_string()), []))
}

///|
pub fn appearance(value : String) -> InteractionDeclaration {
  interaction_declaration(declaration("appearance", value, []))
}

///|
pub fn appearance_fallbacks(
  values : Array[String],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("appearance", values.map(value => value), []))
}

///|
pub fn font_family(value : String) -> TypographyDeclaration {
  typography_declaration(declaration("fontFamily", value, []))
}

///|
pub fn font_family_fallbacks(
  values : Array[String],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontFamily", values.map(value => value), []))
}

///|
pub fn box_shadow(value : @values.BoxShadowList) -> VisualDeclaration {
  visual_declaration(declaration("boxShadow", value.to_css(), []))
}

///|
pub fn box_shadow_fallbacks(
  values : Array[@values.BoxShadowList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("boxShadow", values.map(value => value.to_css()), []))
}

///|
pub fn filter(value : @values.FilterList) -> VisualDeclaration {
  visual_declaration(declaration("filter", value.to_css(), []))
}

///|
pub fn filter_fallbacks(
  values : Array[@values.FilterList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("filter", values.map(value => value.to_css()), []))
}

///|
pub fn backdrop_filter(value : @values.FilterList) -> VisualDeclaration {
  visual_declaration(declaration("backdropFilter", value.to_css(), []))
}

///|
pub fn backdrop_filter_fallbacks(
  values : Array[@values.FilterList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backdropFilter", values.map(value => value.to_css()), []))
}

///|
pub fn text_shadow(value : @values.TextShadowList) -> TypographyDeclaration {
  typography_declaration(declaration("textShadow", value.to_css(), []))
}

///|
pub fn text_shadow_fallbacks(
  values : Array[@values.TextShadowList],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textShadow", values.map(value => value.to_css()), []))
}

///|
pub fn grid_template_areas(value : @values.GridTemplateAreas) -> LayoutDeclaration {
  layout_declaration(declaration("gridTemplateAreas", value.to_css(), []))
}

///|
pub fn grid_template_areas_fallbacks(
  values : Array[@values.GridTemplateAreas],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridTemplateAreas", values.map(value => value.to_css()), []))
}

///|
pub fn container_name(value : @values.ContainerNames) -> LayoutDeclaration {
  layout_declaration(declaration("containerName", value.to_css(), []))
}

///|
pub fn container_name_fallbacks(
  values : Array[@values.ContainerNames],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containerName", values.map(value => value.to_css()), []))
}

///|
pub fn mask_image(value : @values.MaskImageList) -> VisualDeclaration {
  visual_declaration(declaration("maskImage", value.to_css(), []))
}

///|
pub fn mask_image_fallbacks(
  values : Array[@values.MaskImageList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskImage", values.map(value => value.to_css()), []))
}

///|
pub fn mask_position(value : @values.PositionList) -> VisualDeclaration {
  visual_declaration(declaration("maskPosition", value.to_css(), []))
}

///|
pub fn mask_position_fallbacks(
  values : Array[@values.PositionList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskPosition", values.map(value => value.to_css()), []))
}

///|
pub fn mask_repeat(value : @values.RepeatStyleList) -> VisualDeclaration {
  visual_declaration(declaration("maskRepeat", value.to_css(), []))
}

///|
pub fn mask_repeat_fallbacks(
  values : Array[@values.RepeatStyleList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskRepeat", values.map(value => value.to_css()), []))
}

///|
pub fn mask_size(value : @values.BackgroundSizeList) -> VisualDeclaration {
  visual_declaration(declaration("maskSize", value.to_css(), []))
}

///|
pub fn mask_size_fallbacks(
  values : Array[@values.BackgroundSizeList],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskSize", values.map(value => value.to_css()), []))
}

///|
pub fn clip_path(value : @values.ClipPath) -> VisualDeclaration {
  visual_declaration(declaration("clipPath", value.to_css(), []))
}

///|
pub fn clip_path_fallbacks(
  values : Array[@values.ClipPath],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("clipPath", values.map(value => value.to_css()), []))
}

///|
pub fn content(value : @values.ContentValue) -> TypographyDeclaration {
  typography_declaration(declaration("content", value.to_css(), []))
}

///|
pub fn content_fallbacks(
  values : Array[@values.ContentValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("content", values.map(value => value.to_css()), []))
}

///|
pub fn anchor_name(value : @values.AnchorNames) -> LayoutDeclaration {
  layout_declaration(declaration("anchorName", value.to_css(), []))
}

///|
pub fn anchor_name_fallbacks(
  values : Array[@values.AnchorNames],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("anchorName", values.map(value => value.to_css()), []))
}

///|
pub fn position_anchor(value : @values.PositionAnchor) -> LayoutDeclaration {
  layout_declaration(declaration("positionAnchor", value.to_css(), []))
}

///|
pub fn position_anchor_fallbacks(
  values : Array[@values.PositionAnchor],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("positionAnchor", values.map(value => value.to_css()), []))
}

///|
pub fn position_area(value : @values.PositionArea) -> LayoutDeclaration {
  layout_declaration(declaration("positionArea", value.to_css(), []))
}

///|
pub fn position_area_fallbacks(
  values : Array[@values.PositionArea],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("positionArea", values.map(value => value.to_css()), []))
}

///|
pub fn position_try(value : @values.PositionTryValue) -> LayoutDeclaration {
  layout_declaration(declaration("positionTry", value.to_css(), []))
}

///|
pub fn position_try_fallbacks(value : @values.PositionTryFallbacks) -> LayoutDeclaration {
  layout_declaration(declaration("positionTryFallbacks", value.to_css(), []))
}

///|
pub fn position_try_fallbacks_fallbacks(
  values : Array[@values.PositionTryFallbacks],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("positionTryFallbacks", values.map(value => value.to_css()), []))
}

///|
pub fn position_try_order(value : @values.PositionTryOrder) -> LayoutDeclaration {
  layout_declaration(declaration("positionTryOrder", value.to_css(), []))
}

///|
pub fn position_try_order_fallbacks(
  values : Array[@values.PositionTryOrder],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("positionTryOrder", values.map(value => value.to_css()), []))
}

///|
pub fn view_transition_name(value : @values.ViewTransitionName) -> MotionDeclaration {
  motion_declaration(declaration("viewTransitionName", value.to_css(), []))
}

///|
pub fn view_transition_name_fallbacks(
  values : Array[@values.ViewTransitionName],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("viewTransitionName", values.map(value => value.to_css()), []))
}

///|
pub fn view_transition_class(value : @values.ViewTransitionClass) -> MotionDeclaration {
  motion_declaration(declaration("viewTransitionClass", value.to_css(), []))
}

///|
pub fn view_transition_class_fallbacks(
  values : Array[@values.ViewTransitionClass],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("viewTransitionClass", values.map(value => value.to_css()), []))
}

///|
pub fn transition(value : String) -> MotionDeclaration {
  motion_declaration(declaration("transition", value, []))
}

///|
pub fn transition_fallbacks(
  values : Array[String],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transition", values.map(value => value), []))
}

///|
pub fn animation_name(
  value : @ir.AnimationName,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(animation_declaration("animationName", value, conditions))
}

///|
pub fn animation_duration(value : @values.Time) -> MotionDeclaration {
  motion_declaration(declaration("animationDuration", value.to_css(), []))
}

///|
pub fn animation_duration_fallbacks(
  values : Array[@values.Time],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationDuration", values.map(value => value.to_css()), []))
}

///|
pub fn min_width(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("minWidth", value.to_css(), []))
}

///|
pub fn min_width_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("minWidth", values.map(value => value.to_css()), []))
}

///|
pub fn max_height(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("maxHeight", value.to_css(), []))
}

///|
pub fn max_height_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("maxHeight", values.map(value => value.to_css()), []))
}

///|
pub fn padding_top(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingTop", value.to_css(), []))
}

///|
pub fn padding_top_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingTop", values.map(value => value.to_css()), []))
}

///|
pub fn padding_right(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingRight", value.to_css(), []))
}

///|
pub fn padding_right_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingRight", values.map(value => value.to_css()), []))
}

///|
pub fn padding_bottom(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingBottom", value.to_css(), []))
}

///|
pub fn padding_bottom_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingBottom", values.map(value => value.to_css()), []))
}

///|
pub fn padding_left(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingLeft", value.to_css(), []))
}

///|
pub fn padding_left_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingLeft", values.map(value => value.to_css()), []))
}

///|
pub fn margin(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("margin", value.to_css(), []))
}

///|
pub fn margin_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("margin", values.map(value => value.to_css()), []))
}

///|
pub fn margin_left(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginLeft", value.to_css(), []))
}

///|
pub fn margin_left_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginLeft", values.map(value => value.to_css()), []))
}

///|
pub fn margin_right(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginRight", value.to_css(), []))
}

///|
pub fn margin_right_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginRight", values.map(value => value.to_css()), []))
}

///|
pub fn margin_block(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginBlock", value.to_css(), []))
}

///|
pub fn margin_block_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginBlock", values.map(value => value.to_css()), []))
}

///|
pub fn margin_inline(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginInline", value.to_css(), []))
}

///|
pub fn margin_inline_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginInline", values.map(value => value.to_css()), []))
}

///|
pub fn margin_inline_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginInlineStart", value.to_css(), []))
}

///|
pub fn margin_inline_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginInlineStart", values.map(value => value.to_css()), []))
}

///|
pub fn margin_inline_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginInlineEnd", value.to_css(), []))
}

///|
pub fn margin_inline_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginInlineEnd", values.map(value => value.to_css()), []))
}

///|
pub fn gap(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("gap", value.to_css(), []))
}

///|
pub fn gap_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gap", values.map(value => value.to_css()), []))
}

///|
pub fn row_gap(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("rowGap", value.to_css(), []))
}

///|
pub fn row_gap_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("rowGap", values.map(value => value.to_css()), []))
}

///|
pub fn column_gap(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("columnGap", value.to_css(), []))
}

///|
pub fn column_gap_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("columnGap", values.map(value => value.to_css()), []))
}

///|
pub fn top(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("top", value.to_css(), []))
}

///|
pub fn top_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("top", values.map(value => value.to_css()), []))
}

///|
pub fn right(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("right", value.to_css(), []))
}

///|
pub fn right_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("right", values.map(value => value.to_css()), []))
}

///|
pub fn bottom(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("bottom", value.to_css(), []))
}

///|
pub fn bottom_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("bottom", values.map(value => value.to_css()), []))
}

///|
pub fn left(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("left", value.to_css(), []))
}

///|
pub fn left_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("left", values.map(value => value.to_css()), []))
}

///|
pub fn letter_spacing(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("letterSpacing", value.to_css(), []))
}

///|
pub fn letter_spacing_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("letterSpacing", values.map(value => value.to_css()), []))
}

///|
pub fn word_spacing(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("wordSpacing", value.to_css(), []))
}

///|
pub fn word_spacing_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("wordSpacing", values.map(value => value.to_css()), []))
}

///|
pub fn text_indent(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("textIndent", value.to_css(), []))
}

///|
pub fn text_indent_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textIndent", values.map(value => value.to_css()), []))
}

///|
pub fn outline_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("outlineColor", value.to_css(), []))
}

///|
pub fn outline_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("outlineColor", values.map(value => value.to_css()), []))
}

///|
pub fn outline_width(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("outlineWidth", value.to_css(), []))
}

///|
pub fn outline_width_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("outlineWidth", values.map(value => value.to_css()), []))
}

///|
pub fn outline_style(value : BorderStyle) -> VisualDeclaration {
  visual_declaration(declaration("outlineStyle", value.to_css(), []))
}

///|
pub fn outline_style_fallbacks(
  values : Array[BorderStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("outlineStyle", values.map(value => value.to_css()), []))
}

///|
pub fn flex_basis(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("flexBasis", value.to_css(), []))
}

///|
pub fn flex_basis_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("flexBasis", values.map(value => value.to_css()), []))
}

///|
pub fn z_index(value : @values.Integer) -> LayoutDeclaration {
  layout_declaration(declaration("zIndex", value.to_css(), []))
}

///|
pub fn z_index_fallbacks(
  values : Array[@values.Integer],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("zIndex", values.map(value => value.to_css()), []))
}

///|
pub fn order(value : @values.Integer) -> LayoutDeclaration {
  layout_declaration(declaration("order", value.to_css(), []))
}

///|
pub fn order_fallbacks(
  values : Array[@values.Integer],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("order", values.map(value => value.to_css()), []))
}

///|
pub fn flex_grow(value : @values.Number) -> LayoutDeclaration {
  layout_declaration(declaration("flexGrow", value.to_css(), []))
}

///|
pub fn flex_grow_fallbacks(
  values : Array[@values.Number],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("flexGrow", values.map(value => value.to_css()), []))
}

///|
pub fn rotate(value : @values.Angle) -> MotionDeclaration {
  motion_declaration(declaration("rotate", value.to_css(), []))
}

///|
pub fn rotate_fallbacks(
  values : Array[@values.Angle],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("rotate", values.map(value => value.to_css()), []))
}

///|
pub fn transition_delay(value : @values.Time) -> MotionDeclaration {
  motion_declaration(declaration("transitionDelay", value.to_css(), []))
}

///|
pub fn transition_delay_fallbacks(
  values : Array[@values.Time],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transitionDelay", values.map(value => value.to_css()), []))
}

///|
pub fn background_image(
  value : @values.Url,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("backgroundImage", value.to_css(), conditions))
}

///|
pub fn background_image_fallbacks(
  values : Array[@values.Url],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundImage", values.map(value => value.to_css()), conditions))
}

///|
pub fn position(value : PositionMode) -> LayoutDeclaration {
  layout_declaration(declaration("position", value.to_css(), []))
}

///|
pub fn position_fallbacks(
  values : Array[PositionMode],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("position", values.map(value => value.to_css()), []))
}

///|
pub fn box_sizing(value : BoxSizing) -> LayoutDeclaration {
  layout_declaration(declaration("boxSizing", value.to_css(), []))
}

///|
pub fn box_sizing_fallbacks(
  values : Array[BoxSizing],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("boxSizing", values.map(value => value.to_css()), []))
}

///|
pub fn visibility(value : Visibility) -> LayoutDeclaration {
  layout_declaration(declaration("visibility", value.to_css(), []))
}

///|
pub fn visibility_fallbacks(
  values : Array[Visibility],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("visibility", values.map(value => value.to_css()), []))
}

///|
pub fn overflow_x(value : Overflow) -> LayoutDeclaration {
  layout_declaration(declaration("overflowX", value.to_css(), []))
}

///|
pub fn overflow_x_fallbacks(
  values : Array[Overflow],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("overflowX", values.map(value => value.to_css()), []))
}

///|
pub fn overflow_y(value : Overflow) -> LayoutDeclaration {
  layout_declaration(declaration("overflowY", value.to_css(), []))
}

///|
pub fn overflow_y_fallbacks(
  values : Array[Overflow],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("overflowY", values.map(value => value.to_css()), []))
}

///|
pub fn overflow_block(value : Overflow) -> LayoutDeclaration {
  layout_declaration(declaration("overflowBlock", value.to_css(), []))
}

///|
pub fn overflow_block_fallbacks(
  values : Array[Overflow],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("overflowBlock", values.map(value => value.to_css()), []))
}

///|
pub fn overflow_inline(value : Overflow) -> LayoutDeclaration {
  layout_declaration(declaration("overflowInline", value.to_css(), []))
}

///|
pub fn overflow_inline_fallbacks(
  values : Array[Overflow],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("overflowInline", values.map(value => value.to_css()), []))
}

///|
pub fn flex_direction(value : FlexDirection) -> LayoutDeclaration {
  layout_declaration(declaration("flexDirection", value.to_css(), []))
}

///|
pub fn flex_direction_fallbacks(
  values : Array[FlexDirection],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("flexDirection", values.map(value => value.to_css()), []))
}

///|
pub fn flex_wrap(value : FlexWrap) -> LayoutDeclaration {
  layout_declaration(declaration("flexWrap", value.to_css(), []))
}

///|
pub fn flex_wrap_fallbacks(
  values : Array[FlexWrap],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("flexWrap", values.map(value => value.to_css()), []))
}

///|
pub fn flex_shrink(value : @values.Number) -> LayoutDeclaration {
  layout_declaration(declaration("flexShrink", value.to_css(), []))
}

///|
pub fn flex_shrink_fallbacks(
  values : Array[@values.Number],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("flexShrink", values.map(value => value.to_css()), []))
}

///|
pub fn align_content(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("alignContent", value.to_css(), []))
}

///|
pub fn align_content_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("alignContent", values.map(value => value.to_css()), []))
}

///|
pub fn align_items(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("alignItems", value.to_css(), []))
}

///|
pub fn align_items_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("alignItems", values.map(value => value.to_css()), []))
}

///|
pub fn align_self(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("alignSelf", value.to_css(), []))
}

///|
pub fn align_self_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("alignSelf", values.map(value => value.to_css()), []))
}

///|
pub fn justify_content(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("justifyContent", value.to_css(), []))
}

///|
pub fn justify_content_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("justifyContent", values.map(value => value.to_css()), []))
}

///|
pub fn justify_items(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("justifyItems", value.to_css(), []))
}

///|
pub fn justify_items_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("justifyItems", values.map(value => value.to_css()), []))
}

///|
pub fn justify_self(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("justifySelf", value.to_css(), []))
}

///|
pub fn justify_self_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("justifySelf", values.map(value => value.to_css()), []))
}

///|
pub fn place_content(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("placeContent", value.to_css(), []))
}

///|
pub fn place_content_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("placeContent", values.map(value => value.to_css()), []))
}

///|
pub fn place_self(value : Alignment) -> LayoutDeclaration {
  layout_declaration(declaration("placeSelf", value.to_css(), []))
}

///|
pub fn place_self_fallbacks(
  values : Array[Alignment],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("placeSelf", values.map(value => value.to_css()), []))
}

///|
pub fn aspect_ratio(value : @values.Ratio) -> LayoutDeclaration {
  layout_declaration(declaration("aspectRatio", value.to_css(), []))
}

///|
pub fn aspect_ratio_fallbacks(
  values : Array[@values.Ratio],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("aspectRatio", values.map(value => value.to_css()), []))
}

///|
pub fn object_fit(value : ObjectFit) -> LayoutDeclaration {
  layout_declaration(declaration("objectFit", value.to_css(), []))
}

///|
pub fn object_fit_fallbacks(
  values : Array[ObjectFit],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("objectFit", values.map(value => value.to_css()), []))
}

///|
pub fn float(value : FloatMode) -> LayoutDeclaration {
  layout_declaration(declaration("float", value.to_css(), []))
}

///|
pub fn float_fallbacks(
  values : Array[FloatMode],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("float", values.map(value => value.to_css()), []))
}

///|
pub fn clear(value : ClearMode) -> LayoutDeclaration {
  layout_declaration(declaration("clear", value.to_css(), []))
}

///|
pub fn clear_fallbacks(
  values : Array[ClearMode],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("clear", values.map(value => value.to_css()), []))
}

///|
pub fn resize(value : ResizeMode) -> LayoutDeclaration {
  layout_declaration(declaration("resize", value.to_css(), []))
}

///|
pub fn resize_fallbacks(
  values : Array[ResizeMode],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("resize", values.map(value => value.to_css()), []))
}

///|
pub fn contain(value : @values.Contain) -> LayoutDeclaration {
  layout_declaration(declaration("contain", value.to_css(), []))
}

///|
pub fn contain_fallbacks(
  values : Array[@values.Contain],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("contain", values.map(value => value.to_css()), []))
}

///|
pub fn inset(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("inset", value.to_css(), []))
}

///|
pub fn inset_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("inset", values.map(value => value.to_css()), []))
}

///|
pub fn inset_block(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("insetBlock", value.to_css(), []))
}

///|
pub fn inset_block_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("insetBlock", values.map(value => value.to_css()), []))
}

///|
pub fn inset_inline(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("insetInline", value.to_css(), []))
}

///|
pub fn inset_inline_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("insetInline", values.map(value => value.to_css()), []))
}

///|
pub fn inset_block_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("insetBlockStart", value.to_css(), []))
}

///|
pub fn inset_block_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("insetBlockStart", values.map(value => value.to_css()), []))
}

///|
pub fn inset_block_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("insetBlockEnd", value.to_css(), []))
}

///|
pub fn inset_block_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("insetBlockEnd", values.map(value => value.to_css()), []))
}

///|
pub fn inset_inline_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("insetInlineStart", value.to_css(), []))
}

///|
pub fn inset_inline_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("insetInlineStart", values.map(value => value.to_css()), []))
}

///|
pub fn inset_inline_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("insetInlineEnd", value.to_css(), []))
}

///|
pub fn inset_inline_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("insetInlineEnd", values.map(value => value.to_css()), []))
}

///|
pub fn grid_auto_flow(value : GridAutoFlow) -> LayoutDeclaration {
  layout_declaration(declaration("gridAutoFlow", value.to_css(), []))
}

///|
pub fn grid_auto_flow_fallbacks(
  values : Array[GridAutoFlow],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridAutoFlow", values.map(value => value.to_css()), []))
}

///|
pub fn grid_template_columns(value : @values.GridTrackList) -> LayoutDeclaration {
  layout_declaration(declaration("gridTemplateColumns", value.to_css(), []))
}

///|
pub fn grid_template_columns_fallbacks(
  values : Array[@values.GridTrackList],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridTemplateColumns", values.map(value => value.to_css()), []))
}

///|
pub fn grid_template_rows(value : @values.GridTrackList) -> LayoutDeclaration {
  layout_declaration(declaration("gridTemplateRows", value.to_css(), []))
}

///|
pub fn grid_template_rows_fallbacks(
  values : Array[@values.GridTrackList],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridTemplateRows", values.map(value => value.to_css()), []))
}

///|
pub fn grid_auto_columns(value : @values.GridTrackList) -> LayoutDeclaration {
  layout_declaration(declaration("gridAutoColumns", value.to_css(), []))
}

///|
pub fn grid_auto_columns_fallbacks(
  values : Array[@values.GridTrackList],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridAutoColumns", values.map(value => value.to_css()), []))
}

///|
pub fn grid_auto_rows(value : @values.GridTrackList) -> LayoutDeclaration {
  layout_declaration(declaration("gridAutoRows", value.to_css(), []))
}

///|
pub fn grid_auto_rows_fallbacks(
  values : Array[@values.GridTrackList],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridAutoRows", values.map(value => value.to_css()), []))
}

///|
pub fn grid_column_start(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridColumnStart", value.to_css(), []))
}

///|
pub fn grid_column_start_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridColumnStart", values.map(value => value.to_css()), []))
}

///|
pub fn grid_column_end(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridColumnEnd", value.to_css(), []))
}

///|
pub fn grid_column_end_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridColumnEnd", values.map(value => value.to_css()), []))
}

///|
pub fn grid_row_start(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridRowStart", value.to_css(), []))
}

///|
pub fn grid_row_start_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridRowStart", values.map(value => value.to_css()), []))
}

///|
pub fn grid_row_end(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridRowEnd", value.to_css(), []))
}

///|
pub fn grid_row_end_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridRowEnd", values.map(value => value.to_css()), []))
}

///|
pub fn grid_column(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridColumn", value.to_css(), []))
}

///|
pub fn grid_column_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridColumn", values.map(value => value.to_css()), []))
}

///|
pub fn grid_row(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridRow", value.to_css(), []))
}

///|
pub fn grid_row_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridRow", values.map(value => value.to_css()), []))
}

///|
pub fn grid_area(value : @values.GridLine) -> LayoutDeclaration {
  layout_declaration(declaration("gridArea", value.to_css(), []))
}

///|
pub fn grid_area_fallbacks(
  values : Array[@values.GridLine],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("gridArea", values.map(value => value.to_css()), []))
}

///|
pub fn text_align(value : TextAlign) -> TypographyDeclaration {
  typography_declaration(declaration("textAlign", value.to_css(), []))
}

///|
pub fn text_align_fallbacks(
  values : Array[TextAlign],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textAlign", values.map(value => value.to_css()), []))
}

///|
pub fn text_align_last(value : TextAlign) -> TypographyDeclaration {
  typography_declaration(declaration("textAlignLast", value.to_css(), []))
}

///|
pub fn text_align_last_fallbacks(
  values : Array[TextAlign],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textAlignLast", values.map(value => value.to_css()), []))
}

///|
pub fn text_transform(value : TextTransform) -> TypographyDeclaration {
  typography_declaration(declaration("textTransform", value.to_css(), []))
}

///|
pub fn text_transform_fallbacks(
  values : Array[TextTransform],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textTransform", values.map(value => value.to_css()), []))
}

///|
pub fn text_decoration_line(value : TextDecorationLine) -> TypographyDeclaration {
  typography_declaration(declaration("textDecorationLine", value.to_css(), []))
}

///|
pub fn text_decoration_line_fallbacks(
  values : Array[TextDecorationLine],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textDecorationLine", values.map(value => value.to_css()), []))
}

///|
pub fn text_decoration_style(value : TextDecorationStyle) -> TypographyDeclaration {
  typography_declaration(declaration("textDecorationStyle", value.to_css(), []))
}

///|
pub fn text_decoration_style_fallbacks(
  values : Array[TextDecorationStyle],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textDecorationStyle", values.map(value => value.to_css()), []))
}

///|
pub fn text_decoration_color(value : @values.Color) -> TypographyDeclaration {
  typography_declaration(declaration("textDecorationColor", value.to_css(), []))
}

///|
pub fn text_decoration_color_fallbacks(
  values : Array[@values.Color],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textDecorationColor", values.map(value => value.to_css()), []))
}

///|
pub fn text_decoration_thickness(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("textDecorationThickness", value.to_css(), []))
}

///|
pub fn text_decoration_thickness_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textDecorationThickness", values.map(value => value.to_css()), []))
}

///|
pub fn text_underline_offset(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("textUnderlineOffset", value.to_css(), []))
}

///|
pub fn text_underline_offset_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textUnderlineOffset", values.map(value => value.to_css()), []))
}

///|
pub fn tab_size(value : @values.Length) -> TypographyDeclaration {
  typography_declaration(declaration("tabSize", value.to_css(), []))
}

///|
pub fn tab_size_fallbacks(
  values : Array[@values.Length],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("tabSize", values.map(value => value.to_css()), []))
}

///|
pub fn text_underline_position(value : TextUnderlinePosition) -> TypographyDeclaration {
  typography_declaration(declaration("textUnderlinePosition", value.to_css(), []))
}

///|
pub fn text_underline_position_fallbacks(
  values : Array[TextUnderlinePosition],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textUnderlinePosition", values.map(value => value.to_css()), []))
}

///|
pub fn overflow_wrap(value : OverflowWrap) -> TypographyDeclaration {
  typography_declaration(declaration("overflowWrap", value.to_css(), []))
}

///|
pub fn overflow_wrap_fallbacks(
  values : Array[OverflowWrap],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("overflowWrap", values.map(value => value.to_css()), []))
}

///|
pub fn word_break(value : WordBreak) -> TypographyDeclaration {
  typography_declaration(declaration("wordBreak", value.to_css(), []))
}

///|
pub fn word_break_fallbacks(
  values : Array[WordBreak],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("wordBreak", values.map(value => value.to_css()), []))
}

///|
pub fn hyphens(value : Hyphens) -> TypographyDeclaration {
  typography_declaration(declaration("hyphens", value.to_css(), []))
}

///|
pub fn hyphens_fallbacks(
  values : Array[Hyphens],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("hyphens", values.map(value => value.to_css()), []))
}

///|
pub fn text_overflow(value : TextOverflow) -> TypographyDeclaration {
  typography_declaration(declaration("textOverflow", value.to_css(), []))
}

///|
pub fn text_overflow_fallbacks(
  values : Array[TextOverflow],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textOverflow", values.map(value => value.to_css()), []))
}

///|
pub fn white_space_collapse(value : WhiteSpaceCollapse) -> TypographyDeclaration {
  typography_declaration(declaration("whiteSpaceCollapse", value.to_css(), []))
}

///|
pub fn white_space_collapse_fallbacks(
  values : Array[WhiteSpaceCollapse],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("whiteSpaceCollapse", values.map(value => value.to_css()), []))
}

///|
pub fn text_wrap_mode(value : TextWrapMode) -> TypographyDeclaration {
  typography_declaration(declaration("textWrapMode", value.to_css(), []))
}

///|
pub fn text_wrap_mode_fallbacks(
  values : Array[TextWrapMode],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textWrapMode", values.map(value => value.to_css()), []))
}

///|
pub fn text_wrap_style(value : TextWrapStyle) -> TypographyDeclaration {
  typography_declaration(declaration("textWrapStyle", value.to_css(), []))
}

///|
pub fn text_wrap_style_fallbacks(
  values : Array[TextWrapStyle],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textWrapStyle", values.map(value => value.to_css()), []))
}

///|
pub fn font_style(value : FontStyle) -> TypographyDeclaration {
  typography_declaration(declaration("fontStyle", value.to_css(), []))
}

///|
pub fn font_style_fallbacks(
  values : Array[FontStyle],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontStyle", values.map(value => value.to_css()), []))
}

///|
pub fn font_stretch(value : FontStretch) -> TypographyDeclaration {
  typography_declaration(declaration("fontStretch", value.to_css(), []))
}

///|
pub fn font_stretch_fallbacks(
  values : Array[FontStretch],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontStretch", values.map(value => value.to_css()), []))
}

///|
pub fn font_kerning(value : FontKerning) -> TypographyDeclaration {
  typography_declaration(declaration("fontKerning", value.to_css(), []))
}

///|
pub fn font_kerning_fallbacks(
  values : Array[FontKerning],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontKerning", values.map(value => value.to_css()), []))
}

///|
pub fn font_optical_sizing(value : FontOpticalSizing) -> TypographyDeclaration {
  typography_declaration(declaration("fontOpticalSizing", value.to_css(), []))
}

///|
pub fn font_optical_sizing_fallbacks(
  values : Array[FontOpticalSizing],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontOpticalSizing", values.map(value => value.to_css()), []))
}

///|
pub fn font_variant_caps(value : FontVariantCaps) -> TypographyDeclaration {
  typography_declaration(declaration("fontVariantCaps", value.to_css(), []))
}

///|
pub fn font_variant_caps_fallbacks(
  values : Array[FontVariantCaps],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontVariantCaps", values.map(value => value.to_css()), []))
}

///|
pub fn font_variant_numeric(value : @values.FontVariantNumeric) -> TypographyDeclaration {
  typography_declaration(declaration("fontVariantNumeric", value.to_css(), []))
}

///|
pub fn font_variant_numeric_fallbacks(
  values : Array[@values.FontVariantNumeric],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontVariantNumeric", values.map(value => value.to_css()), []))
}

///|
pub fn list_style_position(value : ListStylePosition) -> TypographyDeclaration {
  typography_declaration(declaration("listStylePosition", value.to_css(), []))
}

///|
pub fn list_style_position_fallbacks(
  values : Array[ListStylePosition],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("listStylePosition", values.map(value => value.to_css()), []))
}

///|
pub fn background_attachment(value : BackgroundAttachment) -> VisualDeclaration {
  visual_declaration(declaration("backgroundAttachment", value.to_css(), []))
}

///|
pub fn background_attachment_fallbacks(
  values : Array[BackgroundAttachment],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundAttachment", values.map(value => value.to_css()), []))
}

///|
pub fn background_clip(value : BackgroundBox) -> VisualDeclaration {
  visual_declaration(declaration("backgroundClip", value.to_css(), []))
}

///|
pub fn background_clip_fallbacks(
  values : Array[BackgroundBox],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundClip", values.map(value => value.to_css()), []))
}

///|
pub fn background_origin(value : BackgroundBox) -> VisualDeclaration {
  visual_declaration(declaration("backgroundOrigin", value.to_css(), []))
}

///|
pub fn background_origin_fallbacks(
  values : Array[BackgroundBox],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundOrigin", values.map(value => value.to_css()), []))
}

///|
pub fn background_repeat(value : @values.RepeatStyle) -> VisualDeclaration {
  visual_declaration(declaration("backgroundRepeat", value.to_css(), []))
}

///|
pub fn background_repeat_fallbacks(
  values : Array[@values.RepeatStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundRepeat", values.map(value => value.to_css()), []))
}

///|
pub fn background_position_x(value : @values.Position) -> VisualDeclaration {
  visual_declaration(declaration("backgroundPositionX", value.to_css(), []))
}

///|
pub fn background_position_x_fallbacks(
  values : Array[@values.Position],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundPositionX", values.map(value => value.to_css()), []))
}

///|
pub fn background_position_y(value : @values.Position) -> VisualDeclaration {
  visual_declaration(declaration("backgroundPositionY", value.to_css(), []))
}

///|
pub fn background_position_y_fallbacks(
  values : Array[@values.Position],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundPositionY", values.map(value => value.to_css()), []))
}

///|
pub fn object_position(value : @values.Position) -> VisualDeclaration {
  visual_declaration(declaration("objectPosition", value.to_css(), []))
}

///|
pub fn object_position_fallbacks(
  values : Array[@values.Position],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("objectPosition", values.map(value => value.to_css()), []))
}

///|
pub fn background_size(value : @values.BackgroundSize) -> VisualDeclaration {
  visual_declaration(declaration("backgroundSize", value.to_css(), []))
}

///|
pub fn background_size_fallbacks(
  values : Array[@values.BackgroundSize],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundSize", values.map(value => value.to_css()), []))
}

///|
pub fn mix_blend_mode(value : BlendMode) -> VisualDeclaration {
  visual_declaration(declaration("mixBlendMode", value.to_css(), []))
}

///|
pub fn mix_blend_mode_fallbacks(
  values : Array[BlendMode],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("mixBlendMode", values.map(value => value.to_css()), []))
}

///|
pub fn background_blend_mode(value : BlendMode) -> VisualDeclaration {
  visual_declaration(declaration("backgroundBlendMode", value.to_css(), []))
}

///|
pub fn background_blend_mode_fallbacks(
  values : Array[BlendMode],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("backgroundBlendMode", values.map(value => value.to_css()), []))
}

///|
pub fn image_rendering(value : ImageRendering) -> VisualDeclaration {
  visual_declaration(declaration("imageRendering", value.to_css(), []))
}

///|
pub fn image_rendering_fallbacks(
  values : Array[ImageRendering],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("imageRendering", values.map(value => value.to_css()), []))
}

///|
pub fn transform(value : @values.TransformList) -> MotionDeclaration {
  motion_declaration(declaration("transform", value.to_css(), []))
}

///|
pub fn transform_fallbacks(
  values : Array[@values.TransformList],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transform", values.map(value => value.to_css()), []))
}

///|
pub fn transform_origin(value : @values.TransformOrigin) -> MotionDeclaration {
  motion_declaration(declaration("transformOrigin", value.to_css(), []))
}

///|
pub fn transform_origin_fallbacks(
  values : Array[@values.TransformOrigin],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transformOrigin", values.map(value => value.to_css()), []))
}

///|
pub fn perspective_origin(value : @values.TransformOrigin) -> MotionDeclaration {
  motion_declaration(declaration("perspectiveOrigin", value.to_css(), []))
}

///|
pub fn perspective_origin_fallbacks(
  values : Array[@values.TransformOrigin],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("perspectiveOrigin", values.map(value => value.to_css()), []))
}

///|
pub fn translate(value : @values.Length) -> MotionDeclaration {
  motion_declaration(declaration("translate", value.to_css(), []))
}

///|
pub fn translate_fallbacks(
  values : Array[@values.Length],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("translate", values.map(value => value.to_css()), []))
}

///|
pub fn perspective(value : @values.Length) -> MotionDeclaration {
  motion_declaration(declaration("perspective", value.to_css(), []))
}

///|
pub fn perspective_fallbacks(
  values : Array[@values.Length],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("perspective", values.map(value => value.to_css()), []))
}

///|
pub fn scale(value : @values.Number) -> MotionDeclaration {
  motion_declaration(declaration("scale", value.to_css(), []))
}

///|
pub fn scale_fallbacks(
  values : Array[@values.Number],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("scale", values.map(value => value.to_css()), []))
}

///|
pub fn animation_iteration_count(value : @values.AnimationIterations) -> MotionDeclaration {
  motion_declaration(declaration("animationIterationCount", value.to_css(), []))
}

///|
pub fn animation_iteration_count_fallbacks(
  values : Array[@values.AnimationIterations],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationIterationCount", values.map(value => value.to_css()), []))
}

///|
pub fn backface_visibility(value : BackfaceVisibility) -> MotionDeclaration {
  motion_declaration(declaration("backfaceVisibility", value.to_css(), []))
}

///|
pub fn backface_visibility_fallbacks(
  values : Array[BackfaceVisibility],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("backfaceVisibility", values.map(value => value.to_css()), []))
}

///|
pub fn transform_style(value : TransformStyle) -> MotionDeclaration {
  motion_declaration(declaration("transformStyle", value.to_css(), []))
}

///|
pub fn transform_style_fallbacks(
  values : Array[TransformStyle],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transformStyle", values.map(value => value.to_css()), []))
}

///|
pub fn animation_delay(value : @values.Time) -> MotionDeclaration {
  motion_declaration(declaration("animationDelay", value.to_css(), []))
}

///|
pub fn animation_delay_fallbacks(
  values : Array[@values.Time],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationDelay", values.map(value => value.to_css()), []))
}

///|
pub fn animation_direction(value : AnimationDirection) -> MotionDeclaration {
  motion_declaration(declaration("animationDirection", value.to_css(), []))
}

///|
pub fn animation_direction_fallbacks(
  values : Array[AnimationDirection],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationDirection", values.map(value => value.to_css()), []))
}

///|
pub fn animation_fill_mode(value : AnimationFillMode) -> MotionDeclaration {
  motion_declaration(declaration("animationFillMode", value.to_css(), []))
}

///|
pub fn animation_fill_mode_fallbacks(
  values : Array[AnimationFillMode],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationFillMode", values.map(value => value.to_css()), []))
}

///|
pub fn animation_play_state(value : AnimationPlayState) -> MotionDeclaration {
  motion_declaration(declaration("animationPlayState", value.to_css(), []))
}

///|
pub fn animation_play_state_fallbacks(
  values : Array[AnimationPlayState],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationPlayState", values.map(value => value.to_css()), []))
}

///|
pub fn animation_timing_function(value : @values.EasingFunction) -> MotionDeclaration {
  motion_declaration(declaration("animationTimingFunction", value.to_css(), []))
}

///|
pub fn animation_timing_function_fallbacks(
  values : Array[@values.EasingFunction],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationTimingFunction", values.map(value => value.to_css()), []))
}

///|
pub fn transition_timing_function(value : @values.EasingFunction) -> MotionDeclaration {
  motion_declaration(declaration("transitionTimingFunction", value.to_css(), []))
}

///|
pub fn transition_timing_function_fallbacks(
  values : Array[@values.EasingFunction],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transitionTimingFunction", values.map(value => value.to_css()), []))
}

///|
pub fn transition_property(value : TransitionProperty) -> MotionDeclaration {
  motion_declaration(declaration("transitionProperty", value.to_css(), []))
}

///|
pub fn transition_property_fallbacks(
  values : Array[TransitionProperty],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transitionProperty", values.map(value => value.to_css()), []))
}

///|
pub fn pointer_events(value : PointerEvents) -> InteractionDeclaration {
  interaction_declaration(declaration("pointerEvents", value.to_css(), []))
}

///|
pub fn pointer_events_fallbacks(
  values : Array[PointerEvents],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("pointerEvents", values.map(value => value.to_css()), []))
}

///|
pub fn user_select(value : UserSelect) -> InteractionDeclaration {
  interaction_declaration(declaration("userSelect", value.to_css(), []))
}

///|
pub fn user_select_fallbacks(
  values : Array[UserSelect],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("userSelect", values.map(value => value.to_css()), []))
}

///|
pub fn touch_action(value : @values.TouchAction) -> InteractionDeclaration {
  interaction_declaration(declaration("touchAction", value.to_css(), []))
}

///|
pub fn touch_action_fallbacks(
  values : Array[@values.TouchAction],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("touchAction", values.map(value => value.to_css()), []))
}

///|
pub fn accent_color(value : @values.Color) -> InteractionDeclaration {
  interaction_declaration(declaration("accentColor", value.to_css(), []))
}

///|
pub fn accent_color_fallbacks(
  values : Array[@values.Color],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("accentColor", values.map(value => value.to_css()), []))
}

///|
pub fn caret_color(value : @values.Color) -> InteractionDeclaration {
  interaction_declaration(declaration("caretColor", value.to_css(), []))
}

///|
pub fn caret_color_fallbacks(
  values : Array[@values.Color],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("caretColor", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_behavior(value : ScrollBehavior) -> InteractionDeclaration {
  interaction_declaration(declaration("scrollBehavior", value.to_css(), []))
}

///|
pub fn scroll_behavior_fallbacks(
  values : Array[ScrollBehavior],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("scrollBehavior", values.map(value => value.to_css()), []))
}

///|
pub fn overscroll_behavior_x(value : OverscrollBehavior) -> InteractionDeclaration {
  interaction_declaration(declaration("overscrollBehaviorX", value.to_css(), []))
}

///|
pub fn overscroll_behavior_x_fallbacks(
  values : Array[OverscrollBehavior],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("overscrollBehaviorX", values.map(value => value.to_css()), []))
}

///|
pub fn overscroll_behavior_y(value : OverscrollBehavior) -> InteractionDeclaration {
  interaction_declaration(declaration("overscrollBehaviorY", value.to_css(), []))
}

///|
pub fn overscroll_behavior_y_fallbacks(
  values : Array[OverscrollBehavior],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("overscrollBehaviorY", values.map(value => value.to_css()), []))
}

///|
pub fn content_visibility(value : ContentVisibility) -> InteractionDeclaration {
  interaction_declaration(declaration("contentVisibility", value.to_css(), []))
}

///|
pub fn content_visibility_fallbacks(
  values : Array[ContentVisibility],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("contentVisibility", values.map(value => value.to_css()), []))
}

///|
pub fn baseline_shift(value : @values.LengthPercentage) -> TypographyDeclaration {
  typography_declaration(declaration("baselineShift", value.to_css(), []))
}

///|
pub fn baseline_shift_fallbacks(
  values : Array[@values.LengthPercentage],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("baselineShift", values.map(value => value.to_css()), []))
}

///|
pub fn baseline_source(value : BaselineSourceValue) -> LayoutDeclaration {
  layout_declaration(declaration("baselineSource", value.to_css(), []))
}

///|
pub fn baseline_source_fallbacks(
  values : Array[BaselineSourceValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("baselineSource", values.map(value => value.to_css()), []))
}

///|
pub fn block_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("blockSize", value.to_css(), []))
}

///|
pub fn block_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("blockSize", values.map(value => value.to_css()), []))
}

///|
pub fn border_collapse(value : BorderCollapseValue) -> LayoutDeclaration {
  layout_declaration(declaration("borderCollapse", value.to_css(), []))
}

///|
pub fn border_collapse_fallbacks(
  values : Array[BorderCollapseValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("borderCollapse", values.map(value => value.to_css()), []))
}

///|
pub fn border_image_repeat(value : BorderImageRepeatValue) -> VisualDeclaration {
  visual_declaration(declaration("borderImageRepeat", value.to_css(), []))
}

///|
pub fn border_image_repeat_fallbacks(
  values : Array[BorderImageRepeatValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderImageRepeat", values.map(value => value.to_css()), []))
}

///|
pub fn border_spacing(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("borderSpacing", value.to_css(), []))
}

///|
pub fn border_spacing_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("borderSpacing", values.map(value => value.to_css()), []))
}

///|
pub fn box_decoration_break(value : BoxDecorationBreakValue) -> VisualDeclaration {
  visual_declaration(declaration("boxDecorationBreak", value.to_css(), []))
}

///|
pub fn box_decoration_break_fallbacks(
  values : Array[BoxDecorationBreakValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("boxDecorationBreak", values.map(value => value.to_css()), []))
}

///|
pub fn break_after(value : BreakAfterValue) -> LayoutDeclaration {
  layout_declaration(declaration("breakAfter", value.to_css(), []))
}

///|
pub fn break_after_fallbacks(
  values : Array[BreakAfterValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("breakAfter", values.map(value => value.to_css()), []))
}

///|
pub fn break_before(value : BreakBeforeValue) -> LayoutDeclaration {
  layout_declaration(declaration("breakBefore", value.to_css(), []))
}

///|
pub fn break_before_fallbacks(
  values : Array[BreakBeforeValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("breakBefore", values.map(value => value.to_css()), []))
}

///|
pub fn break_inside(value : BreakInsideValue) -> LayoutDeclaration {
  layout_declaration(declaration("breakInside", value.to_css(), []))
}

///|
pub fn break_inside_fallbacks(
  values : Array[BreakInsideValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("breakInside", values.map(value => value.to_css()), []))
}

///|
pub fn caption_side(value : CaptionSideValue) -> LayoutDeclaration {
  layout_declaration(declaration("captionSide", value.to_css(), []))
}

///|
pub fn caption_side_fallbacks(
  values : Array[CaptionSideValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("captionSide", values.map(value => value.to_css()), []))
}

///|
pub fn clip_rule(value : ClipRuleValue) -> VisualDeclaration {
  visual_declaration(declaration("clipRule", value.to_css(), []))
}

///|
pub fn clip_rule_fallbacks(
  values : Array[ClipRuleValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("clipRule", values.map(value => value.to_css()), []))
}

///|
pub fn color_interpolation_filters(value : ColorInterpolationFiltersValue) -> VisualDeclaration {
  visual_declaration(declaration("colorInterpolationFilters", value.to_css(), []))
}

///|
pub fn color_interpolation_filters_fallbacks(
  values : Array[ColorInterpolationFiltersValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("colorInterpolationFilters", values.map(value => value.to_css()), []))
}

///|
pub fn column_count(value : @values.Integer) -> LayoutDeclaration {
  layout_declaration(declaration("columnCount", value.to_css(), []))
}

///|
pub fn column_count_fallbacks(
  values : Array[@values.Integer],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("columnCount", values.map(value => value.to_css()), []))
}

///|
pub fn column_fill(value : ColumnFillValue) -> LayoutDeclaration {
  layout_declaration(declaration("columnFill", value.to_css(), []))
}

///|
pub fn column_fill_fallbacks(
  values : Array[ColumnFillValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("columnFill", values.map(value => value.to_css()), []))
}

///|
pub fn column_span(value : ColumnSpanValue) -> LayoutDeclaration {
  layout_declaration(declaration("columnSpan", value.to_css(), []))
}

///|
pub fn column_span_fallbacks(
  values : Array[ColumnSpanValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("columnSpan", values.map(value => value.to_css()), []))
}

///|
pub fn contain_intrinsic_block_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("containIntrinsicBlockSize", value.to_css(), []))
}

///|
pub fn contain_intrinsic_block_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containIntrinsicBlockSize", values.map(value => value.to_css()), []))
}

///|
pub fn contain_intrinsic_height(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("containIntrinsicHeight", value.to_css(), []))
}

///|
pub fn contain_intrinsic_height_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containIntrinsicHeight", values.map(value => value.to_css()), []))
}

///|
pub fn contain_intrinsic_inline_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("containIntrinsicInlineSize", value.to_css(), []))
}

///|
pub fn contain_intrinsic_inline_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containIntrinsicInlineSize", values.map(value => value.to_css()), []))
}

///|
pub fn contain_intrinsic_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("containIntrinsicSize", value.to_css(), []))
}

///|
pub fn contain_intrinsic_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containIntrinsicSize", values.map(value => value.to_css()), []))
}

///|
pub fn contain_intrinsic_width(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("containIntrinsicWidth", value.to_css(), []))
}

///|
pub fn contain_intrinsic_width_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containIntrinsicWidth", values.map(value => value.to_css()), []))
}

///|
pub fn container_type(value : ContainerTypeValue) -> LayoutDeclaration {
  layout_declaration(declaration("containerType", value.to_css(), []))
}

///|
pub fn container_type_fallbacks(
  values : Array[ContainerTypeValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("containerType", values.map(value => value.to_css()), []))
}

///|
pub fn cx(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("cx", value.to_css(), []))
}

///|
pub fn cx_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("cx", values.map(value => value.to_css()), []))
}

///|
pub fn cy(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("cy", value.to_css(), []))
}

///|
pub fn cy_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("cy", values.map(value => value.to_css()), []))
}

///|
pub fn direction(value : DirectionValue) -> LayoutDeclaration {
  layout_declaration(declaration("direction", value.to_css(), []))
}

///|
pub fn direction_fallbacks(
  values : Array[DirectionValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("direction", values.map(value => value.to_css()), []))
}

///|
pub fn empty_cells(value : EmptyCellsValue) -> LayoutDeclaration {
  layout_declaration(declaration("emptyCells", value.to_css(), []))
}

///|
pub fn empty_cells_fallbacks(
  values : Array[EmptyCellsValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("emptyCells", values.map(value => value.to_css()), []))
}

///|
pub fn field_sizing(value : FieldSizingValue) -> LayoutDeclaration {
  layout_declaration(declaration("fieldSizing", value.to_css(), []))
}

///|
pub fn field_sizing_fallbacks(
  values : Array[FieldSizingValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("fieldSizing", values.map(value => value.to_css()), []))
}

///|
pub fn fill_opacity(value : Double) -> VisualDeclaration {
  visual_declaration(declaration("fillOpacity", value.to_string(), []))
}

///|
pub fn fill_opacity_fallbacks(
  values : Array[Double],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("fillOpacity", values.map(value => value.to_string()), []))
}

///|
pub fn fill_rule(value : FillRuleValue) -> VisualDeclaration {
  visual_declaration(declaration("fillRule", value.to_css(), []))
}

///|
pub fn fill_rule_fallbacks(
  values : Array[FillRuleValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("fillRule", values.map(value => value.to_css()), []))
}

///|
pub fn flood_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("floodColor", value.to_css(), []))
}

///|
pub fn flood_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("floodColor", values.map(value => value.to_css()), []))
}

///|
pub fn flood_opacity(value : Double) -> VisualDeclaration {
  visual_declaration(declaration("floodOpacity", value.to_string(), []))
}

///|
pub fn flood_opacity_fallbacks(
  values : Array[Double],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("floodOpacity", values.map(value => value.to_string()), []))
}

///|
pub fn font_size_adjust(value : @values.Number) -> TypographyDeclaration {
  typography_declaration(declaration("fontSizeAdjust", value.to_css(), []))
}

///|
pub fn font_size_adjust_fallbacks(
  values : Array[@values.Number],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontSizeAdjust", values.map(value => value.to_css()), []))
}

///|
pub fn font_synthesis(value : FontSynthesisValue) -> TypographyDeclaration {
  typography_declaration(declaration("fontSynthesis", value.to_css(), []))
}

///|
pub fn font_synthesis_fallbacks(
  values : Array[FontSynthesisValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontSynthesis", values.map(value => value.to_css()), []))
}

///|
pub fn font_synthesis_small_caps(value : FontSynthesisSmallCapsValue) -> TypographyDeclaration {
  typography_declaration(declaration("fontSynthesisSmallCaps", value.to_css(), []))
}

///|
pub fn font_synthesis_small_caps_fallbacks(
  values : Array[FontSynthesisSmallCapsValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontSynthesisSmallCaps", values.map(value => value.to_css()), []))
}

///|
pub fn font_synthesis_style(value : FontSynthesisStyleValue) -> TypographyDeclaration {
  typography_declaration(declaration("fontSynthesisStyle", value.to_css(), []))
}

///|
pub fn font_synthesis_style_fallbacks(
  values : Array[FontSynthesisStyleValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontSynthesisStyle", values.map(value => value.to_css()), []))
}

///|
pub fn font_synthesis_weight(value : FontSynthesisWeightValue) -> TypographyDeclaration {
  typography_declaration(declaration("fontSynthesisWeight", value.to_css(), []))
}

///|
pub fn font_synthesis_weight_fallbacks(
  values : Array[FontSynthesisWeightValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontSynthesisWeight", values.map(value => value.to_css()), []))
}

///|
pub fn font_variant_emoji(value : FontVariantEmojiValue) -> TypographyDeclaration {
  typography_declaration(declaration("fontVariantEmoji", value.to_css(), []))
}

///|
pub fn font_variant_emoji_fallbacks(
  values : Array[FontVariantEmojiValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontVariantEmoji", values.map(value => value.to_css()), []))
}

///|
pub fn font_variant_position(value : FontVariantPositionValue) -> TypographyDeclaration {
  typography_declaration(declaration("fontVariantPosition", value.to_css(), []))
}

///|
pub fn font_variant_position_fallbacks(
  values : Array[FontVariantPositionValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontVariantPosition", values.map(value => value.to_css()), []))
}

///|
pub fn font_width(value : @values.Percentage) -> TypographyDeclaration {
  typography_declaration(declaration("fontWidth", value.to_css(), []))
}

///|
pub fn font_width_fallbacks(
  values : Array[@values.Percentage],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("fontWidth", values.map(value => value.to_css()), []))
}

///|
pub fn forced_color_adjust(value : ForcedColorAdjustValue) -> VisualDeclaration {
  visual_declaration(declaration("forcedColorAdjust", value.to_css(), []))
}

///|
pub fn forced_color_adjust_fallbacks(
  values : Array[ForcedColorAdjustValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("forcedColorAdjust", values.map(value => value.to_css()), []))
}

///|
pub fn hanging_punctuation(value : HangingPunctuationValue) -> TypographyDeclaration {
  typography_declaration(declaration("hangingPunctuation", value.to_css(), []))
}

///|
pub fn hanging_punctuation_fallbacks(
  values : Array[HangingPunctuationValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("hangingPunctuation", values.map(value => value.to_css()), []))
}

///|
pub fn hyphenate_limit_chars(value : @values.Integer) -> TypographyDeclaration {
  typography_declaration(declaration("hyphenateLimitChars", value.to_css(), []))
}

///|
pub fn hyphenate_limit_chars_fallbacks(
  values : Array[@values.Integer],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("hyphenateLimitChars", values.map(value => value.to_css()), []))
}

///|
pub fn image_orientation(value : @values.Angle) -> VisualDeclaration {
  visual_declaration(declaration("imageOrientation", value.to_css(), []))
}

///|
pub fn image_orientation_fallbacks(
  values : Array[@values.Angle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("imageOrientation", values.map(value => value.to_css()), []))
}

///|
pub fn inline_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("inlineSize", value.to_css(), []))
}

///|
pub fn inline_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("inlineSize", values.map(value => value.to_css()), []))
}

///|
pub fn lighting_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("lightingColor", value.to_css(), []))
}

///|
pub fn lighting_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("lightingColor", values.map(value => value.to_css()), []))
}

///|
pub fn line_break(value : LineBreakValue) -> TypographyDeclaration {
  typography_declaration(declaration("lineBreak", value.to_css(), []))
}

///|
pub fn line_break_fallbacks(
  values : Array[LineBreakValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("lineBreak", values.map(value => value.to_css()), []))
}

///|
pub fn margin_block_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginBlockEnd", value.to_css(), []))
}

///|
pub fn margin_block_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginBlockEnd", values.map(value => value.to_css()), []))
}

///|
pub fn margin_block_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("marginBlockStart", value.to_css(), []))
}

///|
pub fn margin_block_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("marginBlockStart", values.map(value => value.to_css()), []))
}

///|
pub fn mask_type(value : MaskTypeValue) -> VisualDeclaration {
  visual_declaration(declaration("maskType", value.to_css(), []))
}

///|
pub fn mask_type_fallbacks(
  values : Array[MaskTypeValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskType", values.map(value => value.to_css()), []))
}

///|
pub fn math_shift(value : MathShiftValue) -> TypographyDeclaration {
  typography_declaration(declaration("mathShift", value.to_css(), []))
}

///|
pub fn math_shift_fallbacks(
  values : Array[MathShiftValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("mathShift", values.map(value => value.to_css()), []))
}

///|
pub fn math_style(value : MathStyleValue) -> TypographyDeclaration {
  typography_declaration(declaration("mathStyle", value.to_css(), []))
}

///|
pub fn math_style_fallbacks(
  values : Array[MathStyleValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("mathStyle", values.map(value => value.to_css()), []))
}

///|
pub fn max_block_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("maxBlockSize", value.to_css(), []))
}

///|
pub fn max_block_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("maxBlockSize", values.map(value => value.to_css()), []))
}

///|
pub fn max_inline_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("maxInlineSize", value.to_css(), []))
}

///|
pub fn max_inline_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("maxInlineSize", values.map(value => value.to_css()), []))
}

///|
pub fn min_block_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("minBlockSize", value.to_css(), []))
}

///|
pub fn min_block_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("minBlockSize", values.map(value => value.to_css()), []))
}

///|
pub fn min_inline_size(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("minInlineSize", value.to_css(), []))
}

///|
pub fn min_inline_size_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("minInlineSize", values.map(value => value.to_css()), []))
}

///|
pub fn offset_distance(value : @values.LengthPercentage) -> MotionDeclaration {
  motion_declaration(declaration("offsetDistance", value.to_css(), []))
}

///|
pub fn offset_distance_fallbacks(
  values : Array[@values.LengthPercentage],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("offsetDistance", values.map(value => value.to_css()), []))
}

///|
pub fn offset_rotate(value : @values.OffsetRotate) -> MotionDeclaration {
  motion_declaration(declaration("offsetRotate", value.to_css(), []))
}

///|
pub fn offset_rotate_fallbacks(
  values : Array[@values.OffsetRotate],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("offsetRotate", values.map(value => value.to_css()), []))
}

///|
pub fn orphans(value : @values.Integer) -> TypographyDeclaration {
  typography_declaration(declaration("orphans", value.to_css(), []))
}

///|
pub fn orphans_fallbacks(
  values : Array[@values.Integer],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("orphans", values.map(value => value.to_css()), []))
}

///|
pub fn outline_offset(value : @values.Length) -> VisualDeclaration {
  visual_declaration(declaration("outlineOffset", value.to_css(), []))
}

///|
pub fn outline_offset_fallbacks(
  values : Array[@values.Length],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("outlineOffset", values.map(value => value.to_css()), []))
}

///|
pub fn overflow_anchor(value : OverflowAnchorValue) -> InteractionDeclaration {
  interaction_declaration(declaration("overflowAnchor", value.to_css(), []))
}

///|
pub fn overflow_anchor_fallbacks(
  values : Array[OverflowAnchorValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("overflowAnchor", values.map(value => value.to_css()), []))
}

///|
pub fn overscroll_behavior(value : OverscrollBehaviorValue) -> InteractionDeclaration {
  interaction_declaration(declaration("overscrollBehavior", value.to_css(), []))
}

///|
pub fn overscroll_behavior_fallbacks(
  values : Array[OverscrollBehaviorValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("overscrollBehavior", values.map(value => value.to_css()), []))
}

///|
pub fn overscroll_behavior_block(value : OverscrollBehaviorBlockValue) -> InteractionDeclaration {
  interaction_declaration(declaration("overscrollBehaviorBlock", value.to_css(), []))
}

///|
pub fn overscroll_behavior_block_fallbacks(
  values : Array[OverscrollBehaviorBlockValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("overscrollBehaviorBlock", values.map(value => value.to_css()), []))
}

///|
pub fn overscroll_behavior_inline(value : OverscrollBehaviorInlineValue) -> InteractionDeclaration {
  interaction_declaration(declaration("overscrollBehaviorInline", value.to_css(), []))
}

///|
pub fn overscroll_behavior_inline_fallbacks(
  values : Array[OverscrollBehaviorInlineValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("overscrollBehaviorInline", values.map(value => value.to_css()), []))
}

///|
pub fn padding_block_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingBlockEnd", value.to_css(), []))
}

///|
pub fn padding_block_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingBlockEnd", values.map(value => value.to_css()), []))
}

///|
pub fn padding_block_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("paddingBlockStart", value.to_css(), []))
}

///|
pub fn padding_block_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("paddingBlockStart", values.map(value => value.to_css()), []))
}

///|
pub fn paint_order(value : PaintOrderValue) -> VisualDeclaration {
  visual_declaration(declaration("paintOrder", value.to_css(), []))
}

///|
pub fn paint_order_fallbacks(
  values : Array[PaintOrderValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("paintOrder", values.map(value => value.to_css()), []))
}

///|
pub fn position_visibility(value : PositionVisibilityValue) -> LayoutDeclaration {
  layout_declaration(declaration("positionVisibility", value.to_css(), []))
}

///|
pub fn position_visibility_fallbacks(
  values : Array[PositionVisibilityValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("positionVisibility", values.map(value => value.to_css()), []))
}

///|
pub fn print_color_adjust(value : PrintColorAdjustValue) -> VisualDeclaration {
  visual_declaration(declaration("printColorAdjust", value.to_css(), []))
}

///|
pub fn print_color_adjust_fallbacks(
  values : Array[PrintColorAdjustValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("printColorAdjust", values.map(value => value.to_css()), []))
}

///|
pub fn r(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("r", value.to_css(), []))
}

///|
pub fn r_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("r", values.map(value => value.to_css()), []))
}

///|
pub fn ruby_align(value : RubyAlignValue) -> TypographyDeclaration {
  typography_declaration(declaration("rubyAlign", value.to_css(), []))
}

///|
pub fn ruby_align_fallbacks(
  values : Array[RubyAlignValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("rubyAlign", values.map(value => value.to_css()), []))
}

///|
pub fn ruby_position(value : RubyPositionValue) -> TypographyDeclaration {
  typography_declaration(declaration("rubyPosition", value.to_css(), []))
}

///|
pub fn ruby_position_fallbacks(
  values : Array[RubyPositionValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("rubyPosition", values.map(value => value.to_css()), []))
}

///|
pub fn rx(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("rx", value.to_css(), []))
}

///|
pub fn rx_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("rx", values.map(value => value.to_css()), []))
}

///|
pub fn ry(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("ry", value.to_css(), []))
}

///|
pub fn ry_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("ry", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMargin", value.to_css(), []))
}

///|
pub fn scroll_margin_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMargin", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_block(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginBlock", value.to_css(), []))
}

///|
pub fn scroll_margin_block_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginBlock", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_block_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginBlockEnd", value.to_css(), []))
}

///|
pub fn scroll_margin_block_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginBlockEnd", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_block_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginBlockStart", value.to_css(), []))
}

///|
pub fn scroll_margin_block_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginBlockStart", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_bottom(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginBottom", value.to_css(), []))
}

///|
pub fn scroll_margin_bottom_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginBottom", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_inline(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginInline", value.to_css(), []))
}

///|
pub fn scroll_margin_inline_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginInline", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_inline_end(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginInlineEnd", value.to_css(), []))
}

///|
pub fn scroll_margin_inline_end_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginInlineEnd", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_inline_start(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginInlineStart", value.to_css(), []))
}

///|
pub fn scroll_margin_inline_start_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginInlineStart", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_left(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginLeft", value.to_css(), []))
}

///|
pub fn scroll_margin_left_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginLeft", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_right(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginRight", value.to_css(), []))
}

///|
pub fn scroll_margin_right_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginRight", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_margin_top(value : @values.Length) -> LayoutDeclaration {
  layout_declaration(declaration("scrollMarginTop", value.to_css(), []))
}

///|
pub fn scroll_margin_top_fallbacks(
  values : Array[@values.Length],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollMarginTop", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPadding", value.to_css(), []))
}

///|
pub fn scroll_padding_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPadding", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_block(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingBlock", value.to_css(), []))
}

///|
pub fn scroll_padding_block_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingBlock", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_block_end(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingBlockEnd", value.to_css(), []))
}

///|
pub fn scroll_padding_block_end_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingBlockEnd", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_block_start(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingBlockStart", value.to_css(), []))
}

///|
pub fn scroll_padding_block_start_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingBlockStart", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_bottom(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingBottom", value.to_css(), []))
}

///|
pub fn scroll_padding_bottom_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingBottom", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_inline(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingInline", value.to_css(), []))
}

///|
pub fn scroll_padding_inline_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingInline", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_inline_end(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingInlineEnd", value.to_css(), []))
}

///|
pub fn scroll_padding_inline_end_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingInlineEnd", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_inline_start(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingInlineStart", value.to_css(), []))
}

///|
pub fn scroll_padding_inline_start_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingInlineStart", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_left(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingLeft", value.to_css(), []))
}

///|
pub fn scroll_padding_left_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingLeft", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_right(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingRight", value.to_css(), []))
}

///|
pub fn scroll_padding_right_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingRight", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_padding_top(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("scrollPaddingTop", value.to_css(), []))
}

///|
pub fn scroll_padding_top_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("scrollPaddingTop", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_snap_align(value : ScrollSnapAlignValue) -> InteractionDeclaration {
  interaction_declaration(declaration("scrollSnapAlign", value.to_css(), []))
}

///|
pub fn scroll_snap_align_fallbacks(
  values : Array[ScrollSnapAlignValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("scrollSnapAlign", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_snap_stop(value : ScrollSnapStopValue) -> InteractionDeclaration {
  interaction_declaration(declaration("scrollSnapStop", value.to_css(), []))
}

///|
pub fn scroll_snap_stop_fallbacks(
  values : Array[ScrollSnapStopValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("scrollSnapStop", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_snap_type(value : ScrollSnapTypeValue) -> InteractionDeclaration {
  interaction_declaration(declaration("scrollSnapType", value.to_css(), []))
}

///|
pub fn scroll_snap_type_fallbacks(
  values : Array[ScrollSnapTypeValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("scrollSnapType", values.map(value => value.to_css()), []))
}

///|
pub fn scroll_timeline_axis(value : ScrollTimelineAxisValue) -> MotionDeclaration {
  motion_declaration(declaration("scrollTimelineAxis", value.to_css(), []))
}

///|
pub fn scroll_timeline_axis_fallbacks(
  values : Array[ScrollTimelineAxisValue],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("scrollTimelineAxis", values.map(value => value.to_css()), []))
}

///|
pub fn scrollbar_width(value : ScrollbarWidthValue) -> InteractionDeclaration {
  interaction_declaration(declaration("scrollbarWidth", value.to_css(), []))
}

///|
pub fn scrollbar_width_fallbacks(
  values : Array[ScrollbarWidthValue],
) -> InteractionDeclaration {
  interaction_declaration(fallback_declaration("scrollbarWidth", values.map(value => value.to_css()), []))
}

///|
pub fn shape_margin(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("shapeMargin", value.to_css(), []))
}

///|
pub fn shape_margin_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("shapeMargin", values.map(value => value.to_css()), []))
}

///|
pub fn shape_rendering(value : ShapeRenderingValue) -> VisualDeclaration {
  visual_declaration(declaration("shapeRendering", value.to_css(), []))
}

///|
pub fn shape_rendering_fallbacks(
  values : Array[ShapeRenderingValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("shapeRendering", values.map(value => value.to_css()), []))
}

///|
pub fn speak(value : SpeakValue) -> TypographyDeclaration {
  typography_declaration(declaration("speak", value.to_css(), []))
}

///|
pub fn speak_fallbacks(
  values : Array[SpeakValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("speak", values.map(value => value.to_css()), []))
}

///|
pub fn stop_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("stopColor", value.to_css(), []))
}

///|
pub fn stop_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("stopColor", values.map(value => value.to_css()), []))
}

///|
pub fn stop_opacity(value : Double) -> VisualDeclaration {
  visual_declaration(declaration("stopOpacity", value.to_string(), []))
}

///|
pub fn stop_opacity_fallbacks(
  values : Array[Double],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("stopOpacity", values.map(value => value.to_string()), []))
}

///|
pub fn stroke_linecap(value : StrokeLinecapValue) -> VisualDeclaration {
  visual_declaration(declaration("strokeLinecap", value.to_css(), []))
}

///|
pub fn stroke_linecap_fallbacks(
  values : Array[StrokeLinecapValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("strokeLinecap", values.map(value => value.to_css()), []))
}

///|
pub fn stroke_linejoin(value : StrokeLinejoinValue) -> VisualDeclaration {
  visual_declaration(declaration("strokeLinejoin", value.to_css(), []))
}

///|
pub fn stroke_linejoin_fallbacks(
  values : Array[StrokeLinejoinValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("strokeLinejoin", values.map(value => value.to_css()), []))
}

///|
pub fn stroke_miterlimit(value : @values.Number) -> VisualDeclaration {
  visual_declaration(declaration("strokeMiterlimit", value.to_css(), []))
}

///|
pub fn stroke_miterlimit_fallbacks(
  values : Array[@values.Number],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("strokeMiterlimit", values.map(value => value.to_css()), []))
}

///|
pub fn stroke_opacity(value : Double) -> VisualDeclaration {
  visual_declaration(declaration("strokeOpacity", value.to_string(), []))
}

///|
pub fn stroke_opacity_fallbacks(
  values : Array[Double],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("strokeOpacity", values.map(value => value.to_string()), []))
}

///|
pub fn table_layout(value : TableLayoutValue) -> LayoutDeclaration {
  layout_declaration(declaration("tableLayout", value.to_css(), []))
}

///|
pub fn table_layout_fallbacks(
  values : Array[TableLayoutValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("tableLayout", values.map(value => value.to_css()), []))
}

///|
pub fn text_anchor(value : TextAnchorValue) -> TypographyDeclaration {
  typography_declaration(declaration("textAnchor", value.to_css(), []))
}

///|
pub fn text_anchor_fallbacks(
  values : Array[TextAnchorValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textAnchor", values.map(value => value.to_css()), []))
}

///|
pub fn text_box_trim(value : TextBoxTrimValue) -> TypographyDeclaration {
  typography_declaration(declaration("textBoxTrim", value.to_css(), []))
}

///|
pub fn text_box_trim_fallbacks(
  values : Array[TextBoxTrimValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textBoxTrim", values.map(value => value.to_css()), []))
}

///|
pub fn text_combine_upright(value : TextCombineUprightValue) -> TypographyDeclaration {
  typography_declaration(declaration("textCombineUpright", value.to_css(), []))
}

///|
pub fn text_combine_upright_fallbacks(
  values : Array[TextCombineUprightValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textCombineUpright", values.map(value => value.to_css()), []))
}

///|
pub fn text_decoration_inset(value : @values.LengthPercentage) -> TypographyDeclaration {
  typography_declaration(declaration("textDecorationInset", value.to_css(), []))
}

///|
pub fn text_decoration_inset_fallbacks(
  values : Array[@values.LengthPercentage],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textDecorationInset", values.map(value => value.to_css()), []))
}

///|
pub fn text_decoration_skip_ink(value : TextDecorationSkipInkValue) -> TypographyDeclaration {
  typography_declaration(declaration("textDecorationSkipInk", value.to_css(), []))
}

///|
pub fn text_decoration_skip_ink_fallbacks(
  values : Array[TextDecorationSkipInkValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textDecorationSkipInk", values.map(value => value.to_css()), []))
}

///|
pub fn text_emphasis_color(value : @values.Color) -> TypographyDeclaration {
  typography_declaration(declaration("textEmphasisColor", value.to_css(), []))
}

///|
pub fn text_emphasis_color_fallbacks(
  values : Array[@values.Color],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textEmphasisColor", values.map(value => value.to_css()), []))
}

///|
pub fn text_justify(value : TextJustifyValue) -> TypographyDeclaration {
  typography_declaration(declaration("textJustify", value.to_css(), []))
}

///|
pub fn text_justify_fallbacks(
  values : Array[TextJustifyValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textJustify", values.map(value => value.to_css()), []))
}

///|
pub fn text_orientation(value : TextOrientationValue) -> TypographyDeclaration {
  typography_declaration(declaration("textOrientation", value.to_css(), []))
}

///|
pub fn text_orientation_fallbacks(
  values : Array[TextOrientationValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textOrientation", values.map(value => value.to_css()), []))
}

///|
pub fn text_rendering(value : TextRenderingValue) -> TypographyDeclaration {
  typography_declaration(declaration("textRendering", value.to_css(), []))
}

///|
pub fn text_rendering_fallbacks(
  values : Array[TextRenderingValue],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("textRendering", values.map(value => value.to_css()), []))
}

///|
pub fn transform_box(value : TransformBoxValue) -> MotionDeclaration {
  motion_declaration(declaration("transformBox", value.to_css(), []))
}

///|
pub fn transform_box_fallbacks(
  values : Array[TransformBoxValue],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transformBox", values.map(value => value.to_css()), []))
}

///|
pub fn transition_duration(value : @values.Time) -> MotionDeclaration {
  motion_declaration(declaration("transitionDuration", value.to_css(), []))
}

///|
pub fn transition_duration_fallbacks(
  values : Array[@values.Time],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("transitionDuration", values.map(value => value.to_css()), []))
}

///|
pub fn unicode_bidi(value : UnicodeBidiValue) -> LayoutDeclaration {
  layout_declaration(declaration("unicodeBidi", value.to_css(), []))
}

///|
pub fn unicode_bidi_fallbacks(
  values : Array[UnicodeBidiValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("unicodeBidi", values.map(value => value.to_css()), []))
}

///|
pub fn vector_effect(value : VectorEffectValue) -> VisualDeclaration {
  visual_declaration(declaration("vectorEffect", value.to_css(), []))
}

///|
pub fn vector_effect_fallbacks(
  values : Array[VectorEffectValue],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("vectorEffect", values.map(value => value.to_css()), []))
}

///|
pub fn view_timeline_axis(value : ViewTimelineAxisValue) -> MotionDeclaration {
  motion_declaration(declaration("viewTimelineAxis", value.to_css(), []))
}

///|
pub fn view_timeline_axis_fallbacks(
  values : Array[ViewTimelineAxisValue],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("viewTimelineAxis", values.map(value => value.to_css()), []))
}

///|
pub fn view_timeline_inset(value : @values.LengthPercentage) -> MotionDeclaration {
  motion_declaration(declaration("viewTimelineInset", value.to_css(), []))
}

///|
pub fn view_timeline_inset_fallbacks(
  values : Array[@values.LengthPercentage],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("viewTimelineInset", values.map(value => value.to_css()), []))
}

///|
pub fn widows(value : @values.Integer) -> TypographyDeclaration {
  typography_declaration(declaration("widows", value.to_css(), []))
}

///|
pub fn widows_fallbacks(
  values : Array[@values.Integer],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("widows", values.map(value => value.to_css()), []))
}

///|
pub fn writing_mode(value : WritingModeValue) -> LayoutDeclaration {
  layout_declaration(declaration("writingMode", value.to_css(), []))
}

///|
pub fn writing_mode_fallbacks(
  values : Array[WritingModeValue],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("writingMode", values.map(value => value.to_css()), []))
}

///|
pub fn x(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("x", value.to_css(), []))
}

///|
pub fn x_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("x", values.map(value => value.to_css()), []))
}

///|
pub fn y(value : @values.LengthPercentage) -> LayoutDeclaration {
  layout_declaration(declaration("y", value.to_css(), []))
}

///|
pub fn y_fallbacks(
  values : Array[@values.LengthPercentage],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("y", values.map(value => value.to_css()), []))
}

///|
pub fn border(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("border", value.to_css(), []))
}

///|
pub fn border_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("border", values.map(value => value.to_css()), []))
}

///|
pub fn border_block(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderBlock", value.to_css(), []))
}

///|
pub fn border_block_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlock", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_color(value : @values.BorderColors) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockColor", value.to_css(), []))
}

///|
pub fn border_block_color_fallbacks(
  values : Array[@values.BorderColors],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_end(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockEnd", value.to_css(), []))
}

///|
pub fn border_block_end_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockEnd", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_end_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockEndColor", value.to_css(), []))
}

///|
pub fn border_block_end_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockEndColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_end_style(value : @values.LineStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockEndStyle", value.to_css(), []))
}

///|
pub fn border_block_end_style_fallbacks(
  values : Array[@values.LineStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockEndStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_end_width(value : @values.LineWidth) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockEndWidth", value.to_css(), []))
}

///|
pub fn border_block_end_width_fallbacks(
  values : Array[@values.LineWidth],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockEndWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_start(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockStart", value.to_css(), []))
}

///|
pub fn border_block_start_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockStart", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_start_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockStartColor", value.to_css(), []))
}

///|
pub fn border_block_start_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockStartColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_start_style(value : @values.LineStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockStartStyle", value.to_css(), []))
}

///|
pub fn border_block_start_style_fallbacks(
  values : Array[@values.LineStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockStartStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_start_width(value : @values.LineWidth) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockStartWidth", value.to_css(), []))
}

///|
pub fn border_block_start_width_fallbacks(
  values : Array[@values.LineWidth],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockStartWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_style(value : @values.BorderStyles) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockStyle", value.to_css(), []))
}

///|
pub fn border_block_style_fallbacks(
  values : Array[@values.BorderStyles],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_block_width(value : @values.BorderWidths) -> VisualDeclaration {
  visual_declaration(declaration("borderBlockWidth", value.to_css(), []))
}

///|
pub fn border_block_width_fallbacks(
  values : Array[@values.BorderWidths],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBlockWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_bottom(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderBottom", value.to_css(), []))
}

///|
pub fn border_bottom_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBottom", values.map(value => value.to_css()), []))
}

///|
pub fn border_bottom_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderBottomColor", value.to_css(), []))
}

///|
pub fn border_bottom_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBottomColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_bottom_left_radius(value : @values.CornerRadius) -> VisualDeclaration {
  visual_declaration(declaration("borderBottomLeftRadius", value.to_css(), []))
}

///|
pub fn border_bottom_left_radius_fallbacks(
  values : Array[@values.CornerRadius],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBottomLeftRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_bottom_right_radius(value : @values.CornerRadius) -> VisualDeclaration {
  visual_declaration(declaration("borderBottomRightRadius", value.to_css(), []))
}

///|
pub fn border_bottom_right_radius_fallbacks(
  values : Array[@values.CornerRadius],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBottomRightRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_bottom_style(value : @values.LineStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderBottomStyle", value.to_css(), []))
}

///|
pub fn border_bottom_style_fallbacks(
  values : Array[@values.LineStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBottomStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_bottom_width(value : @values.LineWidth) -> VisualDeclaration {
  visual_declaration(declaration("borderBottomWidth", value.to_css(), []))
}

///|
pub fn border_bottom_width_fallbacks(
  values : Array[@values.LineWidth],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderBottomWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderInline", value.to_css(), []))
}

///|
pub fn border_inline_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInline", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_color(value : @values.BorderColors) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineColor", value.to_css(), []))
}

///|
pub fn border_inline_color_fallbacks(
  values : Array[@values.BorderColors],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_end(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineEnd", value.to_css(), []))
}

///|
pub fn border_inline_end_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineEnd", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_start(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineStart", value.to_css(), []))
}

///|
pub fn border_inline_start_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineStart", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_style(value : @values.BorderStyles) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineStyle", value.to_css(), []))
}

///|
pub fn border_inline_style_fallbacks(
  values : Array[@values.BorderStyles],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_inline_width(value : @values.BorderWidths) -> VisualDeclaration {
  visual_declaration(declaration("borderInlineWidth", value.to_css(), []))
}

///|
pub fn border_inline_width_fallbacks(
  values : Array[@values.BorderWidths],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderInlineWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_left(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderLeft", value.to_css(), []))
}

///|
pub fn border_left_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderLeft", values.map(value => value.to_css()), []))
}

///|
pub fn border_left_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderLeftColor", value.to_css(), []))
}

///|
pub fn border_left_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderLeftColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_left_style(value : @values.LineStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderLeftStyle", value.to_css(), []))
}

///|
pub fn border_left_style_fallbacks(
  values : Array[@values.LineStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderLeftStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_left_width(value : @values.LineWidth) -> VisualDeclaration {
  visual_declaration(declaration("borderLeftWidth", value.to_css(), []))
}

///|
pub fn border_left_width_fallbacks(
  values : Array[@values.LineWidth],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderLeftWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_right(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderRight", value.to_css(), []))
}

///|
pub fn border_right_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderRight", values.map(value => value.to_css()), []))
}

///|
pub fn border_right_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderRightColor", value.to_css(), []))
}

///|
pub fn border_right_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderRightColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_right_style(value : @values.LineStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderRightStyle", value.to_css(), []))
}

///|
pub fn border_right_style_fallbacks(
  values : Array[@values.LineStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderRightStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_right_width(value : @values.LineWidth) -> VisualDeclaration {
  visual_declaration(declaration("borderRightWidth", value.to_css(), []))
}

///|
pub fn border_right_width_fallbacks(
  values : Array[@values.LineWidth],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderRightWidth", values.map(value => value.to_css()), []))
}

///|
pub fn border_top(value : @values.BorderSide) -> VisualDeclaration {
  visual_declaration(declaration("borderTop", value.to_css(), []))
}

///|
pub fn border_top_fallbacks(
  values : Array[@values.BorderSide],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderTop", values.map(value => value.to_css()), []))
}

///|
pub fn border_top_color(value : @values.Color) -> VisualDeclaration {
  visual_declaration(declaration("borderTopColor", value.to_css(), []))
}

///|
pub fn border_top_color_fallbacks(
  values : Array[@values.Color],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderTopColor", values.map(value => value.to_css()), []))
}

///|
pub fn border_top_left_radius(value : @values.CornerRadius) -> VisualDeclaration {
  visual_declaration(declaration("borderTopLeftRadius", value.to_css(), []))
}

///|
pub fn border_top_left_radius_fallbacks(
  values : Array[@values.CornerRadius],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderTopLeftRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_top_right_radius(value : @values.CornerRadius) -> VisualDeclaration {
  visual_declaration(declaration("borderTopRightRadius", value.to_css(), []))
}

///|
pub fn border_top_right_radius_fallbacks(
  values : Array[@values.CornerRadius],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderTopRightRadius", values.map(value => value.to_css()), []))
}

///|
pub fn border_top_style(value : @values.LineStyle) -> VisualDeclaration {
  visual_declaration(declaration("borderTopStyle", value.to_css(), []))
}

///|
pub fn border_top_style_fallbacks(
  values : Array[@values.LineStyle],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderTopStyle", values.map(value => value.to_css()), []))
}

///|
pub fn border_top_width(value : @values.LineWidth) -> VisualDeclaration {
  visual_declaration(declaration("borderTopWidth", value.to_css(), []))
}

///|
pub fn border_top_width_fallbacks(
  values : Array[@values.LineWidth],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("borderTopWidth", values.map(value => value.to_css()), []))
}

///|
pub fn outline(value : @values.Outline) -> VisualDeclaration {
  visual_declaration(declaration("outline", value.to_css(), []))
}

///|
pub fn outline_fallbacks(
  values : Array[@values.Outline],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("outline", values.map(value => value.to_css()), []))
}

///|
pub fn page(
  value : @values.PageValue,
  conditions? : Array[@ir.Condition] = [],
) -> LayoutDeclaration {
  layout_declaration(declaration("page", value.to_css(), conditions))
}

///|
pub fn page_fallbacks(
  values : Array[@values.PageValue],
  conditions? : Array[@ir.Condition] = [],
) -> LayoutDeclaration {
  layout_declaration(fallback_declaration("page", values.map(value => value.to_css()), conditions))
}

///|
pub fn mask_origin(
  value : @values.MaskBox,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("maskOrigin", value.to_css(), conditions))
}

///|
pub fn mask_origin_fallbacks(
  values : Array[@values.MaskBox],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskOrigin", values.map(value => value.to_css()), conditions))
}

///|
pub fn mask_clip(
  value : @values.MaskClip,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("maskClip", value.to_css(), conditions))
}

///|
pub fn mask_clip_fallbacks(
  values : Array[@values.MaskClip],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskClip", values.map(value => value.to_css()), conditions))
}

///|
pub fn mask_mode(
  value : @values.MaskMode,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("maskMode", value.to_css(), conditions))
}

///|
pub fn mask_mode_fallbacks(
  values : Array[@values.MaskMode],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskMode", values.map(value => value.to_css()), conditions))
}

///|
pub fn mask_composite(
  value : @values.MaskComposite,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(declaration("maskComposite", value.to_css(), conditions))
}

///|
pub fn mask_composite_fallbacks(
  values : Array[@values.MaskComposite],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(fallback_declaration("maskComposite", values.map(value => value.to_css()), conditions))
}

///|
pub fn counter_reset(
  value : @values.CounterChanges,
  conditions? : Array[@ir.Condition] = [],
) -> TypographyDeclaration {
  typography_declaration(declaration("counterReset", value.to_css(), conditions))
}

///|
pub fn counter_reset_fallbacks(
  values : Array[@values.CounterChanges],
  conditions? : Array[@ir.Condition] = [],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("counterReset", values.map(value => value.to_css()), conditions))
}

///|
pub fn counter_set(
  value : @values.CounterChanges,
  conditions? : Array[@ir.Condition] = [],
) -> TypographyDeclaration {
  typography_declaration(declaration("counterSet", value.to_css(), conditions))
}

///|
pub fn counter_set_fallbacks(
  values : Array[@values.CounterChanges],
  conditions? : Array[@ir.Condition] = [],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("counterSet", values.map(value => value.to_css()), conditions))
}

///|
pub fn counter_increment(
  value : @values.CounterChanges,
  conditions? : Array[@ir.Condition] = [],
) -> TypographyDeclaration {
  typography_declaration(declaration("counterIncrement", value.to_css(), conditions))
}

///|
pub fn counter_increment_fallbacks(
  values : Array[@values.CounterChanges],
  conditions? : Array[@ir.Condition] = [],
) -> TypographyDeclaration {
  typography_declaration(fallback_declaration("counterIncrement", values.map(value => value.to_css()), conditions))
}

///|
pub fn scroll_timeline_name(
  value : @values.TimelineNames,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("scrollTimelineName", value.to_css(), conditions))
}

///|
pub fn scroll_timeline_name_fallbacks(
  values : Array[@values.TimelineNames],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("scrollTimelineName", values.map(value => value.to_css()), conditions))
}

///|
pub fn view_timeline_name(
  value : @values.TimelineNames,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("viewTimelineName", value.to_css(), conditions))
}

///|
pub fn view_timeline_name_fallbacks(
  values : Array[@values.TimelineNames],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("viewTimelineName", values.map(value => value.to_css()), conditions))
}

///|
pub fn animation_timeline(
  value : @values.AnimationTimelines,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("animationTimeline", value.to_css(), conditions))
}

///|
pub fn animation_timeline_fallbacks(
  values : Array[@values.AnimationTimelines],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationTimeline", values.map(value => value.to_css()), conditions))
}

///|
pub fn animation_range_start(
  value : @values.TimelineRange,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("animationRangeStart", value.to_css(), conditions))
}

///|
pub fn animation_range_start_fallbacks(
  values : Array[@values.TimelineRange],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationRangeStart", values.map(value => value.to_css()), conditions))
}

///|
pub fn animation_range_end(
  value : @values.TimelineRange,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("animationRangeEnd", value.to_css(), conditions))
}

///|
pub fn animation_range_end_fallbacks(
  values : Array[@values.TimelineRange],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("animationRangeEnd", values.map(value => value.to_css()), conditions))
}

///|
pub fn timeline_scope(
  value : @values.TimelineScope,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("timelineScope", value.to_css(), conditions))
}

///|
pub fn timeline_scope_fallbacks(
  values : Array[@values.TimelineScope],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("timelineScope", values.map(value => value.to_css()), conditions))
}

///|
pub fn offset_path(
  value : @values.MotionPath,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("offsetPath", value.to_css(), conditions))
}

///|
pub fn offset_path_fallbacks(
  values : Array[@values.MotionPath],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("offsetPath", values.map(value => value.to_css()), conditions))
}

///|
pub fn offset_position(
  value : @values.OffsetPosition,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("offsetPosition", value.to_css(), conditions))
}

///|
pub fn offset_position_fallbacks(
  values : Array[@values.OffsetPosition],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("offsetPosition", values.map(value => value.to_css()), conditions))
}

///|
pub fn offset_anchor(
  value : @values.OffsetAnchor,
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(declaration("offsetAnchor", value.to_css(), conditions))
}

///|
pub fn offset_anchor_fallbacks(
  values : Array[@values.OffsetAnchor],
  conditions? : Array[@ir.Condition] = [],
) -> MotionDeclaration {
  motion_declaration(fallback_declaration("offsetAnchor", values.map(value => value.to_css()), conditions))
}

///|
pub fn color_scheme(
  value : @values.ColorScheme,
  conditions? : Array[@ir.Condition] = [],
) -> InteractionDeclaration {
  interaction_declaration(theme_paint_declaration("colorScheme", value.expression(), conditions))
}

///|
pub fn color_scheme_fallbacks(
  values : Array[@values.ColorScheme],
  conditions? : Array[@ir.Condition] = [],
) -> InteractionDeclaration {
  interaction_declaration(theme_paint_fallback_declaration("colorScheme", values.map(value => value.expression()), conditions))
}

///|
pub fn scrollbar_color(
  value : @values.ScrollbarColor,
  conditions? : Array[@ir.Condition] = [],
) -> InteractionDeclaration {
  interaction_declaration(theme_paint_declaration("scrollbarColor", value.expression(), conditions))
}

///|
pub fn scrollbar_color_fallbacks(
  values : Array[@values.ScrollbarColor],
  conditions? : Array[@ir.Condition] = [],
) -> InteractionDeclaration {
  interaction_declaration(theme_paint_fallback_declaration("scrollbarColor", values.map(value => value.expression()), conditions))
}

///|
pub fn fill(
  value : @values.SvgPaint,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(theme_paint_declaration("fill", value.expression(), conditions))
}

///|
pub fn fill_fallbacks(
  values : Array[@values.SvgPaint],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(theme_paint_fallback_declaration("fill", values.map(value => value.expression()), conditions))
}

///|
pub fn stroke(
  value : @values.SvgPaint,
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(theme_paint_declaration("stroke", value.expression(), conditions))
}

///|
pub fn stroke_fallbacks(
  values : Array[@values.SvgPaint],
  conditions? : Array[@ir.Condition] = [],
) -> VisualDeclaration {
  visual_declaration(theme_paint_fallback_declaration("stroke", values.map(value => value.expression()), conditions))
}