module Data.DOM.TreeWalker
       (parentNode, firstChild, lastChild, previousSibling, nextSibling,
        previousNode, nextNode, get'root, getm'root, get'whatToShow,
        getm'whatToShow, get'filter, getm'filter,
        get'expandEntityReferences, getm'expandEntityReferences,
        set'currentNode, get'currentNode, getm'currentNode)
       where
import Data.DOM.Traversal
import Control.Monad
import BrownPLT.JavaScript
import Data.DOM.WBTypes
import Data.DOM.Dom
import Data.DOM.Document (createElement)
 
parentNode ::
           (Monad mn, CTreeWalker this, CNode zz) =>
             Expression this -> mn (Expression zz)
parentNode thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "parentNode")
       return (CallExpr et r [])
 
firstChild ::
           (Monad mn, CTreeWalker this, CNode zz) =>
             Expression this -> mn (Expression zz)
firstChild thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "firstChild")
       return (CallExpr et r [])
 
lastChild ::
          (Monad mn, CTreeWalker this, CNode zz) =>
            Expression this -> mn (Expression zz)
lastChild thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "lastChild")
       return (CallExpr et r [])
 
previousSibling ::
                (Monad mn, CTreeWalker this, CNode zz) =>
                  Expression this -> mn (Expression zz)
previousSibling thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "previousSibling")
       return (CallExpr et r [])
 
nextSibling ::
            (Monad mn, CTreeWalker this, CNode zz) =>
              Expression this -> mn (Expression zz)
nextSibling thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "nextSibling")
       return (CallExpr et r [])
 
previousNode ::
             (Monad mn, CTreeWalker this, CNode zz) =>
               Expression this -> mn (Expression zz)
previousNode thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "previousNode")
       return (CallExpr et r [])
 
nextNode ::
         (Monad mn, CTreeWalker this, CNode zz) =>
           Expression this -> mn (Expression zz)
nextNode thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "nextNode")
       return (CallExpr et r [])
 
get'root ::
         (Monad mn, CTreeWalker this, CNode zz) =>
           Expression this -> mn (Expression zz)
get'root thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "root")
       return r
 
getm'root ::
          (Monad mn, CTreeWalker this) =>
            Expression this -> mn (Expression TNode)
getm'root = get'root
 
get'whatToShow ::
               (Monad mn, CTreeWalker this) =>
                 Expression this -> mn (Expression Double)
get'whatToShow thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "whatToShow")
       return r
 
getm'whatToShow ::
                (Monad mn, CTreeWalker this) =>
                  Expression this -> mn (Expression Double)
getm'whatToShow = get'whatToShow
 
get'filter ::
           (Monad mn, CTreeWalker this, CNodeFilter zz) =>
             Expression this -> mn (Expression zz)
get'filter thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "filter")
       return r
 
getm'filter ::
            (Monad mn, CTreeWalker this) =>
              Expression this -> mn (Expression TNodeFilter)
getm'filter = get'filter
 
get'expandEntityReferences ::
                           (Monad mn, CTreeWalker this) =>
                             Expression this -> mn (Expression Bool)
get'expandEntityReferences thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "expandEntityReferences")
       return r
 
getm'expandEntityReferences ::
                            (Monad mn, CTreeWalker this) =>
                              Expression this -> mn (Expression Bool)
getm'expandEntityReferences = get'expandEntityReferences
 
set'currentNode ::
                (Monad mn, CNode val, CTreeWalker zz) =>
                  Expression val -> Expression zz -> mn (Expression zz)
set'currentNode = setjsProperty "currentNode"
 
get'currentNode ::
                (Monad mn, CTreeWalker this, CNode zz) =>
                  Expression this -> mn (Expression zz)
get'currentNode thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "currentNode")
       return r
 
getm'currentNode ::
                 (Monad mn, CTreeWalker this) =>
                   Expression this -> mn (Expression TNode)
getm'currentNode = get'currentNode