module Data.DOM.Range
       (setStart, setEnd, setStartBefore, setStartAfter, setEndBefore,
        setEndAfter, collapse, selectNode, selectNodeContents,
        compareBoundaryPoints, deleteContents, extractContents,
        cloneContents, insertNode, surroundContents, cloneRange, toString,
        detach, cSTART_TO_START, cSTART_TO_END, cEND_TO_END, cEND_TO_START,
        get'startContainer, getm'startContainer, get'startOffset,
        getm'startOffset, get'endContainer, getm'endContainer,
        get'endOffset, getm'endOffset, get'collapsed, getm'collapsed,
        get'commonAncestorContainer, getm'commonAncestorContainer)
       where
import Data.DOM.Ranges
import Control.Monad
import BrownPLT.JavaScript
import Data.DOM.WBTypes
import Data.DOM.Dom
import Data.DOM.Document (createElement)
 
setStart ::
         (Monad mn, CRange this, CNode refNode) =>
           Expression refNode ->
             Expression Double -> Expression this -> mn (Expression ())
setStart a b thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "setStart")
       return (CallExpr et r [a /\ et, b /\ et])
 
setEnd ::
       (Monad mn, CRange this, CNode refNode) =>
         Expression refNode ->
           Expression Double -> Expression this -> mn (Expression ())
setEnd a b thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "setEnd")
       return (CallExpr et r [a /\ et, b /\ et])
 
setStartBefore ::
               (Monad mn, CRange this, CNode refNode) =>
                 Expression refNode -> Expression this -> mn (Expression ())
setStartBefore a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "setStartBefore")
       return (CallExpr et r [a /\ et])
 
setStartAfter ::
              (Monad mn, CRange this, CNode refNode) =>
                Expression refNode -> Expression this -> mn (Expression ())
setStartAfter a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "setStartAfter")
       return (CallExpr et r [a /\ et])
 
setEndBefore ::
             (Monad mn, CRange this, CNode refNode) =>
               Expression refNode -> Expression this -> mn (Expression ())
setEndBefore a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "setEndBefore")
       return (CallExpr et r [a /\ et])
 
setEndAfter ::
            (Monad mn, CRange this, CNode refNode) =>
              Expression refNode -> Expression this -> mn (Expression ())
setEndAfter a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "setEndAfter")
       return (CallExpr et r [a /\ et])
 
collapse ::
         (Monad mn, CRange this) =>
           Expression Bool -> Expression this -> mn (Expression ())
collapse a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "collapse")
       return (CallExpr et r [a /\ et])
 
selectNode ::
           (Monad mn, CRange this, CNode refNode) =>
             Expression refNode -> Expression this -> mn (Expression ())
selectNode a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "selectNode")
       return (CallExpr et r [a /\ et])
 
selectNodeContents ::
                   (Monad mn, CRange this, CNode refNode) =>
                     Expression refNode -> Expression this -> mn (Expression ())
selectNodeContents a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "selectNodeContents")
       return (CallExpr et r [a /\ et])
 
compareBoundaryPoints ::
                      (Monad mn, CRange this, CRange sourceRange) =>
                        Expression Double ->
                          Expression sourceRange -> Expression this -> mn (Expression Double)
compareBoundaryPoints a b thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "compareBoundaryPoints")
       return (CallExpr et r [a /\ et, b /\ et])
 
deleteContents ::
               (Monad mn, CRange this) => Expression this -> mn (Expression ())
deleteContents thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "deleteContents")
       return (CallExpr et r [])
 
extractContents ::
                (Monad mn, CRange this, CDocumentFragment zz) =>
                  Expression this -> mn (Expression zz)
extractContents thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "extractContents")
       return (CallExpr et r [])
 
cloneContents ::
              (Monad mn, CRange this, CDocumentFragment zz) =>
                Expression this -> mn (Expression zz)
cloneContents thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "cloneContents")
       return (CallExpr et r [])
 
insertNode ::
           (Monad mn, CRange this, CNode newNode) =>
             Expression newNode -> Expression this -> mn (Expression ())
insertNode a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "insertNode")
       return (CallExpr et r [a /\ et])
 
surroundContents ::
                 (Monad mn, CRange this, CNode newParent) =>
                   Expression newParent -> Expression this -> mn (Expression ())
surroundContents a thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "surroundContents")
       return (CallExpr et r [a /\ et])
 
cloneRange ::
           (Monad mn, CRange this, CRange zz) =>
             Expression this -> mn (Expression zz)
cloneRange thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "cloneRange")
       return (CallExpr et r [])
 
toString ::
         (Monad mn, CRange this) =>
           Expression this -> mn (Expression String)
toString thisp
  = do let et = undefined :: String
       let r = DotRef et (thisp /\ et) (Id et "toString")
       return (CallExpr et r [])
 
detach ::
       (Monad mn, CRange this) => Expression this -> mn (Expression ())
detach thisp
  = do let et = undefined :: ()
       let r = DotRef et (thisp /\ et) (Id et "detach")
       return (CallExpr et r [])
cSTART_TO_START = 0
cSTART_TO_END = 1
cEND_TO_END = 2
cEND_TO_START = 3
 
get'startContainer ::
                   (Monad mn, CRange this, CNode zz) =>
                     Expression this -> mn (Expression zz)
get'startContainer thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "startContainer")
       return r
 
getm'startContainer ::
                    (Monad mn, CRange this) => Expression this -> mn (Expression TNode)
getm'startContainer = get'startContainer
 
get'startOffset ::
                (Monad mn, CRange this) =>
                  Expression this -> mn (Expression Double)
get'startOffset thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "startOffset")
       return r
 
getm'startOffset ::
                 (Monad mn, CRange this) =>
                   Expression this -> mn (Expression Double)
getm'startOffset = get'startOffset
 
get'endContainer ::
                 (Monad mn, CRange this, CNode zz) =>
                   Expression this -> mn (Expression zz)
get'endContainer thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "endContainer")
       return r
 
getm'endContainer ::
                  (Monad mn, CRange this) => Expression this -> mn (Expression TNode)
getm'endContainer = get'endContainer
 
get'endOffset ::
              (Monad mn, CRange this) =>
                Expression this -> mn (Expression Double)
get'endOffset thisp
  = do let et = undefined :: Double
       let r = DotRef et (thisp /\ et) (Id et "endOffset")
       return r
 
getm'endOffset ::
               (Monad mn, CRange this) =>
                 Expression this -> mn (Expression Double)
getm'endOffset = get'endOffset
 
get'collapsed ::
              (Monad mn, CRange this) => Expression this -> mn (Expression Bool)
get'collapsed thisp
  = do let et = undefined :: Bool
       let r = DotRef et (thisp /\ et) (Id et "collapsed")
       return r
 
getm'collapsed ::
               (Monad mn, CRange this) => Expression this -> mn (Expression Bool)
getm'collapsed = get'collapsed
 
get'commonAncestorContainer ::
                            (Monad mn, CRange this, CNode zz) =>
                              Expression this -> mn (Expression zz)
get'commonAncestorContainer thisp
  = do let et = undefined :: zz
       let r = DotRef et (thisp /\ et) (Id et "commonAncestorContainer")
       return r
 
getm'commonAncestorContainer ::
                             (Monad mn, CRange this) => Expression this -> mn (Expression TNode)
getm'commonAncestorContainer = get'commonAncestorContainer