module Data.DOM.Node
       (insertBefore, replaceChild, removeChild, appendChild,
        hasChildNodes, cloneNode, normalize, isSupported, hasAttributes,
        cELEMENT_NODE, cATTRIBUTE_NODE, cTEXT_NODE, cCDATA_SECTION_NODE,
        cENTITY_REFERENCE_NODE, cENTITY_NODE, cPROCESSING_INSTRUCTION_NODE,
        cCOMMENT_NODE, cDOCUMENT_NODE, cDOCUMENT_TYPE_NODE,
        cDOCUMENT_FRAGMENT_NODE, cNOTATION_NODE, get'nodeName,
        getm'nodeName, set'nodeValue, get'nodeValue, getm'nodeValue,
        get'nodeType, getm'nodeType, get'parentNode, getm'parentNode,
        get'childNodes, getm'childNodes, get'firstChild, getm'firstChild,
        get'lastChild, getm'lastChild, get'previousSibling,
        getm'previousSibling, get'nextSibling, getm'nextSibling,
        get'attributes, getm'attributes, get'ownerDocument,
        getm'ownerDocument, get'namespaceURI, getm'namespaceURI,
        set'prefix, get'prefix, getm'prefix, get'localName, getm'localName)
       where
import Data.DOM.Dom
import Control.Monad
import BrownPLT.JavaScript
import Data.DOM.WBTypes
import Data.DOM.Document (createElement)
 
insertBefore ::
             (Monad mn, CNode this, CNode newChild, CNode refChild, CNode zz) =>
               Expression newChild ->
                 Expression refChild -> Expression this -> mn (Expression zz)
insertBefore a b thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "insertBefore")
       return (CallExpr et r [a /\ et, b /\ et])
 
replaceChild ::
             (Monad mn, CNode this, CNode newChild, CNode oldChild, CNode zz) =>
               Expression newChild ->
                 Expression oldChild -> Expression this -> mn (Expression zz)
replaceChild a b thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "replaceChild")
       return (CallExpr et r [a /\ et, b /\ et])
 
removeChild ::
            (Monad mn, CNode this, CNode oldChild, CNode zz) =>
              Expression oldChild -> Expression this -> mn (Expression zz)
removeChild a thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "removeChild")
       return (CallExpr et r [a /\ et])
 
appendChild ::
            (Monad mn, CNode this, CNode newChild, CNode zz) =>
              Expression newChild -> Expression this -> mn (Expression zz)
appendChild a thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "appendChild")
       return (CallExpr et r [a /\ et])
 
hasChildNodes ::
              (Monad mn, CNode this) => Expression this -> mn (Expression Bool)
hasChildNodes thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "hasChildNodes")
       return (CallExpr et r [])
 
cloneNode ::
          (Monad mn, CNode this, CNode zz) =>
            Expression Bool -> Expression this -> mn (Expression zz)
cloneNode a thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "cloneNode")
       return (CallExpr et r [a /\ et])
 
normalize ::
          (Monad mn, CNode this) => Expression this -> mn (Expression ())
normalize thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "normalize")
       return (CallExpr et r [])
 
isSupported ::
            (Monad mn, CNode this) =>
              Expression String ->
                Expression String -> Expression this -> mn (Expression Bool)
isSupported a b thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "isSupported")
       return (CallExpr et r [a /\ et, b /\ et])
 
hasAttributes ::
              (Monad mn, CNode this) => Expression this -> mn (Expression Bool)
hasAttributes thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "hasAttributes")
       return (CallExpr et r [])
cELEMENT_NODE = 1
cATTRIBUTE_NODE = 2
cTEXT_NODE = 3
cCDATA_SECTION_NODE = 4
cENTITY_REFERENCE_NODE = 5
cENTITY_NODE = 6
cPROCESSING_INSTRUCTION_NODE = 7
cCOMMENT_NODE = 8
cDOCUMENT_NODE = 9
cDOCUMENT_TYPE_NODE = 10
cDOCUMENT_FRAGMENT_NODE = 11
cNOTATION_NODE = 12
 
get'nodeName ::
             (Monad mn, CNode this) => Expression this -> mn (Expression String)
get'nodeName thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "nodeName")
       return r
 
getm'nodeName ::
              (Monad mn, CNode this) => Expression this -> mn (Expression String)
getm'nodeName = get'nodeName
 
set'nodeValue ::
              (Monad mn, CNode zz) =>
                Expression String -> Expression zz -> mn (Expression zz)
set'nodeValue = setjsProperty "nodeValue"
 
get'nodeValue ::
              (Monad mn, CNode this) => Expression this -> mn (Expression String)
get'nodeValue thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "nodeValue")
       return r
 
getm'nodeValue ::
               (Monad mn, CNode this) => Expression this -> mn (Expression String)
getm'nodeValue = get'nodeValue
 
get'nodeType ::
             (Monad mn, CNode this) => Expression this -> mn (Expression Double)
get'nodeType thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "nodeType")
       return r
 
getm'nodeType ::
              (Monad mn, CNode this) => Expression this -> mn (Expression Double)
getm'nodeType = get'nodeType
 
get'parentNode ::
               (Monad mn, CNode this, CNode zz) =>
                 Expression this -> mn (Expression zz)
get'parentNode thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "parentNode")
       return r
 
getm'parentNode ::
                (Monad mn, CNode this) => Expression this -> mn (Expression TNode)
getm'parentNode = get'parentNode
 
get'childNodes ::
               (Monad mn, CNode this, CNodeList zz) =>
                 Expression this -> mn (Expression zz)
get'childNodes thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "childNodes")
       return r
 
getm'childNodes ::
                (Monad mn, CNode this) =>
                  Expression this -> mn (Expression TNodeList)
getm'childNodes = get'childNodes
 
get'firstChild ::
               (Monad mn, CNode this, CNode zz) =>
                 Expression this -> mn (Expression zz)
get'firstChild thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "firstChild")
       return r
 
getm'firstChild ::
                (Monad mn, CNode this) => Expression this -> mn (Expression TNode)
getm'firstChild = get'firstChild
 
get'lastChild ::
              (Monad mn, CNode this, CNode zz) =>
                Expression this -> mn (Expression zz)
get'lastChild thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "lastChild")
       return r
 
getm'lastChild ::
               (Monad mn, CNode this) => Expression this -> mn (Expression TNode)
getm'lastChild = get'lastChild
 
get'previousSibling ::
                    (Monad mn, CNode this, CNode zz) =>
                      Expression this -> mn (Expression zz)
get'previousSibling thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "previousSibling")
       return r
 
getm'previousSibling ::
                     (Monad mn, CNode this) => Expression this -> mn (Expression TNode)
getm'previousSibling = get'previousSibling
 
get'nextSibling ::
                (Monad mn, CNode this, CNode zz) =>
                  Expression this -> mn (Expression zz)
get'nextSibling thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "nextSibling")
       return r
 
getm'nextSibling ::
                 (Monad mn, CNode this) => Expression this -> mn (Expression TNode)
getm'nextSibling = get'nextSibling
 
get'attributes ::
               (Monad mn, CNode this, CNamedNodeMap zz) =>
                 Expression this -> mn (Expression zz)
get'attributes thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "attributes")
       return r
 
getm'attributes ::
                (Monad mn, CNode this) =>
                  Expression this -> mn (Expression TNamedNodeMap)
getm'attributes = get'attributes
 
get'ownerDocument ::
                  (Monad mn, CNode this, CDocument zz) =>
                    Expression this -> mn (Expression zz)
get'ownerDocument thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "ownerDocument")
       return r
 
getm'ownerDocument ::
                   (Monad mn, CNode this) =>
                     Expression this -> mn (Expression TDocument)
getm'ownerDocument = get'ownerDocument
 
get'namespaceURI ::
                 (Monad mn, CNode this) => Expression this -> mn (Expression String)
get'namespaceURI thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "namespaceURI")
       return r
 
getm'namespaceURI ::
                  (Monad mn, CNode this) => Expression this -> mn (Expression String)
getm'namespaceURI = get'namespaceURI
 
set'prefix ::
           (Monad mn, CNode zz) =>
             Expression String -> Expression zz -> mn (Expression zz)
set'prefix = setjsProperty "prefix"
 
get'prefix ::
           (Monad mn, CNode this) => Expression this -> mn (Expression String)
get'prefix thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "prefix")
       return r
 
getm'prefix ::
            (Monad mn, CNode this) => Expression this -> mn (Expression String)
getm'prefix = get'prefix
 
get'localName ::
              (Monad mn, CNode this) => Expression this -> mn (Expression String)
get'localName thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "localName")
       return r
 
getm'localName ::
               (Monad mn, CNode this) => Expression this -> mn (Expression String)
getm'localName = get'localName