module Data.DOM.CSS2Properties
       (set'azimuth, get'azimuth, getm'azimuth, set'background,
        get'background, getm'background, set'backgroundAttachment,
        get'backgroundAttachment, getm'backgroundAttachment,
        set'backgroundColor, get'backgroundColor, getm'backgroundColor,
        set'backgroundImage, get'backgroundImage, getm'backgroundImage,
        set'backgroundPosition, get'backgroundPosition,
        getm'backgroundPosition, set'backgroundRepeat,
        get'backgroundRepeat, getm'backgroundRepeat, set'border,
        get'border, getm'border, set'borderCollapse, get'borderCollapse,
        getm'borderCollapse, set'borderColor, get'borderColor,
        getm'borderColor, set'borderSpacing, get'borderSpacing,
        getm'borderSpacing, set'borderStyle, get'borderStyle,
        getm'borderStyle, set'borderTop, get'borderTop, getm'borderTop,
        set'borderRight, get'borderRight, getm'borderRight,
        set'borderBottom, get'borderBottom, getm'borderBottom,
        set'borderLeft, get'borderLeft, getm'borderLeft,
        set'borderTopColor, get'borderTopColor, getm'borderTopColor,
        set'borderRightColor, get'borderRightColor, getm'borderRightColor,
        set'borderBottomColor, get'borderBottomColor,
        getm'borderBottomColor, set'borderLeftColor, get'borderLeftColor,
        getm'borderLeftColor, set'borderTopStyle, get'borderTopStyle,
        getm'borderTopStyle, set'borderRightStyle, get'borderRightStyle,
        getm'borderRightStyle, set'borderBottomStyle,
        get'borderBottomStyle, getm'borderBottomStyle, set'borderLeftStyle,
        get'borderLeftStyle, getm'borderLeftStyle, set'borderTopWidth,
        get'borderTopWidth, getm'borderTopWidth, set'borderRightWidth,
        get'borderRightWidth, getm'borderRightWidth, set'borderBottomWidth,
        get'borderBottomWidth, getm'borderBottomWidth, set'borderLeftWidth,
        get'borderLeftWidth, getm'borderLeftWidth, set'borderWidth,
        get'borderWidth, getm'borderWidth, set'bottom, get'bottom,
        getm'bottom, set'captionSide, get'captionSide, getm'captionSide,
        set'clear, get'clear, getm'clear, set'clip, get'clip, getm'clip,
        set'color, get'color, getm'color, set'content, get'content,
        getm'content, set'counterIncrement, get'counterIncrement,
        getm'counterIncrement, set'counterReset, get'counterReset,
        getm'counterReset, set'cue, get'cue, getm'cue, set'cueAfter,
        get'cueAfter, getm'cueAfter, set'cueBefore, get'cueBefore,
        getm'cueBefore, set'cursor, get'cursor, getm'cursor, set'direction,
        get'direction, getm'direction, set'display, get'display,
        getm'display, set'elevation, get'elevation, getm'elevation,
        set'emptyCells, get'emptyCells, getm'emptyCells, set'cssFloat,
        get'cssFloat, getm'cssFloat, set'font, get'font, getm'font,
        set'fontFamily, get'fontFamily, getm'fontFamily, set'fontSize,
        get'fontSize, getm'fontSize, set'fontSizeAdjust,
        get'fontSizeAdjust, getm'fontSizeAdjust, set'fontStretch,
        get'fontStretch, getm'fontStretch, set'fontStyle, get'fontStyle,
        getm'fontStyle, set'fontVariant, get'fontVariant, getm'fontVariant,
        set'fontWeight, get'fontWeight, getm'fontWeight, set'height,
        get'height, getm'height, set'left, get'left, getm'left,
        set'letterSpacing, get'letterSpacing, getm'letterSpacing,
        set'lineHeight, get'lineHeight, getm'lineHeight, set'listStyle,
        get'listStyle, getm'listStyle, set'listStyleImage,
        get'listStyleImage, getm'listStyleImage, set'listStylePosition,
        get'listStylePosition, getm'listStylePosition, set'listStyleType,
        get'listStyleType, getm'listStyleType, set'margin, get'margin,
        getm'margin, set'marginTop, get'marginTop, getm'marginTop,
        set'marginRight, get'marginRight, getm'marginRight,
        set'marginBottom, get'marginBottom, getm'marginBottom,
        set'marginLeft, get'marginLeft, getm'marginLeft, set'markerOffset,
        get'markerOffset, getm'markerOffset, set'marks, get'marks,
        getm'marks, set'maxHeight, get'maxHeight, getm'maxHeight,
        set'maxWidth, get'maxWidth, getm'maxWidth, set'minHeight,
        get'minHeight, getm'minHeight, set'minWidth, get'minWidth,
        getm'minWidth, set'orphans, get'orphans, getm'orphans, set'outline,
        get'outline, getm'outline, set'outlineColor, get'outlineColor,
        getm'outlineColor, set'outlineStyle, get'outlineStyle,
        getm'outlineStyle, set'outlineWidth, get'outlineWidth,
        getm'outlineWidth, set'overflow, get'overflow, getm'overflow,
        set'padding, get'padding, getm'padding, set'paddingTop,
        get'paddingTop, getm'paddingTop, set'paddingRight,
        get'paddingRight, getm'paddingRight, set'paddingBottom,
        get'paddingBottom, getm'paddingBottom, set'paddingLeft,
        get'paddingLeft, getm'paddingLeft, set'page, get'page, getm'page,
        set'pageBreakAfter, get'pageBreakAfter, getm'pageBreakAfter,
        set'pageBreakBefore, get'pageBreakBefore, getm'pageBreakBefore,
        set'pageBreakInside, get'pageBreakInside, getm'pageBreakInside,
        set'pause, get'pause, getm'pause, set'pauseAfter, get'pauseAfter,
        getm'pauseAfter, set'pauseBefore, get'pauseBefore,
        getm'pauseBefore, set'pitch, get'pitch, getm'pitch, set'pitchRange,
        get'pitchRange, getm'pitchRange, set'playDuring, get'playDuring,
        getm'playDuring, set'position, get'position, getm'position,
        set'quotes, get'quotes, getm'quotes, set'richness, get'richness,
        getm'richness, set'right, get'right, getm'right, set'size,
        get'size, getm'size, set'speak, get'speak, getm'speak,
        set'speakHeader, get'speakHeader, getm'speakHeader,
        set'speakNumeral, get'speakNumeral, getm'speakNumeral,
        set'speakPunctuation, get'speakPunctuation, getm'speakPunctuation,
        set'speechRate, get'speechRate, getm'speechRate, set'stress,
        get'stress, getm'stress, set'tableLayout, get'tableLayout,
        getm'tableLayout, set'textAlign, get'textAlign, getm'textAlign,
        set'textDecoration, get'textDecoration, getm'textDecoration,
        set'textIndent, get'textIndent, getm'textIndent, set'textShadow,
        get'textShadow, getm'textShadow, set'textTransform,
        get'textTransform, getm'textTransform, set'top, get'top, getm'top,
        set'unicodeBidi, get'unicodeBidi, getm'unicodeBidi,
        set'verticalAlign, get'verticalAlign, getm'verticalAlign,
        set'visibility, get'visibility, getm'visibility, set'voiceFamily,
        get'voiceFamily, getm'voiceFamily, set'volume, get'volume,
        getm'volume, set'whiteSpace, get'whiteSpace, getm'whiteSpace,
        set'widows, get'widows, getm'widows, set'width, get'width,
        getm'width, set'wordSpacing, get'wordSpacing, getm'wordSpacing,
        set'zIndex, get'zIndex, getm'zIndex)
       where
import Data.DOM.Css
import Control.Monad
import BrownPLT.JavaScript
import Data.DOM.WBTypes
import Data.DOM.Views
import Data.DOM.Stylesheets
import Data.DOM.Dom
import Data.DOM.Document (createElement)
 
set'azimuth ::
            (Monad mn, CCSS2Properties zz) =>
              Expression String -> Expression zz -> mn (Expression zz)
set'azimuth = setjsProperty "azimuth"
 
get'azimuth ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
get'azimuth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "azimuth")
       return r
 
getm'azimuth ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
getm'azimuth = get'azimuth
 
set'background ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'background = setjsProperty "background"
 
get'background ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'background thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "background")
       return r
 
getm'background ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'background = get'background
 
set'backgroundAttachment ::
                         (Monad mn, CCSS2Properties zz) =>
                           Expression String -> Expression zz -> mn (Expression zz)
set'backgroundAttachment = setjsProperty "backgroundAttachment"
 
get'backgroundAttachment ::
                         (Monad mn, CCSS2Properties this) =>
                           Expression this -> mn (Expression String)
get'backgroundAttachment thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "backgroundAttachment")
       return r
 
getm'backgroundAttachment ::
                          (Monad mn, CCSS2Properties this) =>
                            Expression this -> mn (Expression String)
getm'backgroundAttachment = get'backgroundAttachment
 
set'backgroundColor ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'backgroundColor = setjsProperty "backgroundColor"
 
get'backgroundColor ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'backgroundColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "backgroundColor")
       return r
 
getm'backgroundColor ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'backgroundColor = get'backgroundColor
 
set'backgroundImage ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'backgroundImage = setjsProperty "backgroundImage"
 
get'backgroundImage ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'backgroundImage thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "backgroundImage")
       return r
 
getm'backgroundImage ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'backgroundImage = get'backgroundImage
 
set'backgroundPosition ::
                       (Monad mn, CCSS2Properties zz) =>
                         Expression String -> Expression zz -> mn (Expression zz)
set'backgroundPosition = setjsProperty "backgroundPosition"
 
get'backgroundPosition ::
                       (Monad mn, CCSS2Properties this) =>
                         Expression this -> mn (Expression String)
get'backgroundPosition thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "backgroundPosition")
       return r
 
getm'backgroundPosition ::
                        (Monad mn, CCSS2Properties this) =>
                          Expression this -> mn (Expression String)
getm'backgroundPosition = get'backgroundPosition
 
set'backgroundRepeat ::
                     (Monad mn, CCSS2Properties zz) =>
                       Expression String -> Expression zz -> mn (Expression zz)
set'backgroundRepeat = setjsProperty "backgroundRepeat"
 
get'backgroundRepeat ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
get'backgroundRepeat thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "backgroundRepeat")
       return r
 
getm'backgroundRepeat ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
getm'backgroundRepeat = get'backgroundRepeat
 
set'border ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'border = setjsProperty "border"
 
get'border ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'border thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "border")
       return r
 
getm'border ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'border = get'border
 
set'borderCollapse ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'borderCollapse = setjsProperty "borderCollapse"
 
get'borderCollapse ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'borderCollapse thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderCollapse")
       return r
 
getm'borderCollapse ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'borderCollapse = get'borderCollapse
 
set'borderColor ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'borderColor = setjsProperty "borderColor"
 
get'borderColor ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'borderColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderColor")
       return r
 
getm'borderColor ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'borderColor = get'borderColor
 
set'borderSpacing ::
                  (Monad mn, CCSS2Properties zz) =>
                    Expression String -> Expression zz -> mn (Expression zz)
set'borderSpacing = setjsProperty "borderSpacing"
 
get'borderSpacing ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
get'borderSpacing thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderSpacing")
       return r
 
getm'borderSpacing ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
getm'borderSpacing = get'borderSpacing
 
set'borderStyle ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'borderStyle = setjsProperty "borderStyle"
 
get'borderStyle ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'borderStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderStyle")
       return r
 
getm'borderStyle ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'borderStyle = get'borderStyle
 
set'borderTop ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'borderTop = setjsProperty "borderTop"
 
get'borderTop ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'borderTop thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderTop")
       return r
 
getm'borderTop ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'borderTop = get'borderTop
 
set'borderRight ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'borderRight = setjsProperty "borderRight"
 
get'borderRight ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'borderRight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderRight")
       return r
 
getm'borderRight ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'borderRight = get'borderRight
 
set'borderBottom ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'borderBottom = setjsProperty "borderBottom"
 
get'borderBottom ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'borderBottom thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderBottom")
       return r
 
getm'borderBottom ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'borderBottom = get'borderBottom
 
set'borderLeft ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'borderLeft = setjsProperty "borderLeft"
 
get'borderLeft ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'borderLeft thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderLeft")
       return r
 
getm'borderLeft ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'borderLeft = get'borderLeft
 
set'borderTopColor ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'borderTopColor = setjsProperty "borderTopColor"
 
get'borderTopColor ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'borderTopColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderTopColor")
       return r
 
getm'borderTopColor ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'borderTopColor = get'borderTopColor
 
set'borderRightColor ::
                     (Monad mn, CCSS2Properties zz) =>
                       Expression String -> Expression zz -> mn (Expression zz)
set'borderRightColor = setjsProperty "borderRightColor"
 
get'borderRightColor ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
get'borderRightColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderRightColor")
       return r
 
getm'borderRightColor ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
getm'borderRightColor = get'borderRightColor
 
set'borderBottomColor ::
                      (Monad mn, CCSS2Properties zz) =>
                        Expression String -> Expression zz -> mn (Expression zz)
set'borderBottomColor = setjsProperty "borderBottomColor"
 
get'borderBottomColor ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
get'borderBottomColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderBottomColor")
       return r
 
getm'borderBottomColor ::
                       (Monad mn, CCSS2Properties this) =>
                         Expression this -> mn (Expression String)
getm'borderBottomColor = get'borderBottomColor
 
set'borderLeftColor ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'borderLeftColor = setjsProperty "borderLeftColor"
 
get'borderLeftColor ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'borderLeftColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderLeftColor")
       return r
 
getm'borderLeftColor ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'borderLeftColor = get'borderLeftColor
 
set'borderTopStyle ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'borderTopStyle = setjsProperty "borderTopStyle"
 
get'borderTopStyle ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'borderTopStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderTopStyle")
       return r
 
getm'borderTopStyle ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'borderTopStyle = get'borderTopStyle
 
set'borderRightStyle ::
                     (Monad mn, CCSS2Properties zz) =>
                       Expression String -> Expression zz -> mn (Expression zz)
set'borderRightStyle = setjsProperty "borderRightStyle"
 
get'borderRightStyle ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
get'borderRightStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderRightStyle")
       return r
 
getm'borderRightStyle ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
getm'borderRightStyle = get'borderRightStyle
 
set'borderBottomStyle ::
                      (Monad mn, CCSS2Properties zz) =>
                        Expression String -> Expression zz -> mn (Expression zz)
set'borderBottomStyle = setjsProperty "borderBottomStyle"
 
get'borderBottomStyle ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
get'borderBottomStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderBottomStyle")
       return r
 
getm'borderBottomStyle ::
                       (Monad mn, CCSS2Properties this) =>
                         Expression this -> mn (Expression String)
getm'borderBottomStyle = get'borderBottomStyle
 
set'borderLeftStyle ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'borderLeftStyle = setjsProperty "borderLeftStyle"
 
get'borderLeftStyle ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'borderLeftStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderLeftStyle")
       return r
 
getm'borderLeftStyle ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'borderLeftStyle = get'borderLeftStyle
 
set'borderTopWidth ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'borderTopWidth = setjsProperty "borderTopWidth"
 
get'borderTopWidth ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'borderTopWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderTopWidth")
       return r
 
getm'borderTopWidth ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'borderTopWidth = get'borderTopWidth
 
set'borderRightWidth ::
                     (Monad mn, CCSS2Properties zz) =>
                       Expression String -> Expression zz -> mn (Expression zz)
set'borderRightWidth = setjsProperty "borderRightWidth"
 
get'borderRightWidth ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
get'borderRightWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderRightWidth")
       return r
 
getm'borderRightWidth ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
getm'borderRightWidth = get'borderRightWidth
 
set'borderBottomWidth ::
                      (Monad mn, CCSS2Properties zz) =>
                        Expression String -> Expression zz -> mn (Expression zz)
set'borderBottomWidth = setjsProperty "borderBottomWidth"
 
get'borderBottomWidth ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
get'borderBottomWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderBottomWidth")
       return r
 
getm'borderBottomWidth ::
                       (Monad mn, CCSS2Properties this) =>
                         Expression this -> mn (Expression String)
getm'borderBottomWidth = get'borderBottomWidth
 
set'borderLeftWidth ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'borderLeftWidth = setjsProperty "borderLeftWidth"
 
get'borderLeftWidth ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'borderLeftWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderLeftWidth")
       return r
 
getm'borderLeftWidth ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'borderLeftWidth = get'borderLeftWidth
 
set'borderWidth ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'borderWidth = setjsProperty "borderWidth"
 
get'borderWidth ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'borderWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "borderWidth")
       return r
 
getm'borderWidth ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'borderWidth = get'borderWidth
 
set'bottom ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'bottom = setjsProperty "bottom"
 
get'bottom ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'bottom thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "bottom")
       return r
 
getm'bottom ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'bottom = get'bottom
 
set'captionSide ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'captionSide = setjsProperty "captionSide"
 
get'captionSide ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'captionSide thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "captionSide")
       return r
 
getm'captionSide ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'captionSide = get'captionSide
 
set'clear ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'clear = setjsProperty "clear"
 
get'clear ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'clear thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "clear")
       return r
 
getm'clear ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'clear = get'clear
 
set'clip ::
         (Monad mn, CCSS2Properties zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'clip = setjsProperty "clip"
 
get'clip ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
get'clip thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "clip")
       return r
 
getm'clip ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
getm'clip = get'clip
 
set'color ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'color = setjsProperty "color"
 
get'color ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'color thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "color")
       return r
 
getm'color ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'color = get'color
 
set'content ::
            (Monad mn, CCSS2Properties zz) =>
              Expression String -> Expression zz -> mn (Expression zz)
set'content = setjsProperty "content"
 
get'content ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
get'content thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "content")
       return r
 
getm'content ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
getm'content = get'content
 
set'counterIncrement ::
                     (Monad mn, CCSS2Properties zz) =>
                       Expression String -> Expression zz -> mn (Expression zz)
set'counterIncrement = setjsProperty "counterIncrement"
 
get'counterIncrement ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
get'counterIncrement thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "counterIncrement")
       return r
 
getm'counterIncrement ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
getm'counterIncrement = get'counterIncrement
 
set'counterReset ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'counterReset = setjsProperty "counterReset"
 
get'counterReset ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'counterReset thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "counterReset")
       return r
 
getm'counterReset ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'counterReset = get'counterReset
 
set'cue ::
        (Monad mn, CCSS2Properties zz) =>
          Expression String -> Expression zz -> mn (Expression zz)
set'cue = setjsProperty "cue"
 
get'cue ::
        (Monad mn, CCSS2Properties this) =>
          Expression this -> mn (Expression String)
get'cue thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "cue")
       return r
 
getm'cue ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
getm'cue = get'cue
 
set'cueAfter ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'cueAfter = setjsProperty "cueAfter"
 
get'cueAfter ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'cueAfter thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "cueAfter")
       return r
 
getm'cueAfter ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'cueAfter = get'cueAfter
 
set'cueBefore ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'cueBefore = setjsProperty "cueBefore"
 
get'cueBefore ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'cueBefore thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "cueBefore")
       return r
 
getm'cueBefore ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'cueBefore = get'cueBefore
 
set'cursor ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'cursor = setjsProperty "cursor"
 
get'cursor ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'cursor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "cursor")
       return r
 
getm'cursor ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'cursor = get'cursor
 
set'direction ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'direction = setjsProperty "direction"
 
get'direction ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'direction thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "direction")
       return r
 
getm'direction ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'direction = get'direction
 
set'display ::
            (Monad mn, CCSS2Properties zz) =>
              Expression String -> Expression zz -> mn (Expression zz)
set'display = setjsProperty "display"
 
get'display ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
get'display thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "display")
       return r
 
getm'display ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
getm'display = get'display
 
set'elevation ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'elevation = setjsProperty "elevation"
 
get'elevation ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'elevation thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "elevation")
       return r
 
getm'elevation ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'elevation = get'elevation
 
set'emptyCells ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'emptyCells = setjsProperty "emptyCells"
 
get'emptyCells ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'emptyCells thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "emptyCells")
       return r
 
getm'emptyCells ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'emptyCells = get'emptyCells
 
set'cssFloat ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'cssFloat = setjsProperty "cssFloat"
 
get'cssFloat ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'cssFloat thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "cssFloat")
       return r
 
getm'cssFloat ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'cssFloat = get'cssFloat
 
set'font ::
         (Monad mn, CCSS2Properties zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'font = setjsProperty "font"
 
get'font ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
get'font thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "font")
       return r
 
getm'font ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
getm'font = get'font
 
set'fontFamily ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'fontFamily = setjsProperty "fontFamily"
 
get'fontFamily ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'fontFamily thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontFamily")
       return r
 
getm'fontFamily ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'fontFamily = get'fontFamily
 
set'fontSize ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'fontSize = setjsProperty "fontSize"
 
get'fontSize ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'fontSize thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontSize")
       return r
 
getm'fontSize ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'fontSize = get'fontSize
 
set'fontSizeAdjust ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'fontSizeAdjust = setjsProperty "fontSizeAdjust"
 
get'fontSizeAdjust ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'fontSizeAdjust thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontSizeAdjust")
       return r
 
getm'fontSizeAdjust ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'fontSizeAdjust = get'fontSizeAdjust
 
set'fontStretch ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'fontStretch = setjsProperty "fontStretch"
 
get'fontStretch ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'fontStretch thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontStretch")
       return r
 
getm'fontStretch ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'fontStretch = get'fontStretch
 
set'fontStyle ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'fontStyle = setjsProperty "fontStyle"
 
get'fontStyle ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'fontStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontStyle")
       return r
 
getm'fontStyle ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'fontStyle = get'fontStyle
 
set'fontVariant ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'fontVariant = setjsProperty "fontVariant"
 
get'fontVariant ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'fontVariant thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontVariant")
       return r
 
getm'fontVariant ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'fontVariant = get'fontVariant
 
set'fontWeight ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'fontWeight = setjsProperty "fontWeight"
 
get'fontWeight ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'fontWeight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "fontWeight")
       return r
 
getm'fontWeight ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'fontWeight = get'fontWeight
 
set'height ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'height = setjsProperty "height"
 
get'height ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'height thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "height")
       return r
 
getm'height ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'height = get'height
 
set'left ::
         (Monad mn, CCSS2Properties zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'left = setjsProperty "left"
 
get'left ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
get'left thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "left")
       return r
 
getm'left ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
getm'left = get'left
 
set'letterSpacing ::
                  (Monad mn, CCSS2Properties zz) =>
                    Expression String -> Expression zz -> mn (Expression zz)
set'letterSpacing = setjsProperty "letterSpacing"
 
get'letterSpacing ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
get'letterSpacing thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "letterSpacing")
       return r
 
getm'letterSpacing ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
getm'letterSpacing = get'letterSpacing
 
set'lineHeight ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'lineHeight = setjsProperty "lineHeight"
 
get'lineHeight ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'lineHeight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "lineHeight")
       return r
 
getm'lineHeight ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'lineHeight = get'lineHeight
 
set'listStyle ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'listStyle = setjsProperty "listStyle"
 
get'listStyle ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'listStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "listStyle")
       return r
 
getm'listStyle ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'listStyle = get'listStyle
 
set'listStyleImage ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'listStyleImage = setjsProperty "listStyleImage"
 
get'listStyleImage ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'listStyleImage thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "listStyleImage")
       return r
 
getm'listStyleImage ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'listStyleImage = get'listStyleImage
 
set'listStylePosition ::
                      (Monad mn, CCSS2Properties zz) =>
                        Expression String -> Expression zz -> mn (Expression zz)
set'listStylePosition = setjsProperty "listStylePosition"
 
get'listStylePosition ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
get'listStylePosition thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "listStylePosition")
       return r
 
getm'listStylePosition ::
                       (Monad mn, CCSS2Properties this) =>
                         Expression this -> mn (Expression String)
getm'listStylePosition = get'listStylePosition
 
set'listStyleType ::
                  (Monad mn, CCSS2Properties zz) =>
                    Expression String -> Expression zz -> mn (Expression zz)
set'listStyleType = setjsProperty "listStyleType"
 
get'listStyleType ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
get'listStyleType thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "listStyleType")
       return r
 
getm'listStyleType ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
getm'listStyleType = get'listStyleType
 
set'margin ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'margin = setjsProperty "margin"
 
get'margin ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'margin thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "margin")
       return r
 
getm'margin ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'margin = get'margin
 
set'marginTop ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'marginTop = setjsProperty "marginTop"
 
get'marginTop ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'marginTop thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "marginTop")
       return r
 
getm'marginTop ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'marginTop = get'marginTop
 
set'marginRight ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'marginRight = setjsProperty "marginRight"
 
get'marginRight ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'marginRight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "marginRight")
       return r
 
getm'marginRight ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'marginRight = get'marginRight
 
set'marginBottom ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'marginBottom = setjsProperty "marginBottom"
 
get'marginBottom ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'marginBottom thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "marginBottom")
       return r
 
getm'marginBottom ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'marginBottom = get'marginBottom
 
set'marginLeft ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'marginLeft = setjsProperty "marginLeft"
 
get'marginLeft ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'marginLeft thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "marginLeft")
       return r
 
getm'marginLeft ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'marginLeft = get'marginLeft
 
set'markerOffset ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'markerOffset = setjsProperty "markerOffset"
 
get'markerOffset ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'markerOffset thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "markerOffset")
       return r
 
getm'markerOffset ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'markerOffset = get'markerOffset
 
set'marks ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'marks = setjsProperty "marks"
 
get'marks ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'marks thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "marks")
       return r
 
getm'marks ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'marks = get'marks
 
set'maxHeight ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'maxHeight = setjsProperty "maxHeight"
 
get'maxHeight ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'maxHeight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "maxHeight")
       return r
 
getm'maxHeight ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'maxHeight = get'maxHeight
 
set'maxWidth ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'maxWidth = setjsProperty "maxWidth"
 
get'maxWidth ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'maxWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "maxWidth")
       return r
 
getm'maxWidth ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'maxWidth = get'maxWidth
 
set'minHeight ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'minHeight = setjsProperty "minHeight"
 
get'minHeight ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'minHeight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "minHeight")
       return r
 
getm'minHeight ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'minHeight = get'minHeight
 
set'minWidth ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'minWidth = setjsProperty "minWidth"
 
get'minWidth ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'minWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "minWidth")
       return r
 
getm'minWidth ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'minWidth = get'minWidth
 
set'orphans ::
            (Monad mn, CCSS2Properties zz) =>
              Expression String -> Expression zz -> mn (Expression zz)
set'orphans = setjsProperty "orphans"
 
get'orphans ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
get'orphans thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "orphans")
       return r
 
getm'orphans ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
getm'orphans = get'orphans
 
set'outline ::
            (Monad mn, CCSS2Properties zz) =>
              Expression String -> Expression zz -> mn (Expression zz)
set'outline = setjsProperty "outline"
 
get'outline ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
get'outline thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "outline")
       return r
 
getm'outline ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
getm'outline = get'outline
 
set'outlineColor ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'outlineColor = setjsProperty "outlineColor"
 
get'outlineColor ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'outlineColor thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "outlineColor")
       return r
 
getm'outlineColor ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'outlineColor = get'outlineColor
 
set'outlineStyle ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'outlineStyle = setjsProperty "outlineStyle"
 
get'outlineStyle ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'outlineStyle thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "outlineStyle")
       return r
 
getm'outlineStyle ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'outlineStyle = get'outlineStyle
 
set'outlineWidth ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'outlineWidth = setjsProperty "outlineWidth"
 
get'outlineWidth ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'outlineWidth thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "outlineWidth")
       return r
 
getm'outlineWidth ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'outlineWidth = get'outlineWidth
 
set'overflow ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'overflow = setjsProperty "overflow"
 
get'overflow ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'overflow thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "overflow")
       return r
 
getm'overflow ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'overflow = get'overflow
 
set'padding ::
            (Monad mn, CCSS2Properties zz) =>
              Expression String -> Expression zz -> mn (Expression zz)
set'padding = setjsProperty "padding"
 
get'padding ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
get'padding thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "padding")
       return r
 
getm'padding ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
getm'padding = get'padding
 
set'paddingTop ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'paddingTop = setjsProperty "paddingTop"
 
get'paddingTop ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'paddingTop thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "paddingTop")
       return r
 
getm'paddingTop ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'paddingTop = get'paddingTop
 
set'paddingRight ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'paddingRight = setjsProperty "paddingRight"
 
get'paddingRight ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'paddingRight thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "paddingRight")
       return r
 
getm'paddingRight ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'paddingRight = get'paddingRight
 
set'paddingBottom ::
                  (Monad mn, CCSS2Properties zz) =>
                    Expression String -> Expression zz -> mn (Expression zz)
set'paddingBottom = setjsProperty "paddingBottom"
 
get'paddingBottom ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
get'paddingBottom thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "paddingBottom")
       return r
 
getm'paddingBottom ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
getm'paddingBottom = get'paddingBottom
 
set'paddingLeft ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'paddingLeft = setjsProperty "paddingLeft"
 
get'paddingLeft ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'paddingLeft thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "paddingLeft")
       return r
 
getm'paddingLeft ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'paddingLeft = get'paddingLeft
 
set'page ::
         (Monad mn, CCSS2Properties zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'page = setjsProperty "page"
 
get'page ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
get'page thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "page")
       return r
 
getm'page ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
getm'page = get'page
 
set'pageBreakAfter ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'pageBreakAfter = setjsProperty "pageBreakAfter"
 
get'pageBreakAfter ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'pageBreakAfter thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pageBreakAfter")
       return r
 
getm'pageBreakAfter ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'pageBreakAfter = get'pageBreakAfter
 
set'pageBreakBefore ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'pageBreakBefore = setjsProperty "pageBreakBefore"
 
get'pageBreakBefore ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'pageBreakBefore thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pageBreakBefore")
       return r
 
getm'pageBreakBefore ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'pageBreakBefore = get'pageBreakBefore
 
set'pageBreakInside ::
                    (Monad mn, CCSS2Properties zz) =>
                      Expression String -> Expression zz -> mn (Expression zz)
set'pageBreakInside = setjsProperty "pageBreakInside"
 
get'pageBreakInside ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
get'pageBreakInside thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pageBreakInside")
       return r
 
getm'pageBreakInside ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
getm'pageBreakInside = get'pageBreakInside
 
set'pause ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'pause = setjsProperty "pause"
 
get'pause ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'pause thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pause")
       return r
 
getm'pause ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'pause = get'pause
 
set'pauseAfter ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'pauseAfter = setjsProperty "pauseAfter"
 
get'pauseAfter ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'pauseAfter thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pauseAfter")
       return r
 
getm'pauseAfter ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'pauseAfter = get'pauseAfter
 
set'pauseBefore ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'pauseBefore = setjsProperty "pauseBefore"
 
get'pauseBefore ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'pauseBefore thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pauseBefore")
       return r
 
getm'pauseBefore ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'pauseBefore = get'pauseBefore
 
set'pitch ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'pitch = setjsProperty "pitch"
 
get'pitch ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'pitch thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pitch")
       return r
 
getm'pitch ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'pitch = get'pitch
 
set'pitchRange ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'pitchRange = setjsProperty "pitchRange"
 
get'pitchRange ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'pitchRange thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "pitchRange")
       return r
 
getm'pitchRange ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'pitchRange = get'pitchRange
 
set'playDuring ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'playDuring = setjsProperty "playDuring"
 
get'playDuring ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'playDuring thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "playDuring")
       return r
 
getm'playDuring ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'playDuring = get'playDuring
 
set'position ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'position = setjsProperty "position"
 
get'position ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'position thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "position")
       return r
 
getm'position ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'position = get'position
 
set'quotes ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'quotes = setjsProperty "quotes"
 
get'quotes ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'quotes thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "quotes")
       return r
 
getm'quotes ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'quotes = get'quotes
 
set'richness ::
             (Monad mn, CCSS2Properties zz) =>
               Expression String -> Expression zz -> mn (Expression zz)
set'richness = setjsProperty "richness"
 
get'richness ::
             (Monad mn, CCSS2Properties this) =>
               Expression this -> mn (Expression String)
get'richness thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "richness")
       return r
 
getm'richness ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
getm'richness = get'richness
 
set'right ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'right = setjsProperty "right"
 
get'right ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'right thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "right")
       return r
 
getm'right ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'right = get'right
 
set'size ::
         (Monad mn, CCSS2Properties zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'size = setjsProperty "size"
 
get'size ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
get'size thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "size")
       return r
 
getm'size ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
getm'size = get'size
 
set'speak ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'speak = setjsProperty "speak"
 
get'speak ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'speak thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "speak")
       return r
 
getm'speak ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'speak = get'speak
 
set'speakHeader ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'speakHeader = setjsProperty "speakHeader"
 
get'speakHeader ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'speakHeader thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "speakHeader")
       return r
 
getm'speakHeader ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'speakHeader = get'speakHeader
 
set'speakNumeral ::
                 (Monad mn, CCSS2Properties zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'speakNumeral = setjsProperty "speakNumeral"
 
get'speakNumeral ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
get'speakNumeral thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "speakNumeral")
       return r
 
getm'speakNumeral ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
getm'speakNumeral = get'speakNumeral
 
set'speakPunctuation ::
                     (Monad mn, CCSS2Properties zz) =>
                       Expression String -> Expression zz -> mn (Expression zz)
set'speakPunctuation = setjsProperty "speakPunctuation"
 
get'speakPunctuation ::
                     (Monad mn, CCSS2Properties this) =>
                       Expression this -> mn (Expression String)
get'speakPunctuation thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "speakPunctuation")
       return r
 
getm'speakPunctuation ::
                      (Monad mn, CCSS2Properties this) =>
                        Expression this -> mn (Expression String)
getm'speakPunctuation = get'speakPunctuation
 
set'speechRate ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'speechRate = setjsProperty "speechRate"
 
get'speechRate ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'speechRate thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "speechRate")
       return r
 
getm'speechRate ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'speechRate = get'speechRate
 
set'stress ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'stress = setjsProperty "stress"
 
get'stress ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'stress thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "stress")
       return r
 
getm'stress ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'stress = get'stress
 
set'tableLayout ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'tableLayout = setjsProperty "tableLayout"
 
get'tableLayout ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'tableLayout thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "tableLayout")
       return r
 
getm'tableLayout ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'tableLayout = get'tableLayout
 
set'textAlign ::
              (Monad mn, CCSS2Properties zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'textAlign = setjsProperty "textAlign"
 
get'textAlign ::
              (Monad mn, CCSS2Properties this) =>
                Expression this -> mn (Expression String)
get'textAlign thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "textAlign")
       return r
 
getm'textAlign ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
getm'textAlign = get'textAlign
 
set'textDecoration ::
                   (Monad mn, CCSS2Properties zz) =>
                     Expression String -> Expression zz -> mn (Expression zz)
set'textDecoration = setjsProperty "textDecoration"
 
get'textDecoration ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
get'textDecoration thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "textDecoration")
       return r
 
getm'textDecoration ::
                    (Monad mn, CCSS2Properties this) =>
                      Expression this -> mn (Expression String)
getm'textDecoration = get'textDecoration
 
set'textIndent ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'textIndent = setjsProperty "textIndent"
 
get'textIndent ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'textIndent thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "textIndent")
       return r
 
getm'textIndent ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'textIndent = get'textIndent
 
set'textShadow ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'textShadow = setjsProperty "textShadow"
 
get'textShadow ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'textShadow thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "textShadow")
       return r
 
getm'textShadow ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'textShadow = get'textShadow
 
set'textTransform ::
                  (Monad mn, CCSS2Properties zz) =>
                    Expression String -> Expression zz -> mn (Expression zz)
set'textTransform = setjsProperty "textTransform"
 
get'textTransform ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
get'textTransform thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "textTransform")
       return r
 
getm'textTransform ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
getm'textTransform = get'textTransform
 
set'top ::
        (Monad mn, CCSS2Properties zz) =>
          Expression String -> Expression zz -> mn (Expression zz)
set'top = setjsProperty "top"
 
get'top ::
        (Monad mn, CCSS2Properties this) =>
          Expression this -> mn (Expression String)
get'top thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "top")
       return r
 
getm'top ::
         (Monad mn, CCSS2Properties this) =>
           Expression this -> mn (Expression String)
getm'top = get'top
 
set'unicodeBidi ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'unicodeBidi = setjsProperty "unicodeBidi"
 
get'unicodeBidi ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'unicodeBidi thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "unicodeBidi")
       return r
 
getm'unicodeBidi ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'unicodeBidi = get'unicodeBidi
 
set'verticalAlign ::
                  (Monad mn, CCSS2Properties zz) =>
                    Expression String -> Expression zz -> mn (Expression zz)
set'verticalAlign = setjsProperty "verticalAlign"
 
get'verticalAlign ::
                  (Monad mn, CCSS2Properties this) =>
                    Expression this -> mn (Expression String)
get'verticalAlign thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "verticalAlign")
       return r
 
getm'verticalAlign ::
                   (Monad mn, CCSS2Properties this) =>
                     Expression this -> mn (Expression String)
getm'verticalAlign = get'verticalAlign
 
set'visibility ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'visibility = setjsProperty "visibility"
 
get'visibility ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'visibility thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "visibility")
       return r
 
getm'visibility ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'visibility = get'visibility
 
set'voiceFamily ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'voiceFamily = setjsProperty "voiceFamily"
 
get'voiceFamily ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'voiceFamily thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "voiceFamily")
       return r
 
getm'voiceFamily ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'voiceFamily = get'voiceFamily
 
set'volume ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'volume = setjsProperty "volume"
 
get'volume ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'volume thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "volume")
       return r
 
getm'volume ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'volume = get'volume
 
set'whiteSpace ::
               (Monad mn, CCSS2Properties zz) =>
                 Expression String -> Expression zz -> mn (Expression zz)
set'whiteSpace = setjsProperty "whiteSpace"
 
get'whiteSpace ::
               (Monad mn, CCSS2Properties this) =>
                 Expression this -> mn (Expression String)
get'whiteSpace thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "whiteSpace")
       return r
 
getm'whiteSpace ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
getm'whiteSpace = get'whiteSpace
 
set'widows ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'widows = setjsProperty "widows"
 
get'widows ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'widows thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "widows")
       return r
 
getm'widows ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'widows = get'widows
 
set'width ::
          (Monad mn, CCSS2Properties zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'width = setjsProperty "width"
 
get'width ::
          (Monad mn, CCSS2Properties this) =>
            Expression this -> mn (Expression String)
get'width thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "width")
       return r
 
getm'width ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
getm'width = get'width
 
set'wordSpacing ::
                (Monad mn, CCSS2Properties zz) =>
                  Expression String -> Expression zz -> mn (Expression zz)
set'wordSpacing = setjsProperty "wordSpacing"
 
get'wordSpacing ::
                (Monad mn, CCSS2Properties this) =>
                  Expression this -> mn (Expression String)
get'wordSpacing thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "wordSpacing")
       return r
 
getm'wordSpacing ::
                 (Monad mn, CCSS2Properties this) =>
                   Expression this -> mn (Expression String)
getm'wordSpacing = get'wordSpacing
 
set'zIndex ::
           (Monad mn, CCSS2Properties zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'zIndex = setjsProperty "zIndex"
 
get'zIndex ::
           (Monad mn, CCSS2Properties this) =>
             Expression this -> mn (Expression String)
get'zIndex thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "zIndex")
       return r
 
getm'zIndex ::
            (Monad mn, CCSS2Properties this) =>
              Expression this -> mn (Expression String)
getm'zIndex = get'zIndex