Module `Alias`

val initial : [> `initial ]

val inherit_ : [> `inherit_ ]

val unset : [> `unset ]

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

val auto : [> `auto ]

val none : [> `none ]

val text : [> `text ]

val pct : float -> [> `percent of float ]

val num : float -> [> `num of float ]

val ch : float -> [> `ch of float ]

val cm : float -> [> `cm of float ]

val em : float -> [> `em of float ]

val ex : float -> [> `ex of float ]

val mm : float -> [> `mm of float ]

val pt : int -> [> `pt of int ]

val px : int -> [> `px of int ]

val pxFloat : float -> [> `pxFloat of float ]

val rem : float -> [> `rem of float ]

val vh : float -> [> `vh of float ]

val vw : float -> [> `vw of float ]

val vmin : float -> [> `vmin of float ]

val vmax : float -> [> `vmax of float ]

val zero : [> `zero ]

val fr : float -> [> `fr of float ]

val deg : float -> [> `deg of float ]

val rad : float -> [> `rad of float ]

val grad : float -> [> `grad of float ]

val turn : float -> [> `turn of float ]

val ltr : [> `ltr ]

val rtl : [> `rtl ]

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 : int -> int -> int -> [> `rgb of int * int * int ]

val rgba : 
  int ->
  int ->
  int ->
  Css_types.Color.alpha_with_calc ->
  [> `rgba of int * int * int * Css_types.Color.alpha_with_calc ]

val hsl : 
  Css_types.Color.angle_with_calc ->
  Css_types.Color.percent_with_calc ->
  Css_types.Color.percent_with_calc ->
  [> `hsl of
       Css_types.Color.angle_with_calc
       * Css_types.Color.percent_with_calc
       * Css_types.Color.percent_with_calc ]

val hsla : 
  Css_types.Color.angle_with_calc ->
  Css_types.Color.percent_with_calc ->
  Css_types.Color.percent_with_calc ->
  Css_types.Color.angle_with_calc ->
  [> `hsla of
       Css_types.Color.angle_with_calc
       * Css_types.Color.percent_with_calc
       * Css_types.Color.percent_with_calc
       * Css_types.Color.angle_with_calc ]

val hex : string -> [> `hex of string ]

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 : 
  int ->
  [ `end_ | `start ] ->
  [> `steps of int * [ `end_ | `start ] ]

val cubicBezier : 
  float ->
  float ->
  float ->
  float ->
  [> `cubicBezier of float * float * float * float ]

val marginBox : [> `marginBox ]

val fillBox : [> `fillBox ]

val strokeBox : [> `strokeBox ]

val viewBox : [> `viewBox ]

val translate : 
  Css_types.Length.t ->
  Css_types.Length.t ->
  [> `translate of Css_types.Length.t * Css_types.Length.t ]

val translate3d : 
  Css_types.Length.t ->
  Css_types.Length.t ->
  Css_types.Length.t ->
  [> `translate3d of
       Css_types.Length.t * Css_types.Length.t * Css_types.Length.t ]

val translateX : Css_types.Length.t -> [> `translateX of Css_types.Length.t ]

val translateY : Css_types.Length.t -> [> `translateY of Css_types.Length.t ]

val translateZ : Css_types.Length.t -> [> `translateZ of Css_types.Length.t ]

val scaleX : float -> [> `scaleX of float ]

val scaleY : float -> [> `scaleY of float ]

val scaleZ : float -> [> `scaleZ of float ]

val rotateX : Css_types.Angle.t -> [> `rotateX of Css_types.Angle.t ]

val rotateY : Css_types.Angle.t -> [> `rotateY of Css_types.Angle.t ]

val rotateZ : Css_types.Angle.t -> [> `rotateZ of Css_types.Angle.t ]

val scale : float -> float -> [> `scale of float * float ]

val scale3d : float -> float -> float -> [> `scale3d of float * float * float ]

val skew : 
  Css_types.Angle.t ->
  float ->
  [> `skew of Css_types.Angle.t * float ]

val skewX : Css_types.Angle.t -> [> `skewX of Css_types.Angle.t ]

val skewY : Css_types.Angle.t -> [> `skewY of Css_types.Angle.t ]

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 : 
  Css_types.Gradient.direction option ->
  Css_types.Gradient.color_stop_list ->
  [> `linearGradient of
       Css_types.Gradient.direction option option
       * Css_types.Gradient.color_stop_list ]

val repeatingLinearGradient : 
  Css_types.Gradient.direction option ->
  Css_types.Gradient.color_stop_list ->
  [> `repeatingLinearGradient of
       Css_types.Gradient.direction option option
       * Css_types.Gradient.color_stop_list ]

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 : 
  Css_types.Gradient.direction option ->
  Css_types.Gradient.color_stop_list ->
  [> `conicGradient of
       Css_types.Gradient.direction option option
       * Css_types.Gradient.color_stop_list ]

val area : string -> [> `area of string ]

val areas : string array -> [> `areas of string array ]

val trackSizes : 
  Css_types.TrackSize.t array ->
  [> `trackSizes of Css_types.TrackSize.t array ]

val tracks : Css_types.Track.t array -> [> `tracks of Css_types.Track.t array ]

val numInt : int -> [> `num of int ]

val ident : string -> [> `ident of string ]

val numIdent : int -> string -> [> `numIdent of int * string ]

val span : 
  [ `ident of string | `num of int | `numIdent of int * string ] ->
  [> `span of [ `ident of string | `num of int | `numIdent of int * string ] ]

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 ]

module Calc : sig ... end

val size : 
  [ `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
  | `var of string
  | `varDefault of string * string
  | `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
  | `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
  | `var of string
  | `varDefault of string * string
  | `vh of float
  | `vmax of float
  | `vmin of float
  | `vw of float
  | `zero ] ->
  [> `size 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
       | `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
       | `var of string
       | `varDefault of string * string
       | `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
         | `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
         | `var of string
         | `varDefault of string * string
         | `vh of float
         | `vmax of float
         | `vmin of float
         | `vw of float
         | `zero ] ]

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 repeatFn : 
  Css_types.RepeatValue.t ->
  Css_types.RepeatTrack.t array ->
  [> `repeat of Css_types.RepeatValue.t * Css_types.RepeatTrack.t array ]

val repeat : [> `repeat ]

val minmax : 
  Css_types.InflexibleBreadth.t ->
  Css_types.TrackBreadth.t ->
  [> `minmax of Css_types.InflexibleBreadth.t * Css_types.TrackBreadth.t ]

val repeatX : [> `repeatX ]

val repeatY : [> `repeatY ]

val rotate : Css_types.Angle.t -> [> `rotate of Css_types.Angle.t ]

val rotate3d : 
  float ->
  float ->
  float ->
  Css_types.Angle.t ->
  [> `rotate3d of float * float * float * Css_types.Angle.t ]

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 : string -> [> `url of string ]

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 fitContentFn : Css_types.Length.t -> [> `fitContent of Css_types.Length.t ]

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 ]

val subgrid : [> `subgrid ]

val lineNames : string -> [> `lineNames of string ]

module Shadow : sig ... end

module Animation : sig ... end

module Transition : sig ... end

type animationName = Css_types.AnimationName.t

type angle = Css_types.Angle.t

type animationDirection = Css_types.AnimationDirection.Value.t

type animationFillMode = Css_types.AnimationFillMode.Value.t

type animationIterationCount = Css_types.AnimationIterationCount.Value.t

type animationPlayState = Css_types.AnimationPlayState.Value.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

package styled-ppx

Module Alias

Module `Alias`