module Data.DOM.HTMLInputElement
       (blur, focus, select, click, set'defaultValue, get'defaultValue,
        getm'defaultValue, set'defaultChecked, get'defaultChecked,
        getm'defaultChecked, get'form, getm'form, set'accept, get'accept,
        getm'accept, set'accessKey, get'accessKey, getm'accessKey,
        set'align, get'align, getm'align, set'alt, get'alt, getm'alt,
        set'checked, get'checked, getm'checked, set'disabled, get'disabled,
        getm'disabled, set'maxLength, get'maxLength, getm'maxLength,
        set'name, get'name, getm'name, set'readOnly, get'readOnly,
        getm'readOnly, set'size, get'size, getm'size, set'src, get'src,
        getm'src, set'tabIndex, get'tabIndex, getm'tabIndex, set'type,
        get'type, getm'type, set'useMap, get'useMap, getm'useMap,
        set'value, get'value, getm'value, mkInput)
       where
import Data.DOM.Html2
import Control.Monad
import BrownPLT.JavaScript
import Data.DOM.WBTypes
import Data.DOM.Dom
import Data.DOM.Document (createElement)
 
blur ::
     (Monad mn, CHTMLInputElement this) =>
       Expression this -> mn (Expression ())
blur thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "blur")
       return (CallExpr et r [])
 
focus ::
      (Monad mn, CHTMLInputElement this) =>
        Expression this -> mn (Expression ())
focus thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "focus")
       return (CallExpr et r [])
 
select ::
       (Monad mn, CHTMLInputElement this) =>
         Expression this -> mn (Expression ())
select thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "select")
       return (CallExpr et r [])
 
click ::
      (Monad mn, CHTMLInputElement this) =>
        Expression this -> mn (Expression ())
click thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "click")
       return (CallExpr et r [])
 
set'defaultValue ::
                 (Monad mn, CHTMLInputElement zz) =>
                   Expression String -> Expression zz -> mn (Expression zz)
set'defaultValue = setjsProperty "defaultValue"
 
get'defaultValue ::
                 (Monad mn, CHTMLInputElement this) =>
                   Expression this -> mn (Expression String)
get'defaultValue thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "defaultValue")
       return r
 
getm'defaultValue ::
                  (Monad mn, CHTMLInputElement this) =>
                    Expression this -> mn (Expression String)
getm'defaultValue = get'defaultValue
 
set'defaultChecked ::
                   (Monad mn, CHTMLInputElement zz) =>
                     Expression Bool -> Expression zz -> mn (Expression zz)
set'defaultChecked = setjsProperty "defaultChecked"
 
get'defaultChecked ::
                   (Monad mn, CHTMLInputElement this) =>
                     Expression this -> mn (Expression Bool)
get'defaultChecked thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "defaultChecked")
       return r
 
getm'defaultChecked ::
                    (Monad mn, CHTMLInputElement this) =>
                      Expression this -> mn (Expression Bool)
getm'defaultChecked = get'defaultChecked
 
get'form ::
         (Monad mn, CHTMLInputElement this, CHTMLFormElement zz) =>
           Expression this -> mn (Expression zz)
get'form thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "form")
       return r
 
getm'form ::
          (Monad mn, CHTMLInputElement this) =>
            Expression this -> mn (Expression THTMLFormElement)
getm'form = get'form
 
set'accept ::
           (Monad mn, CHTMLInputElement zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'accept = setjsProperty "accept"
 
get'accept ::
           (Monad mn, CHTMLInputElement this) =>
             Expression this -> mn (Expression String)
get'accept thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "accept")
       return r
 
getm'accept ::
            (Monad mn, CHTMLInputElement this) =>
              Expression this -> mn (Expression String)
getm'accept = get'accept
 
set'accessKey ::
              (Monad mn, CHTMLInputElement zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'accessKey = setjsProperty "accessKey"
 
get'accessKey ::
              (Monad mn, CHTMLInputElement this) =>
                Expression this -> mn (Expression String)
get'accessKey thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "accessKey")
       return r
 
getm'accessKey ::
               (Monad mn, CHTMLInputElement this) =>
                 Expression this -> mn (Expression String)
getm'accessKey = get'accessKey
 
set'align ::
          (Monad mn, CHTMLInputElement zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'align = setjsProperty "align"
 
get'align ::
          (Monad mn, CHTMLInputElement this) =>
            Expression this -> mn (Expression String)
get'align thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "align")
       return r
 
getm'align ::
           (Monad mn, CHTMLInputElement this) =>
             Expression this -> mn (Expression String)
getm'align = get'align
 
set'alt ::
        (Monad mn, CHTMLInputElement zz) =>
          Expression String -> Expression zz -> mn (Expression zz)
set'alt = setjsProperty "alt"
 
get'alt ::
        (Monad mn, CHTMLInputElement this) =>
          Expression this -> mn (Expression String)
get'alt thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "alt")
       return r
 
getm'alt ::
         (Monad mn, CHTMLInputElement this) =>
           Expression this -> mn (Expression String)
getm'alt = get'alt
 
set'checked ::
            (Monad mn, CHTMLInputElement zz) =>
              Expression Bool -> Expression zz -> mn (Expression zz)
set'checked = setjsProperty "checked"
 
get'checked ::
            (Monad mn, CHTMLInputElement this) =>
              Expression this -> mn (Expression Bool)
get'checked thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "checked")
       return r
 
getm'checked ::
             (Monad mn, CHTMLInputElement this) =>
               Expression this -> mn (Expression Bool)
getm'checked = get'checked
 
set'disabled ::
             (Monad mn, CHTMLInputElement zz) =>
               Expression Bool -> Expression zz -> mn (Expression zz)
set'disabled = setjsProperty "disabled"
 
get'disabled ::
             (Monad mn, CHTMLInputElement this) =>
               Expression this -> mn (Expression Bool)
get'disabled thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "disabled")
       return r
 
getm'disabled ::
              (Monad mn, CHTMLInputElement this) =>
                Expression this -> mn (Expression Bool)
getm'disabled = get'disabled
 
set'maxLength ::
              (Monad mn, CHTMLInputElement zz) =>
                Expression Double -> Expression zz -> mn (Expression zz)
set'maxLength = setjsProperty "maxLength"
 
get'maxLength ::
              (Monad mn, CHTMLInputElement this) =>
                Expression this -> mn (Expression Double)
get'maxLength thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "maxLength")
       return r
 
getm'maxLength ::
               (Monad mn, CHTMLInputElement this) =>
                 Expression this -> mn (Expression Double)
getm'maxLength = get'maxLength
 
set'name ::
         (Monad mn, CHTMLInputElement zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'name = setjsProperty "name"
 
get'name ::
         (Monad mn, CHTMLInputElement this) =>
           Expression this -> mn (Expression String)
get'name thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "name")
       return r
 
getm'name ::
          (Monad mn, CHTMLInputElement this) =>
            Expression this -> mn (Expression String)
getm'name = get'name
 
set'readOnly ::
             (Monad mn, CHTMLInputElement zz) =>
               Expression Bool -> Expression zz -> mn (Expression zz)
set'readOnly = setjsProperty "readOnly"
 
get'readOnly ::
             (Monad mn, CHTMLInputElement this) =>
               Expression this -> mn (Expression Bool)
get'readOnly thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "readOnly")
       return r
 
getm'readOnly ::
              (Monad mn, CHTMLInputElement this) =>
                Expression this -> mn (Expression Bool)
getm'readOnly = get'readOnly
 
set'size ::
         (Monad mn, CHTMLInputElement zz) =>
           Expression Double -> Expression zz -> mn (Expression zz)
set'size = setjsProperty "size"
 
get'size ::
         (Monad mn, CHTMLInputElement this) =>
           Expression this -> mn (Expression Double)
get'size thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "size")
       return r
 
getm'size ::
          (Monad mn, CHTMLInputElement this) =>
            Expression this -> mn (Expression Double)
getm'size = get'size
 
set'src ::
        (Monad mn, CHTMLInputElement zz) =>
          Expression String -> Expression zz -> mn (Expression zz)
set'src = setjsProperty "src"
 
get'src ::
        (Monad mn, CHTMLInputElement this) =>
          Expression this -> mn (Expression String)
get'src thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "src")
       return r
 
getm'src ::
         (Monad mn, CHTMLInputElement this) =>
           Expression this -> mn (Expression String)
getm'src = get'src
 
set'tabIndex ::
             (Monad mn, CHTMLInputElement zz) =>
               Expression Double -> Expression zz -> mn (Expression zz)
set'tabIndex = setjsProperty "tabIndex"
 
get'tabIndex ::
             (Monad mn, CHTMLInputElement this) =>
               Expression this -> mn (Expression Double)
get'tabIndex thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "tabIndex")
       return r
 
getm'tabIndex ::
              (Monad mn, CHTMLInputElement this) =>
                Expression this -> mn (Expression Double)
getm'tabIndex = get'tabIndex
 
set'type ::
         (Monad mn, CHTMLInputElement zz) =>
           Expression String -> Expression zz -> mn (Expression zz)
set'type = setjsProperty "type"
 
get'type ::
         (Monad mn, CHTMLInputElement this) =>
           Expression this -> mn (Expression String)
get'type thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "type")
       return r
 
getm'type ::
          (Monad mn, CHTMLInputElement this) =>
            Expression this -> mn (Expression String)
getm'type = get'type
 
set'useMap ::
           (Monad mn, CHTMLInputElement zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'useMap = setjsProperty "useMap"
 
get'useMap ::
           (Monad mn, CHTMLInputElement this) =>
             Expression this -> mn (Expression String)
get'useMap thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "useMap")
       return r
 
getm'useMap ::
            (Monad mn, CHTMLInputElement this) =>
              Expression this -> mn (Expression String)
getm'useMap = get'useMap
 
set'value ::
          (Monad mn, CHTMLInputElement zz) =>
            Expression String -> Expression zz -> mn (Expression zz)
set'value = setjsProperty "value"
 
get'value ::
          (Monad mn, CHTMLInputElement this) =>
            Expression this -> mn (Expression String)
get'value thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "value")
       return r
 
getm'value ::
           (Monad mn, CHTMLInputElement this) =>
             Expression this -> mn (Expression String)
getm'value = get'value
 
mkInput ::
        (Monad mn, CHTMLDocument a) =>
          Expression a -> mn (Expression THTMLInputElement)
mkInput = createElement (StringLit "input" "input")