module Data.DOM.NodeIterator
       (nextNode, previousNode, detach, get'root, getm'root,
        get'whatToShow, getm'whatToShow, get'filter, getm'filter,
        get'expandEntityReferences, getm'expandEntityReferences)
       where
import Data.DOM.Traversal
import Control.Monad
import BrownPLT.JavaScript
import Data.DOM.WBTypes
import Data.DOM.Dom
import Data.DOM.Document (createElement)
 
nextNode ::
         (Monad mn, CNodeIterator 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 [])
 
previousNode ::
             (Monad mn, CNodeIterator 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 [])
 
detach ::
       (Monad mn, CNodeIterator this) =>
         Expression this -> mn (Expression ())
detach thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "detach")
       return (CallExpr et r [])
 
get'root ::
         (Monad mn, CNodeIterator 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, CNodeIterator this) =>
            Expression this -> mn (Expression TNode)
getm'root = get'root
 
get'whatToShow ::
               (Monad mn, CNodeIterator 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, CNodeIterator this) =>
                  Expression this -> mn (Expression Double)
getm'whatToShow = get'whatToShow
 
get'filter ::
           (Monad mn, CNodeIterator 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, CNodeIterator this) =>
              Expression this -> mn (Expression TNodeFilter)
getm'filter = get'filter
 
get'expandEntityReferences ::
                           (Monad mn, CNodeIterator 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, CNodeIterator this) =>
                              Expression this -> mn (Expression Bool)
getm'expandEntityReferences = get'expandEntityReferences