package styled-ppx

You can search for identifiers within the package.

in-package search v0.2.0

styled-ppx.css-parser
- Styled_ppx_css_parser
  - Ast
  - Driver
  - Lexer
  - Parser
  - Parser_location
  - Tokens
styled-ppx.css-property-parser
- Css_property_parser
  - Combinator
  - Modifier
  - Parser
    
    StringMap
    
    Types
  - Rule
    
    Data
    
    Let
    
    Match
    
    Pattern
  - Standard
styled-ppx.css-spec-parser
- Css_spec_parser
styled-ppx.murmur2
- Murmur2
styled-ppx.native
- Alias
  - Animation
  - Calc
  - Shadow
  - Transition
- Autoprefixer
- CSS
  - Array
  - Stylesheet
    
    Hashes
- Colors
- Css_types
- Declarations
  - SVG
- Kloth
  - Array
  - Float
  - Int
  - Option
  - String
- Rule
styled-ppx.string-interpolation
- String_interpolation

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Declarations end

val label : string -> Rule.rule

val aspectRatio : 
  [< `auto
  | `inherit_
  | `initial
  | `num of float
  | `ratio of int * int
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val alignContent : 
  [< `baseline
  | `center
  | `end_
  | `firstBaseline
  | `flexEnd
  | `flexStart
  | `inherit_
  | `initial
  | `lastBaseline
  | `normal
  | `revert
  | `revertLayer
  | `safe of Css_types.PositionalAlignment.t
  | `spaceAround
  | `spaceBetween
  | `spaceEvenly
  | `start
  | `stretch
  | `unsafe of Css_types.PositionalAlignment.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val alignItems : 
  [< `baseline
  | `center
  | `end_
  | `firstBaseline
  | `flexEnd
  | `flexStart
  | `inherit_
  | `initial
  | `lastBaseline
  | `left
  | `normal
  | `revert
  | `revertLayer
  | `right
  | `safe of Css_types.PositionalAlignment.t
  | `selfEnd
  | `selfStart
  | `start
  | `stretch
  | `unsafe of Css_types.PositionalAlignment.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val alignSelf : 
  [< `auto
  | `baseline
  | `center
  | `end_
  | `firstBaseline
  | `flexEnd
  | `flexStart
  | `inherit_
  | `initial
  | `lastBaseline
  | `left
  | `normal
  | `revert
  | `revertLayer
  | `right
  | `safe of Css_types.PositionalAlignment.t
  | `selfEnd
  | `selfStart
  | `start
  | `stretch
  | `unsafe of Css_types.PositionalAlignment.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val animationDelay : Css_types.Time.t -> Rule.rule

val animationDirection : 
  [< `alternate | `alternateReverse | `normal | `reverse ] ->
  Rule.rule

val animationDuration : Css_types.Time.t -> Rule.rule

val animationFillMode : 
  [< `backwards
  | `both
  | `forwards
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val animationIterationCount : 
  [< `count of float
  | `infinite
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val animationPlayState : 
  [< `inherit_
  | `initial
  | `paused
  | `revert
  | `revertLayer
  | `running
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val animationTimingFunction : 
  [< `cubicBezier of float * float * float * float
  | `ease
  | `easeIn
  | `easeInOut
  | `easeOut
  | `inherit_
  | `initial
  | `jumpBoth
  | `jumpEnd
  | `jumpNone
  | `jumpStart
  | `linear
  | `revert
  | `revertLayer
  | `stepEnd
  | `stepStart
  | `steps of int * [< `end_ | `start ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backfaceVisibility : [< Css_types.BackfaceVisibility.t ] -> Rule.rule

val backdropFilter : 
  [< `blur of Css_types.Length.t
  | `brightness of [< `num of float | `percent of float ]
  | `contrast of [< `num of float | `percent of float ]
  | `dropShadow of
    Css_types.Length.t
    * Css_types.Length.t
    * Css_types.Length.t
    * Css_types.Color.t
  | `grayscale of [< `num of float | `percent of float ]
  | `hueRotate of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `inherit_
  | `initial
  | `invert of [< `num of float | `percent of float ]
  | `none
  | `opacity of [< `num of float | `percent of float ]
  | `revert
  | `revertLayer
  | `saturate of [< `num of float | `percent of float ]
  | `sepia of [< `num of float | `percent of float ]
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val backgroundAttachment : 
  [< `fixed
  | `inherit_
  | `initial
  | `local
  | `revert
  | `revertLayer
  | `scroll
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backgroundColor : Css_types.Color.t -> Rule.rule

val backgroundClip : 
  [< `borderBox
  | `contentBox
  | `inherit_
  | `initial
  | `paddingBox
  | `revert
  | `revertLayer
  | `text
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backgroundImage : 
  [< `conicGradient of
       Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backgroundImages : 
  [< `conicGradient of
       Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val maskImage : 
  [< `conicGradient of
       Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `url of string ] ->
  Rule.rule

val imageRendering : 
  [< `auto
  | `crispEdges
  | `highQuality
  | `inherit_
  | `initial
  | `pixelated
  | `revert
  | `revertLayer
  | `smooth
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backgroundOrigin : 
  [< `borderBox
  | `contentBox
  | `inherit_
  | `initial
  | `paddingBox
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backgroundPosition : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val backgroundPosition2 : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val backgroundPosition4 : 
  x:
    [< `auto
    | `bottom
    | `calc of Css_types.Length.calc_value
    | `center
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `left
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `right
    | `top
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  offsetX:Css_types.Length.t ->
  y:
    [< `auto
    | `bottom
    | `calc of Css_types.Length.calc_value
    | `center
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `left
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `right
    | `top
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  offsetY:Css_types.Length.t ->
  Rule.rule

val backgroundPositions : 
  ([< `auto
   | `bottom
   | `calc of Css_types.Length.calc_value
   | `center
   | `ch of float
   | `cm of float
   | `cqb of float
   | `cqh of float
   | `cqi of float
   | `cqmax of float
   | `cqmin of float
   | `cqw of float
   | `em of float
   | `ex of float
   | `inch of float
   | `inherit_
   | `initial
   | `left
   | `max of Css_types.Length.t array
   | `min of Css_types.Length.t array
   | `mm of float
   | `pc of float
   | `percent of float
   | `pt of int
   | `px of int
   | `pxFloat of float
   | `rem of float
   | `revert
   | `revertLayer
   | `right
   | `top
   | `unset
   | `var of string
   | `varDefault of string * string
   | `vh of float
   | `vmax of float
   | `vmin of float
   | `vw of float
   | `zero ]
   * [< `auto
     | `bottom
     | `calc of Css_types.Length.calc_value
     | `center
     | `ch of float
     | `cm of float
     | `cqb of float
     | `cqh of float
     | `cqi of float
     | `cqmax of float
     | `cqmin of float
     | `cqw of float
     | `em of float
     | `ex of float
     | `inch of float
     | `inherit_
     | `initial
     | `left
     | `max of Css_types.Length.t array
     | `min of Css_types.Length.t array
     | `mm of float
     | `pc of float
     | `percent of float
     | `pt of int
     | `px of int
     | `pxFloat of float
     | `rem of float
     | `revert
     | `revertLayer
     | `right
     | `top
     | `unset
     | `var of string
     | `varDefault of string * string
     | `vh of float
     | `vmax of float
     | `vmin of float
     | `vw of float
     | `zero ])
    array ->
  Rule.rule

val backgroundRepeat : 
  [< `hv of 'a * 'a
  | `inherit_
  | `initial
  | `noRepeat
  | `repeat
  | `repeatX
  | `repeatY
  | `revert
  | `revertLayer
  | `round
  | `space
  | `unset
  | `var of string
  | `varDefault of string * string ] as 'a ->
  Rule.rule

val maskPosition : 
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `hv of
    [< `calc of Css_types.Length.calc_value
    | `center
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `left
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `right
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `bottom
      | `calc of Css_types.Length.calc_value
      | `center
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `min of Css_types.Length.t array
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `top
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val maskPositions : 
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `hv of
    [< `calc of Css_types.Length.calc_value
    | `center
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `left
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `right
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `bottom
      | `calc of Css_types.Length.calc_value
      | `center
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `min of Css_types.Length.t array
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `top
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ]
    array ->
  Rule.rule

val borderImageSource : 
  [< `conicGradient of
       Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `url of string ] ->
  Rule.rule

val borderBottomColor : Css_types.Color.t -> Rule.rule

val borderBottomLeftRadius : Css_types.Length.t -> Rule.rule

val borderBottomRightRadius : Css_types.Length.t -> Rule.rule

val borderBottomWidth : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val borderCollapse : 
  [< `collapse
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `separate
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val borderColor : Css_types.Color.t -> Rule.rule

val borderLeftColor : Css_types.Color.t -> Rule.rule

val borderLeftWidth : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val borderSpacing : Css_types.Length.t -> Rule.rule

val borderRadius : Css_types.Length.t -> Rule.rule

val borderRadius4 : 
  topLeft:Css_types.Length.t ->
  topRight:Css_types.Length.t ->
  bottomLeft:Css_types.Length.t ->
  bottomRight:Css_types.Length.t ->
  Rule.rule

val borderRightColor : Css_types.Color.t -> Rule.rule

val borderRightWidth : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val borderTopColor : Css_types.Color.t -> Rule.rule

val borderTopLeftRadius : Css_types.Length.t -> Rule.rule

val borderTopRightRadius : Css_types.Length.t -> Rule.rule

val borderTopWidth : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val borderWidth : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val bottom : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val boxSizing : 
  [< `borderBox
  | `contentBox
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val clear : 
  [< `both
  | `inherit_
  | `initial
  | `inlineEnd
  | `inlineStart
  | `left
  | `none
  | `revert
  | `revertLayer
  | `right
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val clipPath : 
  [< `borderBox
  | `contentBox
  | `fillBox
  | `inherit_
  | `initial
  | `marginBox
  | `none
  | `paddingBox
  | `revert
  | `revertLayer
  | `strokeBox
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string
  | `viewBox ] ->
  Rule.rule

val color : Css_types.Color.t -> Rule.rule

val columnCount : 
  [< `auto
  | `count of int
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val rowGap : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val columnGap : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val contentRule : 
  [< `attr of string
  | `closeQuote
  | `conicGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `counter of string * Css_types.Counter.style
  | `counters of string * string * Css_types.Counters.style
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `noCloseQuote
  | `noOpenQuote
  | `none
  | `normal
  | `openQuote
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `text of string
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val contentsRule : 
  [< `attr of string
  | `closeQuote
  | `conicGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `counter of string * Css_types.Counter.style
  | `counters of string * string * Css_types.Counters.style
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `noCloseQuote
  | `noOpenQuote
  | `none
  | `normal
  | `openQuote
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `text of string
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ]
    array ->
  string option ->
  Rule.rule

val counterIncrement : 
  [< `increment of string * int
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val countersIncrement : 
  [< `increment of string * int
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val counterReset : 
  [< `inherit_
  | `initial
  | `none
  | `reset of string * int
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val countersReset : 
  [< `inherit_
  | `initial
  | `none
  | `reset of string * int
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val counterSet : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `set of string * int
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val countersSet : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `set of string * int
  | `unset
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val cursor : 
  [< `_moz_grab
  | `_moz_grabbing
  | `_moz_zoom_in
  | `_moz_zoom_out
  | `_webkit_grab
  | `_webkit_grabbing
  | `_webkit_zoom_in
  | `_webkit_zoom_out
  | `alias
  | `allScroll
  | `auto
  | `cell
  | `colResize
  | `contextMenu
  | `copy
  | `crosshair
  | `default
  | `eResize
  | `ewResize
  | `grab
  | `grabbing
  | `hand
  | `help
  | `inherit_
  | `initial
  | `move
  | `nResize
  | `neResize
  | `neswResize
  | `noDrop
  | `none
  | `notAllowed
  | `nsResize
  | `nwResize
  | `nwseResize
  | `pointer
  | `progress
  | `revert
  | `revertLayer
  | `rowResize
  | `sResize
  | `seResize
  | `swResize
  | `text
  | `unset
  | `var of string
  | `varDefault of string * string
  | `verticalText
  | `wResize
  | `wait
  | `zoomIn
  | `zoomOut ] ->
  Rule.rule

val direction : 
  [< `inherit_
  | `initial
  | `ltr
  | `revert
  | `revertLayer
  | `rtl
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val display : 
  [< `block
  | `contents
  | `flex
  | `flow
  | `flowRoot
  | `grid
  | `inherit_
  | `initial
  | `inline
  | `inlineBlock
  | `inlineFlex
  | `inlineGrid
  | `inlineTable
  | `listItem
  | `mozBox
  | `mozInlineBox
  | `mozInlineStack
  | `msFlexbox
  | `msGrid
  | `msInlineFlexbox
  | `msInlineGrid
  | `none
  | `revert
  | `revertLayer
  | `ruby
  | `rubyBase
  | `rubyBaseContainer
  | `rubyText
  | `rubyTextContainer
  | `runIn
  | `table
  | `tableCaption
  | `tableCell
  | `tableColumn
  | `tableColumnGroup
  | `tableFooterGroup
  | `tableHeaderGroup
  | `tableRow
  | `tableRowGroup
  | `unset
  | `var of string
  | `varDefault of string * string
  | `webkitBox
  | `webkitFlex
  | `webkitInlineBox
  | `webkitInlineFlex ] ->
  Rule.rule

val flex : 
  float ->
  float ->
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `content
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fill
  | `fitContent
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val flex1 : [< `auto | `initial | `none | `num of float ] -> Rule.rule

val flex2 : 
  ?basis:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `content
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fill
    | `fitContent
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  ?shrink:float ->
  float ->
  Rule.rule

val flexDirection : 
  [< `column
  | `columnReverse
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `row
  | `rowReverse
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val flexGrow : float -> Rule.rule

val flexShrink : float -> Rule.rule

val flexWrap : 
  [< `inherit_
  | `initial
  | `nowrap
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `wrap
  | `wrapReverse ] ->
  Rule.rule

val float : 
  [< `inherit_
  | `initial
  | `inlineEnd
  | `inlineStart
  | `left
  | `none
  | `revert
  | `revertLayer
  | `right
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontFamily : string -> Rule.rule

val fontFamilies : string array -> Rule.rule

val fontSize : Css_types.Length.t -> Rule.rule

val fontStyle : 
  [< `inherit_
  | `initial
  | `italic
  | `normal
  | `oblique
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontVariant : 
  [< `inherit_
  | `initial
  | `normal
  | `revert
  | `revertLayer
  | `smallCaps
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontWeight : 
  [< `black
  | `bold
  | `bolder
  | `extraBold
  | `extraLight
  | `inherit_
  | `initial
  | `light
  | `lighter
  | `medium
  | `normal
  | `num of int
  | `revert
  | `revertLayer
  | `semiBold
  | `thin
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontDisplay : 
  [< `auto
  | `block
  | `fallback
  | `inherit_
  | `initial
  | `optional
  | `revert
  | `revertLayer
  | `swap
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val sizeAdjust : [< `percent of float ] -> Rule.rule

val gridAutoFlow : 
  [< `column
  | `columnDense
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `row
  | `rowDense
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val gridColumn : int -> int -> Rule.rule

val gridColumnGap : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val gridColumnStart : int -> Rule.rule

val gridColumnEnd : int -> Rule.rule

val gridRow : int -> int -> Rule.rule

val gap : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val gridGap : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val gap2 : 
  rowGap:
    [< `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `normal
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  columnGap:
    [< `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `normal
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  Rule.rule

val gridRowGap : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val gridRowEnd : int -> Rule.rule

val gridRowStart : int -> Rule.rule

val height : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val textEmphasisStyle : 
  [< `circle
  | `dot
  | `double_circle
  | `filled
  | `inherit_
  | `initial
  | `none
  | `open_
  | `revert
  | `revertLayer
  | `sesame
  | `string of string
  | `triangle
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textEmphasisStyles : 
  [< `filled
  | `inherit_
  | `initial
  | `open_
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `circle
  | `dot
  | `double_circle
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `sesame
  | `triangle
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textEmphasisPosition : 
  [< `inherit_
  | `initial
  | `over
  | `revert
  | `revertLayer
  | `under
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textEmphasisPositions : 
  [< `inherit_
  | `initial
  | `over
  | `revert
  | `revertLayer
  | `under
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `inherit_
  | `initial
  | `left
  | `revert
  | `revertLayer
  | `right
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val justifyContent : 
  [< `center
  | `end_
  | `flexEnd
  | `flexStart
  | `inherit_
  | `initial
  | `left
  | `normal
  | `revert
  | `revertLayer
  | `right
  | `safe of Css_types.PositionalAlignment.t
  | `selfEnd
  | `selfStart
  | `spaceAround
  | `spaceBetween
  | `spaceEvenly
  | `start
  | `stretch
  | `unsafe of Css_types.PositionalAlignment.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val justifyItems : 
  [< `baseline
  | `center
  | `end_
  | `firstBaseline
  | `flexEnd
  | `flexStart
  | `inherit_
  | `initial
  | `lastBaseline
  | `left
  | `legacy
  | `legacyCenter
  | `legacyLeft
  | `legacyRight
  | `normal
  | `revert
  | `revertLayer
  | `right
  | `safe of Css_types.PositionalAlignment.t
  | `selfEnd
  | `selfStart
  | `start
  | `stretch
  | `unsafe of Css_types.PositionalAlignment.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val left : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val letterSpacing : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val lineHeight : 
  [< `abs of float
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `normal
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val listStyle : 
  [< `circle
  | `decimal
  | `disc
  | `inherit_
  | `initial
  | `lowerAlpha
  | `lowerGreek
  | `lowerLatin
  | `lowerRoman
  | `none
  | `revert
  | `revertLayer
  | `square
  | `unset
  | `upperAlpha
  | `upperLatin
  | `upperRoman
  | `var of string
  | `varDefault of string * string ] ->
  [< `inherit_
  | `initial
  | `inside
  | `outside
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< Css_types.ListStyleImage.t ] ->
  Rule.rule

val listStyleImage : 
  [< `conicGradient of
       Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val listStyleType : 
  [< `circle
  | `decimal
  | `disc
  | `inherit_
  | `initial
  | `lowerAlpha
  | `lowerGreek
  | `lowerLatin
  | `lowerRoman
  | `none
  | `revert
  | `revertLayer
  | `square
  | `unset
  | `upperAlpha
  | `upperLatin
  | `upperRoman
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val listStylePosition : 
  [< `inherit_
  | `initial
  | `inside
  | `outside
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val tabSize : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `num of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val margin : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val margin2 : 
  v:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  h:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  Rule.rule

val margin3 : 
  top:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  h:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  bottom:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  Rule.rule

val margin4 : 
  top:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  right:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  bottom:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  left:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `inch of float
    | `inherit_
    | `initial
    | `max of Css_types.Length.t array
    | `min of Css_types.Length.t array
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  Rule.rule

val marginLeft : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val marginRight : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val marginTop : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val marginBottom : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val maxHeight : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val maxWidth : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val minHeight : [< Css_types.Height.t ] -> Rule.rule

val minWidth : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val objectFit : 
  [< `contain
  | `cover
  | `fill
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `scaleDown
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val objectPosition : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val objectPosition2 : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val opacity : float -> Rule.rule

val outline : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `auto
  | `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inset
  | `none
  | `outset
  | `ridge
  | `solid ] ->
  Css_types.Color.t ->
  Rule.rule

val outlineColor : Css_types.Color.t -> Rule.rule

val outlineOffset : Css_types.Length.t -> Rule.rule

val outlineStyle : 
  [< `auto
  | `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inset
  | `none
  | `outset
  | `ridge
  | `solid ] ->
  Rule.rule

val outlineWidth : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val overflow : [< `auto | `clip | `hidden | `scroll | `visible ] -> Rule.rule

val overflows : 
  [< `auto | `clip | `hidden | `scroll | `visible ] array ->
  Rule.rule

val overflowX : [< `auto | `clip | `hidden | `scroll | `visible ] -> Rule.rule

val overflowY : [< `auto | `clip | `hidden | `scroll | `visible ] -> Rule.rule

val overflowWrap : 
  [< `anywhere
  | `breakWord
  | `inherit_
  | `initial
  | `normal
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val padding : Css_types.Length.t -> Rule.rule

val padding2 : v:Css_types.Length.t -> h:Css_types.Length.t -> Rule.rule

val padding3 : 
  top:Css_types.Length.t ->
  h:Css_types.Length.t ->
  bottom:Css_types.Length.t ->
  Rule.rule

val padding4 : 
  top:Css_types.Length.t ->
  right:Css_types.Length.t ->
  bottom:Css_types.Length.t ->
  left:Css_types.Length.t ->
  Rule.rule

val paddingBottom : Css_types.Length.t -> Rule.rule

val paddingLeft : Css_types.Length.t -> Rule.rule

val paddingRight : Css_types.Length.t -> Rule.rule

val paddingTop : Css_types.Length.t -> Rule.rule

val perspective : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val perspectiveOrigin : 
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val perspectiveOrigin2 : 
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val pointerEvents : 
  [< `all
  | `auto
  | `fill
  | `inherit_
  | `initial
  | `none
  | `painted
  | `revert
  | `revertLayer
  | `stroke
  | `unset
  | `var of string
  | `varDefault of string * string
  | `visible
  | `visibleFill
  | `visiblePainted
  | `visibleStroke ] ->
  Rule.rule

val position : 
  [< `absolute
  | `fixed
  | `inherit_
  | `initial
  | `relative
  | `revert
  | `revertLayer
  | `static
  | `sticky
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val isolation : 
  [< `auto
  | `inherit_
  | `initial
  | `isolate
  | `revert
  | `revertLayer
  | `unset ] ->
  Rule.rule

val justifySelf : 
  [< `auto
  | `baseline
  | `center
  | `end_
  | `firstBaseline
  | `flexEnd
  | `flexStart
  | `inherit_
  | `initial
  | `lastBaseline
  | `left
  | `normal
  | `revert
  | `revertLayer
  | `right
  | `safe of Css_types.PositionalAlignment.t
  | `selfEnd
  | `selfStart
  | `start
  | `stretch
  | `unsafe of Css_types.PositionalAlignment.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val resize : 
  [< `block
  | `both
  | `horizontal
  | `inherit_
  | `initial
  | `inline
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vertical ] ->
  Rule.rule

val right : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val tableLayout : 
  [< `auto
  | `fixed
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textAlign : 
  [< `center
  | `end_
  | `inherit_
  | `initial
  | `justify
  | `justifyAll
  | `left
  | `matchParent
  | `revert
  | `revertLayer
  | `right
  | `start
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textAlignAll : 
  [< `center
  | `end_
  | `inherit_
  | `initial
  | `justify
  | `left
  | `matchParent
  | `revert
  | `revertLayer
  | `right
  | `start
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textAlignLast : 
  [< `auto
  | `center
  | `end_
  | `inherit_
  | `initial
  | `justify
  | `left
  | `matchParent
  | `revert
  | `revertLayer
  | `right
  | `start
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textDecorationColor : Css_types.Color.t -> Rule.rule

val textDecorationLine : 
  [< `blink
  | `inherit_
  | `initial
  | `lineThrough
  | `none
  | `overline
  | `revert
  | `revertLayer
  | `underline
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textDecorationStyle : [< Css_types.TextDecorationStyle.t ] -> Rule.rule

val textDecorationThickness : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fromFont
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val textDecorationSkipInk : [< Css_types.TextDecorationSkipInk.t ] -> Rule.rule

val textDecorationSkipBox : 
  [< `all
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textDecorationSkipInset : 
  [< `auto
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textIndent : Css_types.Length.t -> Rule.rule

val textOverflow : 
  [< `clip
  | `ellipsis
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `string of string
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textTransform : 
  [< `capitalize
  | `inherit_
  | `initial
  | `lowercase
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `uppercase
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val top : 
  [< `auto
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `right
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val transform : 
  [< `inherit_
  | `initial
  | `none
  | `perspective of int
  | `revert
  | `revertLayer
  | `rotate of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotate3d of
    float
    * float
    * float
    * [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotateX of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotateY of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotateZ of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `scale of float * float
  | `scale3d of float * float * float
  | `scaleX of float
  | `scaleY of float
  | `scaleZ of float
  | `skew of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
    * [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `skewX of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `skewY of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `translate of Css_types.Length.t * Css_types.Length.t
  | `translate3d of
    Css_types.Length.t * Css_types.Length.t * Css_types.Length.t
  | `translateX of Css_types.Length.t
  | `translateY of Css_types.Length.t
  | `translateZ of Css_types.Length.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val transforms : 
  [< `inherit_
  | `initial
  | `none
  | `perspective of int
  | `revert
  | `revertLayer
  | `rotate of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotate3d of
    float
    * float
    * float
    * [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotateX of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotateY of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `rotateZ of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `scale of float * float
  | `scale3d of float * float * float
  | `scaleX of float
  | `scaleY of float
  | `scaleZ of float
  | `skew of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
    * [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `skewX of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `skewY of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `translate of Css_types.Length.t * Css_types.Length.t
  | `translate3d of
    Css_types.Length.t * Css_types.Length.t * Css_types.Length.t
  | `translateX of Css_types.Length.t
  | `translateY of Css_types.Length.t
  | `translateZ of Css_types.Length.t
  | `unset
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val transformOrigin : 
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `right
  | `top
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val transformOrigin2 : 
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `right
  | `top
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `bottom
  | `calc of Css_types.Length.calc_value
  | `center
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `left
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `right
  | `top
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val transformOrigin3d : 
  Css_types.Length.t ->
  Css_types.Length.t ->
  Css_types.Length.t ->
  Rule.rule

val transformBox : 
  [< `borderBox
  | `contentBox
  | `fillBox
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `strokeBox
  | `unset
  | `var of string
  | `varDefault of string * string
  | `viewBox ] ->
  Rule.rule

val unsafe : string -> string -> Rule.rule

val userSelect : 
  [< `all
  | `auto
  | `contain
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `text
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val verticalAlign : 
  [< `baseline
  | `bottom
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `middle
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `sub
  | `super
  | `textBottom
  | `textTop
  | `top
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val visibility : 
  [< `collapse
  | `hidden
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `visible ] ->
  Rule.rule

val scrollBehavior : 
  [< `auto
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `smooth
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val overscrollBehavior : 
  [< `auto
  | `contain
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val overflowAnchor : 
  [< `auto | `inherit_ | `initial | `none | `revert | `revertLayer | `unset ] ->
  Rule.rule

val columnWidth : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val caretColor : 
  [< `auto
  | `colorMix of
    Css_types.Color.color_interpolation_method
    * (Css_types.Color.t * Css_types.Percentage.t option)
    * (Css_types.Color.t * Css_types.Percentage.t option)
  | `currentColor
  | `hex of string
  | `hsl of Css_types.Color.hsl
  | `hsla of Css_types.Color.hsla
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `rgb of Css_types.Color.rgb
  | `rgba of Css_types.Color.rgba
  | `transparent
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val width : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `inch of float
  | `inherit_
  | `initial
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val whiteSpace : 
  [< `breakSpaces
  | `inherit_
  | `initial
  | `normal
  | `nowrap
  | `pre
  | `preLine
  | `preWrap
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val wordBreak : 
  [< `breakAll
  | `inherit_
  | `initial
  | `keepAll
  | `normal
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val wordSpacing : [< Css_types.WordSpacing.t ] -> Rule.rule

val wordWrap : 
  [< `anywhere
  | `breakWord
  | `inherit_
  | `initial
  | `normal
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val zIndex : 
  [< `auto
  | `inherit_
  | `initial
  | `num of int
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val flex3 : 
  grow:float ->
  shrink:float ->
  basis:
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `content
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fill
    | `fitContent
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ] ->
  Rule.rule

val flexBasis : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `content
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fill
  | `fitContent
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val order : int -> Rule.rule

val string_of_minmax : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  string

val string_of_dimension : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  string

type minmax = [

| `fr of float
| `minContent
| `maxContent
| `auto
| Css_types.Length.t

]

type trackLength = [

| Css_types.Length.t
| `auto
| `fr of float
| `minContent
| `maxContent
| `minmax of minmax * minmax

]

type gridLength = [

| trackLength
| `repeat of Css_types.RepeatValue.t * trackLength array

]

val gridLengthToJs : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent of Css_types.Length.t
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `name of string
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `repeat of [< `autoFill | `autoFit | `num of int ] * 'a array
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] as 'a ->
  string

val string_of_dimensions : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent of Css_types.Length.t
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `name of string
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `repeat of [< `autoFill | `autoFit | `num of int ] * 'a
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ]
    array as 'a ->
  string

val gridTemplateColumns : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent of Css_types.Length.t
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `name of string
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `repeat of [< `autoFill | `autoFit | `num of int ] * 'a
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ]
    array as 'a ->
  Rule.rule

val gridTemplateRows : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent of Css_types.Length.t
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `name of string
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `repeat of [< `autoFill | `autoFit | `num of int ] * 'a
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ]
    array as 'a ->
  Rule.rule

val gridAutoColumns : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val gridAutoRows : 
  [< `auto
  | `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `fitContent
  | `fr of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `maxContent
  | `min of Css_types.Length.t array
  | `minContent
  | `minmax of
    [< `auto
    | `calc of Css_types.Length.calc_value
    | `ch of float
    | `cm of float
    | `cqb of float
    | `cqh of float
    | `cqi of float
    | `cqmax of float
    | `cqmin of float
    | `cqw of float
    | `em of float
    | `ex of float
    | `fr of float
    | `inch of float
    | `max of Css_types.Length.t array
    | `maxContent
    | `min of Css_types.Length.t array
    | `minContent
    | `mm of float
    | `pc of float
    | `percent of float
    | `pt of int
    | `px of int
    | `pxFloat of float
    | `rem of float
    | `vh of float
    | `vmax of float
    | `vmin of float
    | `vw of float
    | `zero ]
    * [< `auto
      | `calc of Css_types.Length.calc_value
      | `ch of float
      | `cm of float
      | `cqb of float
      | `cqh of float
      | `cqi of float
      | `cqmax of float
      | `cqmin of float
      | `cqw of float
      | `em of float
      | `ex of float
      | `fr of float
      | `inch of float
      | `max of Css_types.Length.t array
      | `maxContent
      | `min of Css_types.Length.t array
      | `minContent
      | `mm of float
      | `pc of float
      | `percent of float
      | `pt of int
      | `px of int
      | `pxFloat of float
      | `rem of float
      | `vh of float
      | `vmax of float
      | `vmin of float
      | `vw of float
      | `zero ]
  | `mm of float
  | `none
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `subgrid
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  Rule.rule

val gridArea : 
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val gridArea2 : 
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val gridArea3 : 
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val gridArea4 : 
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  [< `auto
  | `ident of string
  | `inherit_
  | `initial
  | `num of int
  | `numIdent of int * string
  | `revert
  | `revertLayer
  | `span of [< `ident of string | `num of int ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val gridTemplateAreas : 
  [< `areas of string array
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val filter : 
  [< `blur of Css_types.Length.t
  | `brightness of [< `num of float | `percent of float ]
  | `contrast of [< `num of float | `percent of float ]
  | `dropShadow of
    Css_types.Length.t
    * Css_types.Length.t
    * Css_types.Length.t
    * Css_types.Color.t
  | `grayscale of [< `num of float | `percent of float ]
  | `hueRotate of
    [< `deg of float | `grad of float | `rad of float | `turn of float ]
  | `inherit_
  | `initial
  | `invert of [< `num of float | `percent of float ]
  | `none
  | `opacity of [< `num of float | `percent of float ]
  | `revert
  | `revertLayer
  | `saturate of [< `num of float | `percent of float ]
  | `sepia of [< `num of float | `percent of float ]
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val boxShadow : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `shadow of string
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val boxShadows : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `shadow of string
  | `unset
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val border : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Css_types.Color.t ->
  Rule.rule

val borderStyle : 
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val borderLeft : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Css_types.Color.t ->
  Rule.rule

val borderLeftStyle : 
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val borderRight : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Css_types.Color.t ->
  Rule.rule

val borderRightStyle : 
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val borderTop : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Css_types.Color.t ->
  Rule.rule

val borderTopStyle : 
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val borderBottom : 
  [< `calc of Css_types.Length.calc_value
  | `ch of float
  | `cm of float
  | `cqb of float
  | `cqh of float
  | `cqi of float
  | `cqmax of float
  | `cqmin of float
  | `cqw of float
  | `em of float
  | `ex of float
  | `inch of float
  | `max of Css_types.Length.t array
  | `medium
  | `min of Css_types.Length.t array
  | `mm of float
  | `pc of float
  | `percent of float
  | `pt of int
  | `px of int
  | `pxFloat of float
  | `rem of float
  | `thick
  | `thin
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Css_types.Color.t ->
  Rule.rule

val borderBottomStyle : 
  [< `dashed
  | `dotted
  | `double
  | `groove
  | `hidden
  | `inherit_
  | `initial
  | `inset
  | `none
  | `outset
  | `revert
  | `revertLayer
  | `ridge
  | `solid
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val background : 
  [< `colorMix of
       Css_types.Color.color_interpolation_method
       * (Css_types.Color.t * Css_types.Percentage.t option)
       * (Css_types.Color.t * Css_types.Percentage.t option)
  | `conicGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `currentColor
  | `hex of string
  | `hsl of Css_types.Color.hsl
  | `hsla of Css_types.Color.hsla
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `rgb of Css_types.Color.rgb
  | `rgba of Css_types.Color.rgba
  | `transparent
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val backgrounds : 
  [< `colorMix of
       Css_types.Color.color_interpolation_method
       * (Css_types.Color.t * Css_types.Percentage.t option)
       * (Css_types.Color.t * Css_types.Percentage.t option)
  | `conicGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `currentColor
  | `hex of string
  | `hsl of Css_types.Color.hsl
  | `hsla of Css_types.Color.hsla
  | `inherit_
  | `initial
  | `linearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `none
  | `radialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `repeatingLinearGradient of
    Css_types.Gradient.direction option * Css_types.Gradient.color_stop_list
  | `repeatingRadialGradient of
    Css_types.Gradient.shape option
    * Css_types.Gradient.radial_size option
    * Css_types.Position.t option
    * Css_types.Gradient.color_stop_list
  | `revert
  | `revertLayer
  | `rgb of Css_types.Color.rgb
  | `rgba of Css_types.Color.rgba
  | `transparent
  | `unset
  | `url of string
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val backgroundSize : 
  [< `auto
  | `contain
  | `cover
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `size of Css_types.Length.t * Css_types.Length.t
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textDecoration : 
  [< `inherit_
  | `initial
  | `lineThrough
  | `none
  | `overline
  | `revert
  | `revertLayer
  | `underline
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textShadow : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `shadow of string
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textShadows : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `shadow of string
  | `unset
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val transformStyle : 
  [< `flat
  | `inherit_
  | `initial
  | `preserve3d
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val transitionList : 
  [< `none | `value of Css_types.Transition.transitionValue ] array ->
  Rule.rule

val transition : 
  ?duration:Css_types.Time.t ->
  ?delay:Css_types.Time.t ->
  ?timingFunction:Css_types.TimingFunction.t ->
  string ->
  Rule.rule

val transitionDelay : Css_types.Time.t -> Rule.rule

val transitionDuration : Css_types.Time.t -> Rule.rule

val transitionTimingFunction : 
  [< `cubicBezier of float * float * float * float
  | `ease
  | `easeIn
  | `easeInOut
  | `easeOut
  | `inherit_
  | `initial
  | `jumpBoth
  | `jumpEnd
  | `jumpNone
  | `jumpStart
  | `linear
  | `revert
  | `revertLayer
  | `stepEnd
  | `stepStart
  | `steps of int * [< `end_ | `start ]
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val transitionProperty : string -> Rule.rule

val animation : 
  ?duration:Css_types.Time.t ->
  ?delay:Css_types.Time.t ->
  ?direction:Css_types.AnimationDirection.t ->
  ?timingFunction:Css_types.TimingFunction.t ->
  ?fillMode:Css_types.AnimationFillMode.t ->
  ?playState:Css_types.AnimationPlayState.t ->
  ?iterationCount:Css_types.AnimationIterationCount.t ->
  ?name:Css_types.AnimationName.t ->
  unit ->
  Rule.rule

val animations : 
  [< `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `value of Css_types.Animation.animationValue
  | `var of string
  | `varDefault of string * string ]
    array ->
  Rule.rule

val animationName : Css_types.AnimationName.t -> Rule.rule

val animationNames : Css_types.AnimationName.t array -> Rule.rule

module SVG = Declarations.SVG

val touchAction : 
  [< `auto
  | `inherit_
  | `initial
  | `manipulation
  | `none
  | `panDown
  | `panLeft
  | `panRight
  | `panUp
  | `panX
  | `panY
  | `pinchZoom
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textEmphasisColor : Css_types.Color.t -> Rule.rule

val lineBreak : 
  [< `anywhere
  | `auto
  | `inherit_
  | `initial
  | `loose
  | `normal
  | `revert
  | `revertLayer
  | `strict
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val hyphens : 
  [< `auto
  | `inherit_
  | `initial
  | `manual
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val textJustify : 
  [< `auto
  | `inherit_
  | `initial
  | `interCharacter
  | `interWord
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val overflowInline : 
  [< `auto
  | `clip
  | `hidden
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `scroll
  | `unset
  | `var of string
  | `varDefault of string * string
  | `visible ] ->
  Rule.rule

val overflowBlock : 
  [< `auto
  | `clip
  | `hidden
  | `inherit_
  | `initial
  | `revert
  | `revertLayer
  | `scroll
  | `unset
  | `var of string
  | `varDefault of string * string
  | `visible ] ->
  Rule.rule

val fontSynthesisWeight : [< Css_types.FontSynthesisWeight.t ] -> Rule.rule

val fontSynthesisStyle : [< Css_types.FontSynthesisStyle.t ] -> Rule.rule

val fontSynthesisSmallCaps : 
  [< `auto
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontSynthesisPosition : 
  [< `auto
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontKerning : 
  [< `auto
  | `inherit_
  | `initial
  | `none
  | `normal
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontVariantPosition : 
  [< `inherit_
  | `initial
  | `normal
  | `revert
  | `revertLayer
  | `sub
  | `super
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontVariantCaps : 
  [< `allPetiteCaps
  | `allSmallCaps
  | `inherit_
  | `initial
  | `normal
  | `petiteCaps
  | `revert
  | `revertLayer
  | `smallCaps
  | `titlingCaps
  | `unicase
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontOpticalSizing : 
  [< `auto
  | `inherit_
  | `initial
  | `none
  | `revert
  | `revertLayer
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

val fontVariantEmoji : 
  [< `emoji
  | `inherit_
  | `initial
  | `normal
  | `revert
  | `revertLayer
  | `text
  | `unicode
  | `unset
  | `var of string
  | `varDefault of string * string ] ->
  Rule.rule

include module type of struct include Colors end

val aliceblue : Css_types.Color.t

val antiquewhite : Css_types.Color.t

val aqua : Css_types.Color.t

val aquamarine : Css_types.Color.t

val azure : Css_types.Color.t

val beige : Css_types.Color.t

val bisque : Css_types.Color.t

val black : Css_types.Color.t

val blanchedalmond : Css_types.Color.t

val blue : Css_types.Color.t

val blueviolet : Css_types.Color.t

val brown : Css_types.Color.t

val burlywood : Css_types.Color.t

val cadetblue : Css_types.Color.t

val chartreuse : Css_types.Color.t

val chocolate : Css_types.Color.t

val coral : Css_types.Color.t

val cornflowerblue : Css_types.Color.t

val cornsilk : Css_types.Color.t

val crimson : Css_types.Color.t

val cyan : Css_types.Color.t

val darkblue : Css_types.Color.t

val darkcyan : Css_types.Color.t

val darkgoldenrod : Css_types.Color.t

val darkgray : Css_types.Color.t

val darkgreen : Css_types.Color.t

val darkgrey : Css_types.Color.t

val darkkhaki : Css_types.Color.t

val darkmagenta : Css_types.Color.t

val darkolivegreen : Css_types.Color.t

val darkorange : Css_types.Color.t

val darkorchid : Css_types.Color.t

val darkred : Css_types.Color.t

val darksalmon : Css_types.Color.t

val darkseagreen : Css_types.Color.t

val darkslateblue : Css_types.Color.t

val darkslategray : Css_types.Color.t

val darkslategrey : Css_types.Color.t

val darkturquoise : Css_types.Color.t

val darkviolet : Css_types.Color.t

val deeppink : Css_types.Color.t

val deepskyblue : Css_types.Color.t

val dimgray : Css_types.Color.t

val dimgrey : Css_types.Color.t

val dodgerblue : Css_types.Color.t

val firebrick : Css_types.Color.t

val floralwhite : Css_types.Color.t

val forestgreen : Css_types.Color.t

val fuchsia : Css_types.Color.t

val gainsboro : Css_types.Color.t

val ghostwhite : Css_types.Color.t

val gold : Css_types.Color.t

val goldenrod : Css_types.Color.t

val gray : Css_types.Color.t

val green : Css_types.Color.t

val greenyellow : Css_types.Color.t

val grey : Css_types.Color.t

val honeydew : Css_types.Color.t

val hotpink : Css_types.Color.t

val indianred : Css_types.Color.t

val indigo : Css_types.Color.t

val ivory : Css_types.Color.t

val khaki : Css_types.Color.t

val lavender : Css_types.Color.t

val lavenderblush : Css_types.Color.t

val lawngreen : Css_types.Color.t

val lemonchiffon : Css_types.Color.t

val lightblue : Css_types.Color.t

val lightcoral : Css_types.Color.t

val lightcyan : Css_types.Color.t

val lightgoldenrodyellow : Css_types.Color.t

val lightgray : Css_types.Color.t

val lightgreen : Css_types.Color.t

val lightgrey : Css_types.Color.t

val lightpink : Css_types.Color.t

val lightsalmon : Css_types.Color.t

val lightseagreen : Css_types.Color.t

val lightskyblue : Css_types.Color.t

val lightslategray : Css_types.Color.t

val lightslategrey : Css_types.Color.t

val lightsteelblue : Css_types.Color.t

val lightyellow : Css_types.Color.t

val lime : Css_types.Color.t

val limegreen : Css_types.Color.t

val linen : Css_types.Color.t

val magenta : Css_types.Color.t

val maroon : Css_types.Color.t

val mediumaquamarine : Css_types.Color.t

val mediumblue : Css_types.Color.t

val mediumorchid : Css_types.Color.t

val mediumpurple : Css_types.Color.t

val mediumseagreen : Css_types.Color.t

val mediumslateblue : Css_types.Color.t

val mediumspringgreen : Css_types.Color.t

val mediumturquoise : Css_types.Color.t

val mediumvioletred : Css_types.Color.t

val midnightblue : Css_types.Color.t

val mintcream : Css_types.Color.t

val mistyrose : Css_types.Color.t

val moccasin : Css_types.Color.t

val navajowhite : Css_types.Color.t

val navy : Css_types.Color.t

val oldlace : Css_types.Color.t

val olive : Css_types.Color.t

val olivedrab : Css_types.Color.t

val orange : Css_types.Color.t

val orangered : Css_types.Color.t

val orchid : Css_types.Color.t

val palegoldenrod : Css_types.Color.t

val palegreen : Css_types.Color.t

val paleturquoise : Css_types.Color.t

val palevioletred : Css_types.Color.t

val papayawhip : Css_types.Color.t

val peachpuff : Css_types.Color.t

val peru : Css_types.Color.t

val pink : Css_types.Color.t

val plum : Css_types.Color.t

val powderblue : Css_types.Color.t

val purple : Css_types.Color.t

val rebeccapurple : Css_types.Color.t

val red : Css_types.Color.t

val rosybrown : Css_types.Color.t

val royalblue : Css_types.Color.t

val saddlebrown : Css_types.Color.t

val salmon : Css_types.Color.t

val sandybrown : Css_types.Color.t

val seagreen : Css_types.Color.t

val seashell : Css_types.Color.t

val sienna : Css_types.Color.t

val silver : Css_types.Color.t

val skyblue : Css_types.Color.t

val slateblue : Css_types.Color.t

val slategray : Css_types.Color.t

val slategrey : Css_types.Color.t

val snow : Css_types.Color.t

val springgreen : Css_types.Color.t

val steelblue : Css_types.Color.t

val tan : Css_types.Color.t

val teal : Css_types.Color.t

val thistle : Css_types.Color.t

val tomato : Css_types.Color.t

val turquoise : Css_types.Color.t

val violet : Css_types.Color.t

val wheat : Css_types.Color.t

val white : Css_types.Color.t

val whitesmoke : Css_types.Color.t

val yellow : Css_types.Color.t

val yellowgreen : Css_types.Color.t

include module type of struct include Alias end

val initial : Css_types.Cascading.t

val inherit_ : Css_types.Cascading.t

val unset : Css_types.Cascading.t

val var : ?default:string -> string -> Css_types.Var.t

val auto : [> `auto ]

val none : [> `none ]

val text : [> `text ]

val pct : float -> Css_types.Percentage.t

val ch : float -> Css_types.Length.t

val cm : float -> Css_types.Length.t

val em : float -> Css_types.Length.t

val ex : float -> Css_types.Length.t

val mm : float -> Css_types.Length.t

val pt : int -> Css_types.Length.t

val px : int -> Css_types.Length.t

val pxFloat : float -> Css_types.Length.t

val rem : float -> Css_types.Length.t

val vh : float -> Css_types.Length.t

val vmin : float -> Css_types.Length.t

val vmax : float -> Css_types.Length.t

val zero : Css_types.Length.t

val deg : float -> Css_types.Angle.t

val rad : float -> Css_types.Angle.t

val grad : float -> Css_types.Angle.t

val turn : float -> Css_types.Angle.t

val ltr : Css_types.Direction.t

val rtl : Css_types.Direction.t

val absolute : [> `absolute ]

val relative : [> `relative ]

val static : [> `static ]

val fixed : [> `fixed ]

val sticky : [> `sticky ]

val isolate : [> `isolate ]

val horizontal : [> `horizontal ]

val vertical : [> `vertical ]

val smallCaps : [> `smallCaps ]

val italic : [> `italic ]

val oblique : [> `oblique ]

val hidden : [> `hidden ]

val visible : [> `visible ]

val scroll : [> `scroll ]

val rgb : 'a -> 'b -> 'c -> [> `rgb of 'a * 'b * 'c ]

val rgba : 'a -> 'b -> 'c -> 'd -> [> `rgba of 'a * 'b * 'c * 'd ]

val hsl : 'a -> 'b -> 'c -> [> `hsl of 'a * 'b * 'c ]

val hsla : 'a -> 'b -> 'c -> 'd -> [> `hsla of 'a * 'b * 'c * 'd ]

val hex : 'a -> [> `hex of 'a ]

val currentColor : [> `currentColor ]

val transparent : [> `transparent ]

val linear : [> `linear ]

val ease : [> `ease ]

val easeIn : [> `easeIn ]

val easeInOut : [> `easeInOut ]

val easeOut : [> `easeOut ]

val stepStart : [> `stepStart ]

val stepEnd : [> `stepEnd ]

val steps : 'a -> 'b -> [> `steps of 'a * 'b ]

val cubicBezier : 
  'a ->
  'b ->
  'c ->
  'd ->
  [> `cubicBezier of 'a * 'b * 'c * 'd ]

val marginBox : [> `marginBox ]

val fillBox : [> `fillBox ]

val strokeBox : [> `strokeBox ]

val viewBox : [> `viewBox ]

val translate : 'a -> 'b -> [> `translate of 'a * 'b ]

val translate3d : 'a -> 'b -> 'c -> [> `translate3d of 'a * 'b * 'c ]

val translateX : 'a -> [> `translateX of 'a ]

val translateY : 'a -> [> `translateY of 'a ]

val translateZ : 'a -> [> `translateZ of 'a ]

val scaleX : 'a -> [> `scaleX of 'a ]

val scaleY : 'a -> [> `scaleY of 'a ]

val scaleZ : 'a -> [> `scaleZ of 'a ]

val rotateX : 'a -> [> `rotateX of 'a ]

val rotateY : 'a -> [> `rotateY of 'a ]

val rotateZ : 'a -> [> `rotateZ of 'a ]

val scale : 'a -> 'b -> [> `scale of 'a * 'b ]

val scale3d : 'a -> 'b -> 'c -> [> `scale3d of 'a * 'b * 'c ]

val skew : 'a -> 'b -> [> `skew of 'a * 'b ]

val skewX : 'a -> [> `skewX of 'a ]

val skewY : 'a -> [> `skewY of 'a ]

val thin : [> `thin ]

val extraLight : [> `extraLight ]

val light : [> `light ]

val medium : [> `medium ]

val semiBold : [> `semiBold ]

val bold : [> `bold ]

val extraBold : [> `extraBold ]

val lighter : [> `lighter ]

val bolder : [> `bolder ]

val linearGradient : 'a -> 'b -> [> `linearGradient of 'a option * 'b ]

val repeatingLinearGradient : 
  'a ->
  'b ->
  [> `repeatingLinearGradient of 'a option * 'b ]

val radialGradient : 
  Css_types.Gradient.shape ->
  Css_types.Gradient.radial_size ->
  Css_types.Position.t ->
  Css_types.Gradient.color_stop_list ->
  [> `radialGradient of
       Css_types.Gradient.shape option
       * Css_types.Gradient.radial_size option
       * Css_types.Position.t option
       * Css_types.Gradient.color_stop_list ]

val repeatingRadialGradient : 
  Css_types.Gradient.shape ->
  Css_types.Gradient.radial_size ->
  Css_types.Position.t ->
  Css_types.Gradient.color_stop_list ->
  [> `repeatingRadialGradient of
       Css_types.Gradient.shape option
       * Css_types.Gradient.radial_size option
       * Css_types.Position.t option
       * Css_types.Gradient.color_stop_list ]

val conicGradient : 'a -> 'b -> [> `conicGradient of 'a option * 'b ]

val areas : 'a -> [> `areas of 'a ]

val ident : 'a -> [> `ident of 'a ]

val numIdent : 'a -> 'b -> [> `numIdent of 'a * 'b ]

val contextMenu : [> `contextMenu ]

val help : [> `help ]

val pointer : [> `pointer ]

val progress : [> `progress ]

val wait : [> `wait ]

val cell : [> `cell ]

val crosshair : [> `crosshair ]

val verticalText : [> `verticalText ]

val alias : [> `alias ]

val copy : [> `copy ]

val move : [> `move ]

val noDrop : [> `noDrop ]

val notAllowed : [> `notAllowed ]

val grab : [> `grab ]

val grabbing : [> `grabbing ]

val allScroll : [> `allScroll ]

val colResize : [> `colResize ]

val rowResize : [> `rowResize ]

val nResize : [> `nResize ]

val eResize : [> `eResize ]

val sResize : [> `sResize ]

val wResize : [> `wResize ]

val neResize : [> `neResize ]

val nwResize : [> `nwResize ]

val seResize : [> `seResize ]

val swResize : [> `swResize ]

val ewResize : [> `ewResize ]

val nsResize : [> `nsResize ]

val neswResize : [> `neswResize ]

val nwseResize : [> `nwseResize ]

val zoomIn : [> `zoomIn ]

val zoomOut : [> `zoomOut ]

val vw : 'a -> [> `vw of 'a ]

val fr : 'a -> [> `fr of 'a ]

module Calc = Alias.Calc

val size : 'a -> 'b -> [> `size of 'a * 'b ]

val all : [> `all ]

val backwards : [> `backwards ]

val baseline : [> `baseline ]

val block : [> `block ]

val borderBox : [> `borderBox ]

val both : [> `both ]

val center : [> `center ]

val column : [> `column ]

val columnReverse : [> `columnReverse ]

val contain : [> `contain ]

val contentBox : [> `contentBox ]

val count : 'a -> [> `count of 'a ]

val cover : [> `cover ]

val dashed : [> `dashed ]

val dotted : [> `dotted ]

val flexBox : [> `flex ]

val grid : [> `grid ]

val inlineGrid : [> `inlineGrid ]

val flexEnd : [> `flexEnd ]

val flexStart : [> `flexStart ]

val forwards : [> `forwards ]

val infinite : [> `infinite ]

val inline : [> `inline ]

val contents : [> `contents ]

val inlineBlock : [> `inlineBlock ]

val inlineFlex : [> `inlineFlex ]

val inlineTable : [> `inlineTable ]

val listItem : [> `listItem ]

val runIn : [> `runIn ]

val table : [> `table ]

val tableCaption : [> `tableCaption ]

val tableColumnGroup : [> `tableColumnGroup ]

val tableHeaderGroup : [> `tableHeaderGroup ]

val tableFooterGroup : [> `tableFooterGroup ]

val tableRowGroup : [> `tableRowGroup ]

val tableCell : [> `tableCell ]

val tableColumn : [> `tableColumn ]

val tableRow : [> `tableRow ]

val local : [> `local ]

val localUrl : 'a -> [> `localUrl of 'a ]

val noRepeat : [> `noRepeat ]

val space : [> `space ]

val nowrap : [> `nowrap ]

val paddingBox : [> `paddingBox ]

val paused : [> `paused ]

val repeat : [> `repeat ]

val minmax : [> `minmax ]

val repeatX : [> `repeatX ]

val repeatY : [> `repeatY ]

val rotate : 'a -> [> `rotate of 'a ]

val rotate3d : 'a -> 'b -> 'c -> 'd -> [> `rotate3d of 'a * 'b * 'c * 'd ]

val row : [> `row ]

val rowReverse : [> `rowReverse ]

val running : [> `running ]

val solid : [> `solid ]

val spaceAround : [> `spaceAround ]

val spaceBetween : [> `spaceBetween ]

val spaceEvenly : [> `spaceEvenly ]

val stretch : [> `stretch ]

val url : 'a -> [> `url of 'a ]

val wrap : [> `wrap ]

val wrapReverse : [> `wrapReverse ]

val inside : [> `inside ]

val outside : [> `outside ]

val underline : [> `underline ]

val overline : [> `overline ]

val lineThrough : [> `lineThrough ]

val clip : [> `clip ]

val ellipsis : [> `ellipsis ]

val wavy : [> `wavy ]

val double : [> `double ]

val uppercase : [> `uppercase ]

val lowercase : [> `lowercase ]

val capitalize : [> `capitalize ]

val sub : [> `sub ]

val super : [> `super ]

val textTop : [> `textTop ]

val textBottom : [> `textBottom ]

val middle : [> `middle ]

val normal : [> `normal ]

val breakAll : [> `breakAll ]

val keepAll : [> `keepAll ]

val breakWord : [> `breakWord ]

val reverse : [> `reverse ]

val alternate : [> `alternate ]

val alternateReverse : [> `alternateReverse ]

val fill : [> `fill ]

val maxContent : [> `maxContent ]

val minContent : [> `minContent ]

val fitContent : [> `fitContent ]

val round : [> `round ]

val miter : [> `miter ]

val bevel : [> `bevel ]

val butt : [> `butt ]

val square : [> `square ]

val panX : [> `panX ]

val panY : [> `panY ]

val panLeft : [> `panLeft ]

val panRight : [> `panRight ]

val panUp : [> `panUp ]

val panDown : [> `panDown ]

val pinchZoom : [> `pinchZoom ]

val manipulation : [> `manipulation ]

module Shadow = Alias.Shadow

module Animation = Alias.Animation

module Transition = Alias.Transition

type animationName = Css_types.AnimationName.t

type angle = Css_types.Angle.t

type animationDirection = Css_types.AnimationDirection.t

type animationFillMode = Css_types.AnimationFillMode.t

type animationIterationCount = Css_types.AnimationIterationCount.t

type animationPlayState = Css_types.AnimationPlayState.t

type cascading = Css_types.Cascading.t

type color = Css_types.Color.t

type fontStyle = Css_types.FontStyle.t

type fontWeight = Css_types.FontWeight.t

type length = Css_types.Length.t

type listStyleType = Css_types.ListStyleType.t

type repeatValue = Css_types.RepeatValue.t

type outlineStyle = Css_types.OutlineStyle.t

type transform = Css_types.Transform.t

type gradient = Css_types.Gradient.t

include module type of struct include Rule end

type rule = Rule.rule =

| Declaration of string * string
| Selector of string * rule array

val declaration : (string * string) -> rule

val selector : string -> rule array -> rule

val media : string -> rule array -> rule

val important : rule -> rule

val ruleToDict : Js.Json.t Js.Dict.t -> rule -> Js.Json.t Js.Dict.t

val toJson : rule array -> Js.Json.t

include module type of struct include Emotion_bindings end

type styleEncoding = Emotion_bindings.styleEncoding

type renderer = Js.Json.t

val injectRaw : string -> unit

val renderRaw : 'a -> string -> unit

val injectRawRules : Js.Json.t -> unit

val injectRules : Js.Json.t -> unit

val renderRules : 'a -> Js.Dict.key -> Js.Json.t -> unit

val mergeStyles : styleEncoding array -> styleEncoding

val make : Js.Json.t -> string

val makeAnimation : Js.Json.t Js.Dict.t -> string

val makeKeyframes : Js.Json.t Js.Dict.t -> string

val insertRule : string -> unit

val renderRule : 'a -> string -> unit

val global : Rule.rule array -> unit

val renderGlobal : 'a -> Js.Dict.key -> Rule.rule array -> unit

val style : Rule.rule array -> string

val merge : styleEncoding array -> styleEncoding

val merge2 : styleEncoding -> styleEncoding -> styleEncoding

val merge3 : styleEncoding -> styleEncoding -> styleEncoding -> styleEncoding

val merge4 : 
  styleEncoding ->
  styleEncoding ->
  styleEncoding ->
  styleEncoding ->
  styleEncoding

val framesToDict : (int * Rule.rule array) array -> Js.Json.t Js.Dict.t

val keyframes : (int * Rule.rule array) array -> Css_types.AnimationName.t

val renderKeyframes : 'a -> (int * Rule.rule array) array -> string

val fontFace : 
  fontFamily:string ->
  src:[< `local of string | `url of string ] array ->
  ?fontStyle:
    [< `inherit_
    | `initial
    | `italic
    | `normal
    | `oblique
    | `revert
    | `revertLayer
    | `unset
    | `var of string
    | `varDefault of string * string ] ->
  ?fontWeight:
    [< `black
    | `bold
    | `bolder
    | `extraBold
    | `extraLight
    | `inherit_
    | `initial
    | `light
    | `lighter
    | `medium
    | `normal
    | `num of int
    | `revert
    | `revertLayer
    | `semiBold
    | `thin
    | `unset
    | `var of string
    | `varDefault of string * string ] ->
  ?fontDisplay:
    [< `auto
    | `block
    | `fallback
    | `inherit_
    | `initial
    | `optional
    | `revert
    | `revertLayer
    | `swap
    | `unset
    | `var of string
    | `varDefault of string * string ] ->
  ?sizeAdjust:[< `percent of float ] ->
  unit ->
  string

module Types = Css_types