content: {-# LANGUAGE PatternSynonyms #-}
  {-# LANGUAGE ForeignFunctionInterface #-}
  {-# LANGUAGE JavaScriptFFI #-}
  -- For HasCallStack compatibility
  {-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
  module GHCJS.DOM.JSFFI.Generated.Document
         (js_getAnimations, getAnimations, getAnimations_, js_newDocument,
          newDocument, js_getElementsByTagName, getElementsByTagName,
          getElementsByTagName_, js_getElementsByTagNameNS,
          getElementsByTagNameNS, getElementsByTagNameNS_,
          js_getElementsByClassName, getElementsByClassName,
          getElementsByClassName_, js_createElement, createElement,
          createElement_, js_createElementNS, createElementNS,
          createElementNS_, js_createDocumentFragment,
          createDocumentFragment, createDocumentFragment_, js_createTextNode,
          createTextNode, createTextNode_, js_createCDATASection,
          createCDATASection, createCDATASection_, js_createComment,
          createComment, createComment_, js_createProcessingInstruction,
          createProcessingInstruction, createProcessingInstruction_,
          js_importNode, importNode, importNode_, js_adoptNode, adoptNode,
          adoptNode_, js_createAttribute, createAttribute, createAttribute_,
          js_createAttributeNS, createAttributeNS, createAttributeNS_,
          js_createEvent, createEvent, createEvent_, js_createRange,
          createRange, createRange_, js_createNodeIterator,
          createNodeIterator, createNodeIterator_, js_createTreeWalker,
          createTreeWalker, createTreeWalker_, js_getElementsByName,
          getElementsByName, getElementsByName_, js_hasFocus, hasFocus,
          hasFocus_, js_execCommand, execCommand, execCommand_,
          js_queryCommandEnabled, queryCommandEnabled, queryCommandEnabled_,
          js_queryCommandIndeterm, queryCommandIndeterm,
          queryCommandIndeterm_, js_queryCommandState, queryCommandState,
          queryCommandState_, js_queryCommandSupported,
          queryCommandSupported, queryCommandSupported_,
          js_queryCommandValue, queryCommandValue, queryCommandValue_,
          js_getSelection, getSelection, getSelection_, getSelectionUnsafe,
          getSelectionUnchecked, js_createExpression, createExpression,
          createExpression_, js_createNSResolver, createNSResolver,
          createNSResolver_, js_evaluate, evaluate, evaluate_,
          js_webkitExitFullscreen, webkitExitFullscreen,
          js_webkitCancelFullScreen, webkitCancelFullScreen,
          js_exitPointerLock, exitPointerLock, js_getOverrideStyle,
          getOverrideStyle, getOverrideStyle_, js_caretRangeFromPoint,
          caretRangeFromPoint, caretRangeFromPoint_, js_getCSSCanvasContext,
          getCSSCanvasContext, getCSSCanvasContext_, js_webkitGetNamedFlows,
          webkitGetNamedFlows, webkitGetNamedFlows_, js_createTouch,
          createTouch, createTouch_, js_createTouchList, createTouchList,
          createTouchList_, js_getTimeline, getTimeline,
          js_getImplementation, getImplementation, js_getURL, getURL,
          js_getDocumentURI, getDocumentURI, js_getOrigin, getOrigin,
          js_getCompatMode, getCompatMode, js_getCharacterSet,
          getCharacterSet, js_getCharset, getCharset, js_getInputEncoding,
          getInputEncoding, js_getContentType, getContentType, js_getDoctype,
          getDoctype, getDoctypeUnsafe, getDoctypeUnchecked,
          js_getDocumentElement, getDocumentElement,
          getDocumentElementUnsafe, getDocumentElementUnchecked,
          js_getLocation, getLocation, getLocationUnsafe,
          getLocationUnchecked, js_setDomain, setDomain, js_getDomain,
          getDomain, js_getReferrer, getReferrer, js_setCookie, setCookie,
          js_getCookie, getCookie, js_getLastModified, getLastModified,
          js_getReadyState, getReadyState, js_setTitle, setTitle,
          js_getTitle, getTitle, js_setDir, setDir, js_getDir, getDir,
          js_setBody, setBody, js_getBody, getBody, getBodyUnsafe,
          getBodyUnchecked, js_getHead, getHead, getHeadUnsafe,
          getHeadUnchecked, js_getImages, getImages, js_getEmbeds, getEmbeds,
          js_getPlugins, getPlugins, js_getLinks, getLinks, js_getForms,
          getForms, js_getScripts, getScripts, js_getCurrentScript,
          getCurrentScript, getCurrentScriptUnsafe,
          getCurrentScriptUnchecked, js_getDefaultView, getDefaultView,
          getDefaultViewUnsafe, getDefaultViewUnchecked, js_setDesignMode,
          setDesignMode, js_getDesignMode, getDesignMode, readyStateChange,
          js_getStyleSheets, getStyleSheets, js_getScrollingElement,
          getScrollingElement, getScrollingElementUnsafe,
          getScrollingElementUnchecked, js_getWebkitFullscreenEnabled,
          getWebkitFullscreenEnabled, js_getWebkitFullscreenElement,
          getWebkitFullscreenElement, getWebkitFullscreenElementUnsafe,
          getWebkitFullscreenElementUnchecked, js_getWebkitIsFullScreen,
          getWebkitIsFullScreen, js_getWebkitFullScreenKeyboardInputAllowed,
          getWebkitFullScreenKeyboardInputAllowed,
          js_getWebkitCurrentFullScreenElement,
          getWebkitCurrentFullScreenElement, webKitFullscreenChange,
          webKitFullscreenError, pointerlockchange, pointerlockerror,
          js_getFonts, getFonts, js_getHidden, getHidden,
          js_getVisibilityState, getVisibilityState, visibilitychange,
          js_getApplets, getApplets, js_getAnchors, getAnchors,
          js_getPreferredStylesheetSet, getPreferredStylesheetSet,
          getPreferredStylesheetSetUnsafe,
          getPreferredStylesheetSetUnchecked, js_setSelectedStylesheetSet,
          setSelectedStylesheetSet, js_getSelectedStylesheetSet,
          getSelectedStylesheetSet, getSelectedStylesheetSetUnsafe,
          getSelectedStylesheetSetUnchecked, js_getXmlEncoding,
          getXmlEncoding, getXmlEncodingUnsafe, getXmlEncodingUnchecked,
          js_setXmlVersion, setXmlVersion, js_getXmlVersion, getXmlVersion,
          getXmlVersionUnsafe, getXmlVersionUnchecked, js_setXmlStandalone,
          setXmlStandalone, js_getXmlStandalone, getXmlStandalone,
          selectStart, selectionchange, js_getRootElement, getRootElement,
          getRootElementUnsafe, getRootElementUnchecked, Document(..),
          gTypeDocument, IsDocument, toDocument)
         where
  import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
  import qualified Prelude (error)
  import Data.Typeable (Typeable)
  import GHCJS.Types (JSVal(..), JSString)
  import GHCJS.Foreign (jsNull, jsUndefined)
  import GHCJS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
  import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
  import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
  import Control.Monad (void)
  import Control.Monad.IO.Class (MonadIO(..))
  import Data.Int (Int64)
  import Data.Word (Word, Word64)
  import Data.Maybe (fromJust)
  import Data.Traversable (mapM)
  import GHCJS.DOM.Types
  import Control.Applicative ((<$>))
  import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
  import GHCJS.DOM.JSFFI.Generated.Enums
   
  foreign import javascript unsafe "$1[\"getAnimations\"]()"
          js_getAnimations :: Document -> IO JSVal
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getAnimations Mozilla Document.getAnimations documentation> 
  getAnimations ::
                (MonadIO m, IsDocument self) => self -> m [Animation]
  getAnimations self
    = liftIO
        ((js_getAnimations (toDocument self)) >>= fromJSValUnchecked)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getAnimations Mozilla Document.getAnimations documentation> 
  getAnimations_ :: (MonadIO m, IsDocument self) => self -> m ()
  getAnimations_ self
    = liftIO (void (js_getAnimations (toDocument self)))
   
  foreign import javascript unsafe "new window[\"Document\"]()"
          js_newDocument :: IO Document
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document Mozilla Document documentation> 
  newDocument :: (MonadIO m) => m Document
  newDocument = liftIO (js_newDocument)
   
  foreign import javascript unsafe "$1[\"getElementsByTagName\"]($2)"
          js_getElementsByTagName ::
          Document -> JSString -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagName Mozilla Document.getElementsByTagName documentation> 
  getElementsByTagName ::
                       (MonadIO m, IsDocument self, ToJSString qualifiedName) =>
                         self -> qualifiedName -> m HTMLCollection
  getElementsByTagName self qualifiedName
    = liftIO
        (js_getElementsByTagName (toDocument self)
           (toJSString qualifiedName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagName Mozilla Document.getElementsByTagName documentation> 
  getElementsByTagName_ ::
                        (MonadIO m, IsDocument self, ToJSString qualifiedName) =>
                          self -> qualifiedName -> m ()
  getElementsByTagName_ self qualifiedName
    = liftIO
        (void
           (js_getElementsByTagName (toDocument self)
              (toJSString qualifiedName)))
   
  foreign import javascript unsafe
          "$1[\"getElementsByTagNameNS\"]($2,\n$3)" js_getElementsByTagNameNS
          :: Document -> Optional JSString -> JSString -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagNameNS Mozilla Document.getElementsByTagNameNS documentation> 
  getElementsByTagNameNS ::
                         (MonadIO m, IsDocument self, ToJSString namespaceURI,
                          ToJSString localName) =>
                           self -> Maybe namespaceURI -> localName -> m HTMLCollection
  getElementsByTagNameNS self namespaceURI localName
    = liftIO
        (js_getElementsByTagNameNS (toDocument self)
           (toOptionalJSString namespaceURI)
           (toJSString localName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagNameNS Mozilla Document.getElementsByTagNameNS documentation> 
  getElementsByTagNameNS_ ::
                          (MonadIO m, IsDocument self, ToJSString namespaceURI,
                           ToJSString localName) =>
                            self -> Maybe namespaceURI -> localName -> m ()
  getElementsByTagNameNS_ self namespaceURI localName
    = liftIO
        (void
           (js_getElementsByTagNameNS (toDocument self)
              (toOptionalJSString namespaceURI)
              (toJSString localName)))
   
  foreign import javascript unsafe
          "$1[\"getElementsByClassName\"]($2)" js_getElementsByClassName ::
          Document -> JSString -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByClassName Mozilla Document.getElementsByClassName documentation> 
  getElementsByClassName ::
                         (MonadIO m, IsDocument self, ToJSString classNames) =>
                           self -> classNames -> m HTMLCollection
  getElementsByClassName self classNames
    = liftIO
        (js_getElementsByClassName (toDocument self)
           (toJSString classNames))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByClassName Mozilla Document.getElementsByClassName documentation> 
  getElementsByClassName_ ::
                          (MonadIO m, IsDocument self, ToJSString classNames) =>
                            self -> classNames -> m ()
  getElementsByClassName_ self classNames
    = liftIO
        (void
           (js_getElementsByClassName (toDocument self)
              (toJSString classNames)))
   
  foreign import javascript safe "$1[\"createElement\"]($2)"
          js_createElement :: Document -> JSString -> IO Element
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElement Mozilla Document.createElement documentation> 
  createElement ::
                (MonadIO m, IsDocument self, ToJSString localName) =>
                  self -> localName -> m Element
  createElement self localName
    = liftIO
        (js_createElement (toDocument self) (toJSString localName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElement Mozilla Document.createElement documentation> 
  createElement_ ::
                 (MonadIO m, IsDocument self, ToJSString localName) =>
                   self -> localName -> m ()
  createElement_ self localName
    = liftIO
        (void (js_createElement (toDocument self) (toJSString localName)))
   
  foreign import javascript safe "$1[\"createElementNS\"]($2, $3)"
          js_createElementNS ::
          Document -> Optional JSString -> JSString -> IO Element
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElementNS Mozilla Document.createElementNS documentation> 
  createElementNS ::
                  (MonadIO m, IsDocument self, ToJSString namespaceURI,
                   ToJSString qualifiedName) =>
                    self -> Maybe namespaceURI -> qualifiedName -> m Element
  createElementNS self namespaceURI qualifiedName
    = liftIO
        (js_createElementNS (toDocument self)
           (toOptionalJSString namespaceURI)
           (toJSString qualifiedName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElementNS Mozilla Document.createElementNS documentation> 
  createElementNS_ ::
                   (MonadIO m, IsDocument self, ToJSString namespaceURI,
                    ToJSString qualifiedName) =>
                     self -> Maybe namespaceURI -> qualifiedName -> m ()
  createElementNS_ self namespaceURI qualifiedName
    = liftIO
        (void
           (js_createElementNS (toDocument self)
              (toOptionalJSString namespaceURI)
              (toJSString qualifiedName)))
   
  foreign import javascript unsafe "$1[\"createDocumentFragment\"]()"
          js_createDocumentFragment :: Document -> IO DocumentFragment
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createDocumentFragment Mozilla Document.createDocumentFragment documentation> 
  createDocumentFragment ::
                         (MonadIO m, IsDocument self) => self -> m DocumentFragment
  createDocumentFragment self
    = liftIO (js_createDocumentFragment (toDocument self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createDocumentFragment Mozilla Document.createDocumentFragment documentation> 
  createDocumentFragment_ ::
                          (MonadIO m, IsDocument self) => self -> m ()
  createDocumentFragment_ self
    = liftIO (void (js_createDocumentFragment (toDocument self)))
   
  foreign import javascript unsafe "$1[\"createTextNode\"]($2)"
          js_createTextNode :: Document -> JSString -> IO Text
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTextNode Mozilla Document.createTextNode documentation> 
  createTextNode ::
                 (MonadIO m, IsDocument self, ToJSString data') =>
                   self -> data' -> m Text
  createTextNode self data'
    = liftIO (js_createTextNode (toDocument self) (toJSString data'))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTextNode Mozilla Document.createTextNode documentation> 
  createTextNode_ ::
                  (MonadIO m, IsDocument self, ToJSString data') =>
                    self -> data' -> m ()
  createTextNode_ self data'
    = liftIO
        (void (js_createTextNode (toDocument self) (toJSString data')))
   
  foreign import javascript safe "$1[\"createCDATASection\"]($2)"
          js_createCDATASection :: Document -> JSString -> IO CDATASection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createCDATASection Mozilla Document.createCDATASection documentation> 
  createCDATASection ::
                     (MonadIO m, IsDocument self, ToJSString data') =>
                       self -> data' -> m CDATASection
  createCDATASection self data'
    = liftIO
        (js_createCDATASection (toDocument self) (toJSString data'))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createCDATASection Mozilla Document.createCDATASection documentation> 
  createCDATASection_ ::
                      (MonadIO m, IsDocument self, ToJSString data') =>
                        self -> data' -> m ()
  createCDATASection_ self data'
    = liftIO
        (void (js_createCDATASection (toDocument self) (toJSString data')))
   
  foreign import javascript unsafe "$1[\"createComment\"]($2)"
          js_createComment :: Document -> JSString -> IO Comment
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createComment Mozilla Document.createComment documentation> 
  createComment ::
                (MonadIO m, IsDocument self, ToJSString data') =>
                  self -> data' -> m Comment
  createComment self data'
    = liftIO (js_createComment (toDocument self) (toJSString data'))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createComment Mozilla Document.createComment documentation> 
  createComment_ ::
                 (MonadIO m, IsDocument self, ToJSString data') =>
                   self -> data' -> m ()
  createComment_ self data'
    = liftIO
        (void (js_createComment (toDocument self) (toJSString data')))
   
  foreign import javascript safe
          "$1[\"createProcessingInstruction\"]($2,\n$3)"
          js_createProcessingInstruction ::
          Document -> JSString -> JSString -> IO ProcessingInstruction
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createProcessingInstruction Mozilla Document.createProcessingInstruction documentation> 
  createProcessingInstruction ::
                              (MonadIO m, IsDocument self, ToJSString target,
                               ToJSString data') =>
                                self -> target -> data' -> m ProcessingInstruction
  createProcessingInstruction self target data'
    = liftIO
        (js_createProcessingInstruction (toDocument self)
           (toJSString target)
           (toJSString data'))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createProcessingInstruction Mozilla Document.createProcessingInstruction documentation> 
  createProcessingInstruction_ ::
                               (MonadIO m, IsDocument self, ToJSString target,
                                ToJSString data') =>
                                 self -> target -> data' -> m ()
  createProcessingInstruction_ self target data'
    = liftIO
        (void
           (js_createProcessingInstruction (toDocument self)
              (toJSString target)
              (toJSString data')))
   
  foreign import javascript safe "$1[\"importNode\"]($2, $3)"
          js_importNode :: Document -> Node -> Bool -> IO Node
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.importNode Mozilla Document.importNode documentation> 
  importNode ::
             (MonadIO m, IsDocument self, IsNode node) =>
               self -> node -> Bool -> m Node
  importNode self node deep
    = liftIO (js_importNode (toDocument self) (toNode node) deep)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.importNode Mozilla Document.importNode documentation> 
  importNode_ ::
              (MonadIO m, IsDocument self, IsNode node) =>
                self -> node -> Bool -> m ()
  importNode_ self node deep
    = liftIO
        (void (js_importNode (toDocument self) (toNode node) deep))
   
  foreign import javascript safe "$1[\"adoptNode\"]($2)" js_adoptNode
          :: Document -> Node -> IO Node
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.adoptNode Mozilla Document.adoptNode documentation> 
  adoptNode ::
            (MonadIO m, IsDocument self, IsNode node) => self -> node -> m Node
  adoptNode self node
    = liftIO (js_adoptNode (toDocument self) (toNode node))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.adoptNode Mozilla Document.adoptNode documentation> 
  adoptNode_ ::
             (MonadIO m, IsDocument self, IsNode node) => self -> node -> m ()
  adoptNode_ self node
    = liftIO (void (js_adoptNode (toDocument self) (toNode node)))
   
  foreign import javascript safe "$1[\"createAttribute\"]($2)"
          js_createAttribute :: Document -> JSString -> IO Attr
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttribute Mozilla Document.createAttribute documentation> 
  createAttribute ::
                  (MonadIO m, IsDocument self, ToJSString localName) =>
                    self -> localName -> m Attr
  createAttribute self localName
    = liftIO
        (js_createAttribute (toDocument self) (toJSString localName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttribute Mozilla Document.createAttribute documentation> 
  createAttribute_ ::
                   (MonadIO m, IsDocument self, ToJSString localName) =>
                     self -> localName -> m ()
  createAttribute_ self localName
    = liftIO
        (void
           (js_createAttribute (toDocument self) (toJSString localName)))
   
  foreign import javascript safe "$1[\"createAttributeNS\"]($2, $3)"
          js_createAttributeNS ::
          Document -> Optional JSString -> JSString -> IO Attr
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttributeNS Mozilla Document.createAttributeNS documentation> 
  createAttributeNS ::
                    (MonadIO m, IsDocument self, ToJSString namespaceURI,
                     ToJSString qualifiedName) =>
                      self -> Maybe namespaceURI -> qualifiedName -> m Attr
  createAttributeNS self namespaceURI qualifiedName
    = liftIO
        (js_createAttributeNS (toDocument self)
           (toOptionalJSString namespaceURI)
           (toJSString qualifiedName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttributeNS Mozilla Document.createAttributeNS documentation> 
  createAttributeNS_ ::
                     (MonadIO m, IsDocument self, ToJSString namespaceURI,
                      ToJSString qualifiedName) =>
                       self -> Maybe namespaceURI -> qualifiedName -> m ()
  createAttributeNS_ self namespaceURI qualifiedName
    = liftIO
        (void
           (js_createAttributeNS (toDocument self)
              (toOptionalJSString namespaceURI)
              (toJSString qualifiedName)))
   
  foreign import javascript safe "$1[\"createEvent\"]($2)"
          js_createEvent :: Document -> JSString -> IO Event
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createEvent Mozilla Document.createEvent documentation> 
  createEvent ::
              (MonadIO m, IsDocument self, ToJSString type') =>
                self -> type' -> m Event
  createEvent self type'
    = liftIO (js_createEvent (toDocument self) (toJSString type'))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createEvent Mozilla Document.createEvent documentation> 
  createEvent_ ::
               (MonadIO m, IsDocument self, ToJSString type') =>
                 self -> type' -> m ()
  createEvent_ self type'
    = liftIO
        (void (js_createEvent (toDocument self) (toJSString type')))
   
  foreign import javascript unsafe "$1[\"createRange\"]()"
          js_createRange :: Document -> IO Range
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createRange Mozilla Document.createRange documentation> 
  createRange :: (MonadIO m, IsDocument self) => self -> m Range
  createRange self = liftIO (js_createRange (toDocument self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createRange Mozilla Document.createRange documentation> 
  createRange_ :: (MonadIO m, IsDocument self) => self -> m ()
  createRange_ self
    = liftIO (void (js_createRange (toDocument self)))
   
  foreign import javascript unsafe
          "$1[\"createNodeIterator\"]($2, $3,\n$4)" js_createNodeIterator ::
          Document ->
            Node -> Optional Word -> Optional NodeFilter -> IO NodeIterator
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNodeIterator Mozilla Document.createNodeIterator documentation> 
  createNodeIterator ::
                     (MonadIO m, IsDocument self, IsNode root) =>
                       self -> root -> Maybe Word -> Maybe NodeFilter -> m NodeIterator
  createNodeIterator self root whatToShow filter
    = liftIO
        (js_createNodeIterator (toDocument self) (toNode root)
           (maybeToOptional whatToShow)
           (maybeToOptional filter))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNodeIterator Mozilla Document.createNodeIterator documentation> 
  createNodeIterator_ ::
                      (MonadIO m, IsDocument self, IsNode root) =>
                        self -> root -> Maybe Word -> Maybe NodeFilter -> m ()
  createNodeIterator_ self root whatToShow filter
    = liftIO
        (void
           (js_createNodeIterator (toDocument self) (toNode root)
              (maybeToOptional whatToShow)
              (maybeToOptional filter)))
   
  foreign import javascript unsafe
          "$1[\"createTreeWalker\"]($2, $3,\n$4)" js_createTreeWalker ::
          Document ->
            Node -> Optional Word -> Optional NodeFilter -> IO TreeWalker
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTreeWalker Mozilla Document.createTreeWalker documentation> 
  createTreeWalker ::
                   (MonadIO m, IsDocument self, IsNode root) =>
                     self -> root -> Maybe Word -> Maybe NodeFilter -> m TreeWalker
  createTreeWalker self root whatToShow filter
    = liftIO
        (js_createTreeWalker (toDocument self) (toNode root)
           (maybeToOptional whatToShow)
           (maybeToOptional filter))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTreeWalker Mozilla Document.createTreeWalker documentation> 
  createTreeWalker_ ::
                    (MonadIO m, IsDocument self, IsNode root) =>
                      self -> root -> Maybe Word -> Maybe NodeFilter -> m ()
  createTreeWalker_ self root whatToShow filter
    = liftIO
        (void
           (js_createTreeWalker (toDocument self) (toNode root)
              (maybeToOptional whatToShow)
              (maybeToOptional filter)))
   
  foreign import javascript unsafe "$1[\"getElementsByName\"]($2)"
          js_getElementsByName :: Document -> JSString -> IO NodeList
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByName Mozilla Document.getElementsByName documentation> 
  getElementsByName ::
                    (MonadIO m, IsDocument self, ToJSString elementName) =>
                      self -> elementName -> m NodeList
  getElementsByName self elementName
    = liftIO
        (js_getElementsByName (toDocument self) (toJSString elementName))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByName Mozilla Document.getElementsByName documentation> 
  getElementsByName_ ::
                     (MonadIO m, IsDocument self, ToJSString elementName) =>
                       self -> elementName -> m ()
  getElementsByName_ self elementName
    = liftIO
        (void
           (js_getElementsByName (toDocument self) (toJSString elementName)))
   
  foreign import javascript unsafe "($1[\"hasFocus\"]() ? 1 : 0)"
          js_hasFocus :: Document -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.hasFocus Mozilla Document.hasFocus documentation> 
  hasFocus :: (MonadIO m, IsDocument self) => self -> m Bool
  hasFocus self = liftIO (js_hasFocus (toDocument self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.hasFocus Mozilla Document.hasFocus documentation> 
  hasFocus_ :: (MonadIO m, IsDocument self) => self -> m ()
  hasFocus_ self = liftIO (void (js_hasFocus (toDocument self)))
   
  foreign import javascript unsafe
          "($1[\"execCommand\"]($2, $3,\n$4) ? 1 : 0)" js_execCommand ::
          Document -> JSString -> Bool -> Optional JSString -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.execCommand Mozilla Document.execCommand documentation> 
  execCommand ::
              (MonadIO m, IsDocument self, ToJSString commandId,
               ToJSString value) =>
                self -> commandId -> Bool -> Maybe value -> m Bool
  execCommand self commandId showUI value
    = liftIO
        (js_execCommand (toDocument self) (toJSString commandId) showUI
           (toOptionalJSString value))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.execCommand Mozilla Document.execCommand documentation> 
  execCommand_ ::
               (MonadIO m, IsDocument self, ToJSString commandId,
                ToJSString value) =>
                 self -> commandId -> Bool -> Maybe value -> m ()
  execCommand_ self commandId showUI value
    = liftIO
        (void
           (js_execCommand (toDocument self) (toJSString commandId) showUI
              (toOptionalJSString value)))
   
  foreign import javascript unsafe
          "($1[\"queryCommandEnabled\"]($2) ? 1 : 0)" js_queryCommandEnabled
          :: Document -> JSString -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandEnabled Mozilla Document.queryCommandEnabled documentation> 
  queryCommandEnabled ::
                      (MonadIO m, IsDocument self, ToJSString commandId) =>
                        self -> commandId -> m Bool
  queryCommandEnabled self commandId
    = liftIO
        (js_queryCommandEnabled (toDocument self) (toJSString commandId))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandEnabled Mozilla Document.queryCommandEnabled documentation> 
  queryCommandEnabled_ ::
                       (MonadIO m, IsDocument self, ToJSString commandId) =>
                         self -> commandId -> m ()
  queryCommandEnabled_ self commandId
    = liftIO
        (void
           (js_queryCommandEnabled (toDocument self) (toJSString commandId)))
   
  foreign import javascript unsafe
          "($1[\"queryCommandIndeterm\"]($2) ? 1 : 0)"
          js_queryCommandIndeterm :: Document -> JSString -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandIndeterm Mozilla Document.queryCommandIndeterm documentation> 
  queryCommandIndeterm ::
                       (MonadIO m, IsDocument self, ToJSString commandId) =>
                         self -> commandId -> m Bool
  queryCommandIndeterm self commandId
    = liftIO
        (js_queryCommandIndeterm (toDocument self) (toJSString commandId))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandIndeterm Mozilla Document.queryCommandIndeterm documentation> 
  queryCommandIndeterm_ ::
                        (MonadIO m, IsDocument self, ToJSString commandId) =>
                          self -> commandId -> m ()
  queryCommandIndeterm_ self commandId
    = liftIO
        (void
           (js_queryCommandIndeterm (toDocument self) (toJSString commandId)))
   
  foreign import javascript unsafe
          "($1[\"queryCommandState\"]($2) ? 1 : 0)" js_queryCommandState ::
          Document -> JSString -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandState Mozilla Document.queryCommandState documentation> 
  queryCommandState ::
                    (MonadIO m, IsDocument self, ToJSString commandId) =>
                      self -> commandId -> m Bool
  queryCommandState self commandId
    = liftIO
        (js_queryCommandState (toDocument self) (toJSString commandId))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandState Mozilla Document.queryCommandState documentation> 
  queryCommandState_ ::
                     (MonadIO m, IsDocument self, ToJSString commandId) =>
                       self -> commandId -> m ()
  queryCommandState_ self commandId
    = liftIO
        (void
           (js_queryCommandState (toDocument self) (toJSString commandId)))
   
  foreign import javascript unsafe
          "($1[\"queryCommandSupported\"]($2) ? 1 : 0)"
          js_queryCommandSupported :: Document -> JSString -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandSupported Mozilla Document.queryCommandSupported documentation> 
  queryCommandSupported ::
                        (MonadIO m, IsDocument self, ToJSString commandId) =>
                          self -> commandId -> m Bool
  queryCommandSupported self commandId
    = liftIO
        (js_queryCommandSupported (toDocument self) (toJSString commandId))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandSupported Mozilla Document.queryCommandSupported documentation> 
  queryCommandSupported_ ::
                         (MonadIO m, IsDocument self, ToJSString commandId) =>
                           self -> commandId -> m ()
  queryCommandSupported_ self commandId
    = liftIO
        (void
           (js_queryCommandSupported (toDocument self)
              (toJSString commandId)))
   
  foreign import javascript unsafe "$1[\"queryCommandValue\"]($2)"
          js_queryCommandValue :: Document -> JSString -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandValue Mozilla Document.queryCommandValue documentation> 
  queryCommandValue ::
                    (MonadIO m, IsDocument self, ToJSString commandId,
                     FromJSString result) =>
                      self -> commandId -> m result
  queryCommandValue self commandId
    = liftIO
        (fromJSString <$>
           (js_queryCommandValue (toDocument self) (toJSString commandId)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.queryCommandValue Mozilla Document.queryCommandValue documentation> 
  queryCommandValue_ ::
                     (MonadIO m, IsDocument self, ToJSString commandId) =>
                       self -> commandId -> m ()
  queryCommandValue_ self commandId
    = liftIO
        (void
           (js_queryCommandValue (toDocument self) (toJSString commandId)))
   
  foreign import javascript unsafe "$1[\"getSelection\"]()"
          js_getSelection :: Document -> IO (Nullable Selection)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getSelection Mozilla Document.getSelection documentation> 
  getSelection ::
               (MonadIO m, IsDocument self) => self -> m (Maybe Selection)
  getSelection self
    = liftIO (nullableToMaybe <$> (js_getSelection (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getSelection Mozilla Document.getSelection documentation> 
  getSelection_ :: (MonadIO m, IsDocument self) => self -> m ()
  getSelection_ self
    = liftIO (void (js_getSelection (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getSelection Mozilla Document.getSelection documentation> 
  getSelectionUnsafe ::
                     (MonadIO m, IsDocument self, HasCallStack) => self -> m Selection
  getSelectionUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getSelection (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getSelection Mozilla Document.getSelection documentation> 
  getSelectionUnchecked ::
                        (MonadIO m, IsDocument self) => self -> m Selection
  getSelectionUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getSelection (toDocument self)))
   
  foreign import javascript safe "$1[\"createExpression\"]($2, $3)"
          js_createExpression ::
          Document ->
            Optional JSString -> Optional XPathNSResolver -> IO XPathExpression
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createExpression Mozilla Document.createExpression documentation> 
  createExpression ::
                   (MonadIO m, IsDocument self, ToJSString expression) =>
                     self ->
                       Maybe expression -> Maybe XPathNSResolver -> m XPathExpression
  createExpression self expression resolver
    = liftIO
        (js_createExpression (toDocument self)
           (toOptionalJSString expression)
           (maybeToOptional resolver))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createExpression Mozilla Document.createExpression documentation> 
  createExpression_ ::
                    (MonadIO m, IsDocument self, ToJSString expression) =>
                      self -> Maybe expression -> Maybe XPathNSResolver -> m ()
  createExpression_ self expression resolver
    = liftIO
        (void
           (js_createExpression (toDocument self)
              (toOptionalJSString expression)
              (maybeToOptional resolver)))
   
  foreign import javascript unsafe "$1[\"createNSResolver\"]($2)"
          js_createNSResolver ::
          Document -> Optional Node -> IO XPathNSResolver
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNSResolver Mozilla Document.createNSResolver documentation> 
  createNSResolver ::
                   (MonadIO m, IsDocument self, IsNode nodeResolver) =>
                     self -> Maybe nodeResolver -> m XPathNSResolver
  createNSResolver self nodeResolver
    = liftIO
        (js_createNSResolver (toDocument self)
           (maybeToOptional (fmap toNode nodeResolver)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNSResolver Mozilla Document.createNSResolver documentation> 
  createNSResolver_ ::
                    (MonadIO m, IsDocument self, IsNode nodeResolver) =>
                      self -> Maybe nodeResolver -> m ()
  createNSResolver_ self nodeResolver
    = liftIO
        (void
           (js_createNSResolver (toDocument self)
              (maybeToOptional (fmap toNode nodeResolver))))
   
  foreign import javascript safe
          "$1[\"evaluate\"]($2, $3, $4, $5,\n$6)" js_evaluate ::
          Document ->
            Optional JSString ->
              Optional Node ->
                Optional XPathNSResolver ->
                  Optional Word -> Optional XPathResult -> IO XPathResult
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.evaluate Mozilla Document.evaluate documentation> 
  evaluate ::
           (MonadIO m, IsDocument self, ToJSString expression,
            IsNode contextNode) =>
             self ->
               Maybe expression ->
                 Maybe contextNode ->
                   Maybe XPathNSResolver ->
                     Maybe Word -> Maybe XPathResult -> m XPathResult
  evaluate self expression contextNode resolver type' inResult
    = liftIO
        (js_evaluate (toDocument self) (toOptionalJSString expression)
           (maybeToOptional (fmap toNode contextNode))
           (maybeToOptional resolver)
           (maybeToOptional type')
           (maybeToOptional inResult))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.evaluate Mozilla Document.evaluate documentation> 
  evaluate_ ::
            (MonadIO m, IsDocument self, ToJSString expression,
             IsNode contextNode) =>
              self ->
                Maybe expression ->
                  Maybe contextNode ->
                    Maybe XPathNSResolver -> Maybe Word -> Maybe XPathResult -> m ()
  evaluate_ self expression contextNode resolver type' inResult
    = liftIO
        (void
           (js_evaluate (toDocument self) (toOptionalJSString expression)
              (maybeToOptional (fmap toNode contextNode))
              (maybeToOptional resolver)
              (maybeToOptional type')
              (maybeToOptional inResult)))
   
  foreign import javascript unsafe "$1[\"webkitExitFullscreen\"]()"
          js_webkitExitFullscreen :: Document -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitExitFullscreen Mozilla Document.webkitExitFullscreen documentation> 
  webkitExitFullscreen ::
                       (MonadIO m, IsDocument self) => self -> m ()
  webkitExitFullscreen self
    = liftIO (js_webkitExitFullscreen (toDocument self))
   
  foreign import javascript unsafe "$1[\"webkitCancelFullScreen\"]()"
          js_webkitCancelFullScreen :: Document -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitCancelFullScreen Mozilla Document.webkitCancelFullScreen documentation> 
  webkitCancelFullScreen ::
                         (MonadIO m, IsDocument self) => self -> m ()
  webkitCancelFullScreen self
    = liftIO (js_webkitCancelFullScreen (toDocument self))
   
  foreign import javascript unsafe "$1[\"exitPointerLock\"]()"
          js_exitPointerLock :: Document -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.exitPointerLock Mozilla Document.exitPointerLock documentation> 
  exitPointerLock :: (MonadIO m, IsDocument self) => self -> m ()
  exitPointerLock self
    = liftIO (js_exitPointerLock (toDocument self))
   
  foreign import javascript unsafe "$1[\"getOverrideStyle\"]($2, $3)"
          js_getOverrideStyle ::
          Document ->
            Optional Element -> Optional JSString -> IO CSSStyleDeclaration
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getOverrideStyle Mozilla Document.getOverrideStyle documentation> 
  getOverrideStyle ::
                   (MonadIO m, IsDocument self, IsElement element,
                    ToJSString pseudoElement) =>
                     self ->
                       Maybe element -> Maybe pseudoElement -> m CSSStyleDeclaration
  getOverrideStyle self element pseudoElement
    = liftIO
        (js_getOverrideStyle (toDocument self)
           (maybeToOptional (fmap toElement element))
           (toOptionalJSString pseudoElement))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getOverrideStyle Mozilla Document.getOverrideStyle documentation> 
  getOverrideStyle_ ::
                    (MonadIO m, IsDocument self, IsElement element,
                     ToJSString pseudoElement) =>
                      self -> Maybe element -> Maybe pseudoElement -> m ()
  getOverrideStyle_ self element pseudoElement
    = liftIO
        (void
           (js_getOverrideStyle (toDocument self)
              (maybeToOptional (fmap toElement element))
              (toOptionalJSString pseudoElement)))
   
  foreign import javascript unsafe
          "$1[\"caretRangeFromPoint\"]($2,\n$3)" js_caretRangeFromPoint ::
          Document -> Optional Int -> Optional Int -> IO Range
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.caretRangeFromPoint Mozilla Document.caretRangeFromPoint documentation> 
  caretRangeFromPoint ::
                      (MonadIO m, IsDocument self) =>
                        self -> Maybe Int -> Maybe Int -> m Range
  caretRangeFromPoint self x y
    = liftIO
        (js_caretRangeFromPoint (toDocument self) (maybeToOptional x)
           (maybeToOptional y))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.caretRangeFromPoint Mozilla Document.caretRangeFromPoint documentation> 
  caretRangeFromPoint_ ::
                       (MonadIO m, IsDocument self) =>
                         self -> Maybe Int -> Maybe Int -> m ()
  caretRangeFromPoint_ self x y
    = liftIO
        (void
           (js_caretRangeFromPoint (toDocument self) (maybeToOptional x)
              (maybeToOptional y)))
   
  foreign import javascript unsafe
          "$1[\"getCSSCanvasContext\"]($2,\n$3, $4, $5)"
          js_getCSSCanvasContext ::
          Document ->
            JSString -> JSString -> Int -> Int -> IO RenderingContext
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getCSSCanvasContext Mozilla Document.getCSSCanvasContext documentation> 
  getCSSCanvasContext ::
                      (MonadIO m, IsDocument self, ToJSString contextId,
                       ToJSString name) =>
                        self -> contextId -> name -> Int -> Int -> m RenderingContext
  getCSSCanvasContext self contextId name width height
    = liftIO
        (js_getCSSCanvasContext (toDocument self) (toJSString contextId)
           (toJSString name)
           width
           height)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getCSSCanvasContext Mozilla Document.getCSSCanvasContext documentation> 
  getCSSCanvasContext_ ::
                       (MonadIO m, IsDocument self, ToJSString contextId,
                        ToJSString name) =>
                         self -> contextId -> name -> Int -> Int -> m ()
  getCSSCanvasContext_ self contextId name width height
    = liftIO
        (void
           (js_getCSSCanvasContext (toDocument self) (toJSString contextId)
              (toJSString name)
              width
              height))
   
  foreign import javascript unsafe "$1[\"webkitGetNamedFlows\"]()"
          js_webkitGetNamedFlows :: Document -> IO DOMNamedFlowCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitGetNamedFlows Mozilla Document.webkitGetNamedFlows documentation> 
  webkitGetNamedFlows ::
                      (MonadIO m, IsDocument self) => self -> m DOMNamedFlowCollection
  webkitGetNamedFlows self
    = liftIO (js_webkitGetNamedFlows (toDocument self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitGetNamedFlows Mozilla Document.webkitGetNamedFlows documentation> 
  webkitGetNamedFlows_ ::
                       (MonadIO m, IsDocument self) => self -> m ()
  webkitGetNamedFlows_ self
    = liftIO (void (js_webkitGetNamedFlows (toDocument self)))
   
  foreign import javascript unsafe
          "$1[\"createTouch\"]($2, $3, $4,\n$5, $6, $7, $8, $9, $10, $11,\n$12)"
          js_createTouch ::
          Document ->
            Optional Window ->
              Optional EventTarget ->
                Optional Int ->
                  Optional Int ->
                    Optional Int ->
                      Optional Int ->
                        Optional Int ->
                          Optional Int ->
                            Optional Int -> Optional Float -> Optional Float -> IO Touch
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouch Mozilla Document.createTouch documentation> 
  createTouch ::
              (MonadIO m, IsDocument self, IsEventTarget target) =>
                self ->
                  Maybe Window ->
                    Maybe target ->
                      Maybe Int ->
                        Maybe Int ->
                          Maybe Int ->
                            Maybe Int ->
                              Maybe Int ->
                                Maybe Int -> Maybe Int -> Maybe Float -> Maybe Float -> m Touch
  createTouch self window target identifier pageX pageY screenX
    screenY webkitRadiusX webkitRadiusY webkitRotationAngle webkitForce
    = liftIO
        (js_createTouch (toDocument self) (maybeToOptional window)
           (maybeToOptional (fmap toEventTarget target))
           (maybeToOptional identifier)
           (maybeToOptional pageX)
           (maybeToOptional pageY)
           (maybeToOptional screenX)
           (maybeToOptional screenY)
           (maybeToOptional webkitRadiusX)
           (maybeToOptional webkitRadiusY)
           (maybeToOptional webkitRotationAngle)
           (maybeToOptional webkitForce))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouch Mozilla Document.createTouch documentation> 
  createTouch_ ::
               (MonadIO m, IsDocument self, IsEventTarget target) =>
                 self ->
                   Maybe Window ->
                     Maybe target ->
                       Maybe Int ->
                         Maybe Int ->
                           Maybe Int ->
                             Maybe Int ->
                               Maybe Int ->
                                 Maybe Int -> Maybe Int -> Maybe Float -> Maybe Float -> m ()
  createTouch_ self window target identifier pageX pageY screenX
    screenY webkitRadiusX webkitRadiusY webkitRotationAngle webkitForce
    = liftIO
        (void
           (js_createTouch (toDocument self) (maybeToOptional window)
              (maybeToOptional (fmap toEventTarget target))
              (maybeToOptional identifier)
              (maybeToOptional pageX)
              (maybeToOptional pageY)
              (maybeToOptional screenX)
              (maybeToOptional screenY)
              (maybeToOptional webkitRadiusX)
              (maybeToOptional webkitRadiusY)
              (maybeToOptional webkitRotationAngle)
              (maybeToOptional webkitForce)))
   
  foreign import javascript unsafe "$1[\"createTouchList\"]($2)"
          js_createTouchList :: Document -> JSVal -> IO TouchList
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouchList Mozilla Document.createTouchList documentation> 
  createTouchList ::
                  (MonadIO m, IsDocument self) => self -> [Touch] -> m TouchList
  createTouchList self touches
    = liftIO
        (toJSVal touches >>=
           \ touches' -> js_createTouchList (toDocument self) touches')
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouchList Mozilla Document.createTouchList documentation> 
  createTouchList_ ::
                   (MonadIO m, IsDocument self) => self -> [Touch] -> m ()
  createTouchList_ self touches
    = liftIO
        (void
           (toJSVal touches >>=
              \ touches' -> js_createTouchList (toDocument self) touches'))
   
  foreign import javascript unsafe "$1[\"timeline\"]" js_getTimeline
          :: Document -> IO DocumentTimeline
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.timeline Mozilla Document.timeline documentation> 
  getTimeline ::
              (MonadIO m, IsDocument self) => self -> m DocumentTimeline
  getTimeline self = liftIO (js_getTimeline (toDocument self))
   
  foreign import javascript unsafe "$1[\"implementation\"]"
          js_getImplementation :: Document -> IO DOMImplementation
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.implementation Mozilla Document.implementation documentation> 
  getImplementation ::
                    (MonadIO m, IsDocument self) => self -> m DOMImplementation
  getImplementation self
    = liftIO (js_getImplementation (toDocument self))
   
  foreign import javascript unsafe "$1[\"URL\"]" js_getURL ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.URL Mozilla Document.URL documentation> 
  getURL ::
         (MonadIO m, IsDocument self, FromJSString result) =>
           self -> m result
  getURL self
    = liftIO (fromJSString <$> (js_getURL (toDocument self)))
   
  foreign import javascript unsafe "$1[\"documentURI\"]"
          js_getDocumentURI :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentURI Mozilla Document.documentURI documentation> 
  getDocumentURI ::
                 (MonadIO m, IsDocument self, FromJSString result) =>
                   self -> m result
  getDocumentURI self
    = liftIO (fromJSString <$> (js_getDocumentURI (toDocument self)))
   
  foreign import javascript unsafe "$1[\"origin\"]" js_getOrigin ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.origin Mozilla Document.origin documentation> 
  getOrigin ::
            (MonadIO m, IsDocument self, FromJSString result) =>
              self -> m result
  getOrigin self
    = liftIO (fromJSString <$> (js_getOrigin (toDocument self)))
   
  foreign import javascript unsafe "$1[\"compatMode\"]"
          js_getCompatMode :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.compatMode Mozilla Document.compatMode documentation> 
  getCompatMode ::
                (MonadIO m, IsDocument self, FromJSString result) =>
                  self -> m result
  getCompatMode self
    = liftIO (fromJSString <$> (js_getCompatMode (toDocument self)))
   
  foreign import javascript unsafe "$1[\"characterSet\"]"
          js_getCharacterSet :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.characterSet Mozilla Document.characterSet documentation> 
  getCharacterSet ::
                  (MonadIO m, IsDocument self, FromJSString result) =>
                    self -> m result
  getCharacterSet self
    = liftIO (fromJSString <$> (js_getCharacterSet (toDocument self)))
   
  foreign import javascript unsafe "$1[\"charset\"]" js_getCharset ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.charset Mozilla Document.charset documentation> 
  getCharset ::
             (MonadIO m, IsDocument self, FromJSString result) =>
               self -> m result
  getCharset self
    = liftIO (fromJSString <$> (js_getCharset (toDocument self)))
   
  foreign import javascript unsafe "$1[\"inputEncoding\"]"
          js_getInputEncoding :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.inputEncoding Mozilla Document.inputEncoding documentation> 
  getInputEncoding ::
                   (MonadIO m, IsDocument self, FromJSString result) =>
                     self -> m result
  getInputEncoding self
    = liftIO (fromJSString <$> (js_getInputEncoding (toDocument self)))
   
  foreign import javascript unsafe "$1[\"contentType\"]"
          js_getContentType :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.contentType Mozilla Document.contentType documentation> 
  getContentType ::
                 (MonadIO m, IsDocument self, FromJSString result) =>
                   self -> m result
  getContentType self
    = liftIO (fromJSString <$> (js_getContentType (toDocument self)))
   
  foreign import javascript unsafe "$1[\"doctype\"]" js_getDoctype ::
          Document -> IO (Nullable DocumentType)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.doctype Mozilla Document.doctype documentation> 
  getDoctype ::
             (MonadIO m, IsDocument self) => self -> m (Maybe DocumentType)
  getDoctype self
    = liftIO (nullableToMaybe <$> (js_getDoctype (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.doctype Mozilla Document.doctype documentation> 
  getDoctypeUnsafe ::
                   (MonadIO m, IsDocument self, HasCallStack) =>
                     self -> m DocumentType
  getDoctypeUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getDoctype (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.doctype Mozilla Document.doctype documentation> 
  getDoctypeUnchecked ::
                      (MonadIO m, IsDocument self) => self -> m DocumentType
  getDoctypeUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$> (js_getDoctype (toDocument self)))
   
  foreign import javascript unsafe "$1[\"documentElement\"]"
          js_getDocumentElement :: Document -> IO (Nullable Element)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentElement Mozilla Document.documentElement documentation> 
  getDocumentElement ::
                     (MonadIO m, IsDocument self) => self -> m (Maybe Element)
  getDocumentElement self
    = liftIO
        (nullableToMaybe <$> (js_getDocumentElement (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentElement Mozilla Document.documentElement documentation> 
  getDocumentElementUnsafe ::
                           (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
  getDocumentElementUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getDocumentElement (toDocument self)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentElement Mozilla Document.documentElement documentation> 
  getDocumentElementUnchecked ::
                              (MonadIO m, IsDocument self) => self -> m Element
  getDocumentElementUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getDocumentElement (toDocument self)))
   
  foreign import javascript unsafe "$1[\"location\"]" js_getLocation
          :: Document -> IO (Nullable Location)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.location Mozilla Document.location documentation> 
  getLocation ::
              (MonadIO m, IsDocument self) => self -> m (Maybe Location)
  getLocation self
    = liftIO (nullableToMaybe <$> (js_getLocation (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.location Mozilla Document.location documentation> 
  getLocationUnsafe ::
                    (MonadIO m, IsDocument self, HasCallStack) => self -> m Location
  getLocationUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getLocation (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.location Mozilla Document.location documentation> 
  getLocationUnchecked ::
                       (MonadIO m, IsDocument self) => self -> m Location
  getLocationUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$> (js_getLocation (toDocument self)))
   
  foreign import javascript safe "$1[\"domain\"] = $2;" js_setDomain
          :: Document -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.domain Mozilla Document.domain documentation> 
  setDomain ::
            (MonadIO m, IsDocument self, ToJSString val) => self -> val -> m ()
  setDomain self val
    = liftIO (js_setDomain (toDocument self) (toJSString val))
   
  foreign import javascript unsafe "$1[\"domain\"]" js_getDomain ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.domain Mozilla Document.domain documentation> 
  getDomain ::
            (MonadIO m, IsDocument self, FromJSString result) =>
              self -> m result
  getDomain self
    = liftIO (fromJSString <$> (js_getDomain (toDocument self)))
   
  foreign import javascript unsafe "$1[\"referrer\"]" js_getReferrer
          :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.referrer Mozilla Document.referrer documentation> 
  getReferrer ::
              (MonadIO m, IsDocument self, FromJSString result) =>
                self -> m result
  getReferrer self
    = liftIO (fromJSString <$> (js_getReferrer (toDocument self)))
   
  foreign import javascript safe "$1[\"cookie\"] = $2;" js_setCookie
          :: Document -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.cookie Mozilla Document.cookie documentation> 
  setCookie ::
            (MonadIO m, IsDocument self, ToJSString val) => self -> val -> m ()
  setCookie self val
    = liftIO (js_setCookie (toDocument self) (toJSString val))
   
  foreign import javascript safe "$1[\"cookie\"]" js_getCookie ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.cookie Mozilla Document.cookie documentation> 
  getCookie ::
            (MonadIO m, IsDocument self, FromJSString result) =>
              self -> m result
  getCookie self
    = liftIO (fromJSString <$> (js_getCookie (toDocument self)))
   
  foreign import javascript unsafe "$1[\"lastModified\"]"
          js_getLastModified :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.lastModified Mozilla Document.lastModified documentation> 
  getLastModified ::
                  (MonadIO m, IsDocument self, FromJSString result) =>
                    self -> m result
  getLastModified self
    = liftIO (fromJSString <$> (js_getLastModified (toDocument self)))
   
  foreign import javascript unsafe "$1[\"readyState\"]"
          js_getReadyState :: Document -> IO JSVal
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.readyState Mozilla Document.readyState documentation> 
  getReadyState ::
                (MonadIO m, IsDocument self) => self -> m DocumentReadyState
  getReadyState self
    = liftIO
        ((js_getReadyState (toDocument self)) >>= fromJSValUnchecked)
   
  foreign import javascript unsafe "$1[\"title\"] = $2;" js_setTitle
          :: Document -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.title Mozilla Document.title documentation> 
  setTitle ::
           (MonadIO m, IsDocument self, ToJSString val) => self -> val -> m ()
  setTitle self val
    = liftIO (js_setTitle (toDocument self) (toJSString val))
   
  foreign import javascript unsafe "$1[\"title\"]" js_getTitle ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.title Mozilla Document.title documentation> 
  getTitle ::
           (MonadIO m, IsDocument self, FromJSString result) =>
             self -> m result
  getTitle self
    = liftIO (fromJSString <$> (js_getTitle (toDocument self)))
   
  foreign import javascript unsafe "$1[\"dir\"] = $2;" js_setDir ::
          Document -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.dir Mozilla Document.dir documentation> 
  setDir ::
         (MonadIO m, IsDocument self, ToJSString val) => self -> val -> m ()
  setDir self val
    = liftIO (js_setDir (toDocument self) (toJSString val))
   
  foreign import javascript unsafe "$1[\"dir\"]" js_getDir ::
          Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.dir Mozilla Document.dir documentation> 
  getDir ::
         (MonadIO m, IsDocument self, FromJSString result) =>
           self -> m result
  getDir self
    = liftIO (fromJSString <$> (js_getDir (toDocument self)))
   
  foreign import javascript safe "$1[\"body\"] = $2;" js_setBody ::
          Document -> Optional HTMLElement -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.body Mozilla Document.body documentation> 
  setBody ::
          (MonadIO m, IsDocument self, IsHTMLElement val) =>
            self -> Maybe val -> m ()
  setBody self val
    = liftIO
        (js_setBody (toDocument self)
           (maybeToOptional (fmap toHTMLElement val)))
   
  foreign import javascript unsafe "$1[\"body\"]" js_getBody ::
          Document -> IO (Nullable HTMLElement)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.body Mozilla Document.body documentation> 
  getBody ::
          (MonadIO m, IsDocument self) => self -> m (Maybe HTMLElement)
  getBody self
    = liftIO (nullableToMaybe <$> (js_getBody (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.body Mozilla Document.body documentation> 
  getBodyUnsafe ::
                (MonadIO m, IsDocument self, HasCallStack) => self -> m HTMLElement
  getBodyUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getBody (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.body Mozilla Document.body documentation> 
  getBodyUnchecked ::
                   (MonadIO m, IsDocument self) => self -> m HTMLElement
  getBodyUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$> (js_getBody (toDocument self)))
   
  foreign import javascript unsafe "$1[\"head\"]" js_getHead ::
          Document -> IO (Nullable HTMLHeadElement)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.head Mozilla Document.head documentation> 
  getHead ::
          (MonadIO m, IsDocument self) => self -> m (Maybe HTMLHeadElement)
  getHead self
    = liftIO (nullableToMaybe <$> (js_getHead (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.head Mozilla Document.head documentation> 
  getHeadUnsafe ::
                (MonadIO m, IsDocument self, HasCallStack) =>
                  self -> m HTMLHeadElement
  getHeadUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getHead (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.head Mozilla Document.head documentation> 
  getHeadUnchecked ::
                   (MonadIO m, IsDocument self) => self -> m HTMLHeadElement
  getHeadUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$> (js_getHead (toDocument self)))
   
  foreign import javascript unsafe "$1[\"images\"]" js_getImages ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.images Mozilla Document.images documentation> 
  getImages ::
            (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getImages self = liftIO (js_getImages (toDocument self))
   
  foreign import javascript unsafe "$1[\"embeds\"]" js_getEmbeds ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.embeds Mozilla Document.embeds documentation> 
  getEmbeds ::
            (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getEmbeds self = liftIO (js_getEmbeds (toDocument self))
   
  foreign import javascript unsafe "$1[\"plugins\"]" js_getPlugins ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.plugins Mozilla Document.plugins documentation> 
  getPlugins ::
             (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getPlugins self = liftIO (js_getPlugins (toDocument self))
   
  foreign import javascript unsafe "$1[\"links\"]" js_getLinks ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.links Mozilla Document.links documentation> 
  getLinks ::
           (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getLinks self = liftIO (js_getLinks (toDocument self))
   
  foreign import javascript unsafe "$1[\"forms\"]" js_getForms ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.forms Mozilla Document.forms documentation> 
  getForms ::
           (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getForms self = liftIO (js_getForms (toDocument self))
   
  foreign import javascript unsafe "$1[\"scripts\"]" js_getScripts ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.scripts Mozilla Document.scripts documentation> 
  getScripts ::
             (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getScripts self = liftIO (js_getScripts (toDocument self))
   
  foreign import javascript unsafe "$1[\"currentScript\"]"
          js_getCurrentScript :: Document -> IO (Nullable HTMLScriptElement)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.currentScript Mozilla Document.currentScript documentation> 
  getCurrentScript ::
                   (MonadIO m, IsDocument self) => self -> m (Maybe HTMLScriptElement)
  getCurrentScript self
    = liftIO
        (nullableToMaybe <$> (js_getCurrentScript (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.currentScript Mozilla Document.currentScript documentation> 
  getCurrentScriptUnsafe ::
                         (MonadIO m, IsDocument self, HasCallStack) =>
                           self -> m HTMLScriptElement
  getCurrentScriptUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getCurrentScript (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.currentScript Mozilla Document.currentScript documentation> 
  getCurrentScriptUnchecked ::
                            (MonadIO m, IsDocument self) => self -> m HTMLScriptElement
  getCurrentScriptUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getCurrentScript (toDocument self)))
   
  foreign import javascript unsafe "$1[\"defaultView\"]"
          js_getDefaultView :: Document -> IO (Nullable Window)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultView Mozilla Document.defaultView documentation> 
  getDefaultView ::
                 (MonadIO m, IsDocument self) => self -> m (Maybe Window)
  getDefaultView self
    = liftIO
        (nullableToMaybe <$> (js_getDefaultView (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultView Mozilla Document.defaultView documentation> 
  getDefaultViewUnsafe ::
                       (MonadIO m, IsDocument self, HasCallStack) => self -> m Window
  getDefaultViewUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getDefaultView (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultView Mozilla Document.defaultView documentation> 
  getDefaultViewUnchecked ::
                          (MonadIO m, IsDocument self) => self -> m Window
  getDefaultViewUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getDefaultView (toDocument self)))
   
  foreign import javascript unsafe "$1[\"designMode\"] = $2;"
          js_setDesignMode :: Document -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.designMode Mozilla Document.designMode documentation> 
  setDesignMode ::
                (MonadIO m, IsDocument self, ToJSString val) => self -> val -> m ()
  setDesignMode self val
    = liftIO (js_setDesignMode (toDocument self) (toJSString val))
   
  foreign import javascript unsafe "$1[\"designMode\"]"
          js_getDesignMode :: Document -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.designMode Mozilla Document.designMode documentation> 
  getDesignMode ::
                (MonadIO m, IsDocument self, FromJSString result) =>
                  self -> m result
  getDesignMode self
    = liftIO (fromJSString <$> (js_getDesignMode (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onreadystatechange Mozilla Document.onreadystatechange documentation> 
  readyStateChange ::
                   (IsDocument self, IsEventTarget self) => EventName self Event
  readyStateChange
    = unsafeEventNameAsync (toJSString "readystatechange")
   
  foreign import javascript unsafe "$1[\"styleSheets\"]"
          js_getStyleSheets :: Document -> IO StyleSheetList
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.styleSheets Mozilla Document.styleSheets documentation> 
  getStyleSheets ::
                 (MonadIO m, IsDocument self) => self -> m StyleSheetList
  getStyleSheets self = liftIO (js_getStyleSheets (toDocument self))
   
  foreign import javascript unsafe "$1[\"scrollingElement\"]"
          js_getScrollingElement :: Document -> IO (Nullable Element)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.scrollingElement Mozilla Document.scrollingElement documentation> 
  getScrollingElement ::
                      (MonadIO m, IsDocument self) => self -> m (Maybe Element)
  getScrollingElement self
    = liftIO
        (nullableToMaybe <$> (js_getScrollingElement (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.scrollingElement Mozilla Document.scrollingElement documentation> 
  getScrollingElementUnsafe ::
                            (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
  getScrollingElementUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getScrollingElement (toDocument self)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.scrollingElement Mozilla Document.scrollingElement documentation> 
  getScrollingElementUnchecked ::
                               (MonadIO m, IsDocument self) => self -> m Element
  getScrollingElementUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getScrollingElement (toDocument self)))
   
  foreign import javascript unsafe
          "($1[\"webkitFullscreenEnabled\"] ? 1 : 0)"
          js_getWebkitFullscreenEnabled :: Document -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullscreenEnabled Mozilla Document.webkitFullscreenEnabled documentation> 
  getWebkitFullscreenEnabled ::
                             (MonadIO m, IsDocument self) => self -> m Bool
  getWebkitFullscreenEnabled self
    = liftIO (js_getWebkitFullscreenEnabled (toDocument self))
   
  foreign import javascript unsafe "$1[\"webkitFullscreenElement\"]"
          js_getWebkitFullscreenElement :: Document -> IO (Nullable Element)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullscreenElement Mozilla Document.webkitFullscreenElement documentation> 
  getWebkitFullscreenElement ::
                             (MonadIO m, IsDocument self) => self -> m (Maybe Element)
  getWebkitFullscreenElement self
    = liftIO
        (nullableToMaybe <$>
           (js_getWebkitFullscreenElement (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullscreenElement Mozilla Document.webkitFullscreenElement documentation> 
  getWebkitFullscreenElementUnsafe ::
                                   (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
  getWebkitFullscreenElementUnsafe self
    = liftIO
        ((nullableToMaybe <$>
            (js_getWebkitFullscreenElement (toDocument self)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullscreenElement Mozilla Document.webkitFullscreenElement documentation> 
  getWebkitFullscreenElementUnchecked ::
                                      (MonadIO m, IsDocument self) => self -> m Element
  getWebkitFullscreenElementUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getWebkitFullscreenElement (toDocument self)))
   
  foreign import javascript unsafe
          "($1[\"webkitIsFullScreen\"] ? 1 : 0)" js_getWebkitIsFullScreen ::
          Document -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitIsFullScreen Mozilla Document.webkitIsFullScreen documentation> 
  getWebkitIsFullScreen ::
                        (MonadIO m, IsDocument self) => self -> m Bool
  getWebkitIsFullScreen self
    = liftIO (js_getWebkitIsFullScreen (toDocument self))
   
  foreign import javascript unsafe
          "($1[\"webkitFullScreenKeyboardInputAllowed\"] ? 1 : 0)"
          js_getWebkitFullScreenKeyboardInputAllowed :: Document -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullScreenKeyboardInputAllowed Mozilla Document.webkitFullScreenKeyboardInputAllowed documentation> 
  getWebkitFullScreenKeyboardInputAllowed ::
                                          (MonadIO m, IsDocument self) => self -> m Bool
  getWebkitFullScreenKeyboardInputAllowed self
    = liftIO
        (js_getWebkitFullScreenKeyboardInputAllowed (toDocument self))
   
  foreign import javascript unsafe
          "$1[\"webkitCurrentFullScreenElement\"]"
          js_getWebkitCurrentFullScreenElement :: Document -> IO Element
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitCurrentFullScreenElement Mozilla Document.webkitCurrentFullScreenElement documentation> 
  getWebkitCurrentFullScreenElement ::
                                    (MonadIO m, IsDocument self) => self -> m Element
  getWebkitCurrentFullScreenElement self
    = liftIO (js_getWebkitCurrentFullScreenElement (toDocument self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onwebkitfullscreenchange Mozilla Document.onwebkitfullscreenchange documentation> 
  webKitFullscreenChange ::
                         (IsDocument self, IsEventTarget self) => EventName self Event
  webKitFullscreenChange
    = unsafeEventName (toJSString "webkitfullscreenchange")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onwebkitfullscreenerror Mozilla Document.onwebkitfullscreenerror documentation> 
  webKitFullscreenError ::
                        (IsDocument self, IsEventTarget self) => EventName self Event
  webKitFullscreenError
    = unsafeEventName (toJSString "webkitfullscreenerror")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onpointerlockchange Mozilla Document.onpointerlockchange documentation> 
  pointerlockchange ::
                    (IsDocument self, IsEventTarget self) => EventName self Event
  pointerlockchange
    = unsafeEventName (toJSString "pointerlockchange")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onpointerlockerror Mozilla Document.onpointerlockerror documentation> 
  pointerlockerror ::
                   (IsDocument self, IsEventTarget self) => EventName self Event
  pointerlockerror = unsafeEventName (toJSString "pointerlockerror")
   
  foreign import javascript unsafe "$1[\"fonts\"]" js_getFonts ::
          Document -> IO FontFaceSet
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.fonts Mozilla Document.fonts documentation> 
  getFonts :: (MonadIO m, IsDocument self) => self -> m FontFaceSet
  getFonts self = liftIO (js_getFonts (toDocument self))
   
  foreign import javascript unsafe "($1[\"hidden\"] ? 1 : 0)"
          js_getHidden :: Document -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.hidden Mozilla Document.hidden documentation> 
  getHidden :: (MonadIO m, IsDocument self) => self -> m Bool
  getHidden self = liftIO (js_getHidden (toDocument self))
   
  foreign import javascript unsafe "$1[\"visibilityState\"]"
          js_getVisibilityState :: Document -> IO JSVal
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.visibilityState Mozilla Document.visibilityState documentation> 
  getVisibilityState ::
                     (MonadIO m, IsDocument self) => self -> m VisibilityState
  getVisibilityState self
    = liftIO
        ((js_getVisibilityState (toDocument self)) >>= fromJSValUnchecked)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onvisibilitychange Mozilla Document.onvisibilitychange documentation> 
  visibilitychange ::
                   (IsDocument self, IsEventTarget self) => EventName self Event
  visibilitychange = unsafeEventName (toJSString "visibilitychange")
   
  foreign import javascript unsafe "$1[\"applets\"]" js_getApplets ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.applets Mozilla Document.applets documentation> 
  getApplets ::
             (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getApplets self = liftIO (js_getApplets (toDocument self))
   
  foreign import javascript unsafe "$1[\"anchors\"]" js_getAnchors ::
          Document -> IO HTMLCollection
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.anchors Mozilla Document.anchors documentation> 
  getAnchors ::
             (MonadIO m, IsDocument self) => self -> m HTMLCollection
  getAnchors self = liftIO (js_getAnchors (toDocument self))
   
  foreign import javascript unsafe "$1[\"preferredStylesheetSet\"]"
          js_getPreferredStylesheetSet :: Document -> IO (Nullable JSString)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.preferredStylesheetSet Mozilla Document.preferredStylesheetSet documentation> 
  getPreferredStylesheetSet ::
                            (MonadIO m, IsDocument self, FromJSString result) =>
                              self -> m (Maybe result)
  getPreferredStylesheetSet self
    = liftIO
        (fromMaybeJSString <$>
           (js_getPreferredStylesheetSet (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.preferredStylesheetSet Mozilla Document.preferredStylesheetSet documentation> 
  getPreferredStylesheetSetUnsafe ::
                                  (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
                                    self -> m result
  getPreferredStylesheetSetUnsafe self
    = liftIO
        ((fromMaybeJSString <$>
            (js_getPreferredStylesheetSet (toDocument self)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.preferredStylesheetSet Mozilla Document.preferredStylesheetSet documentation> 
  getPreferredStylesheetSetUnchecked ::
                                     (MonadIO m, IsDocument self, FromJSString result) =>
                                       self -> m result
  getPreferredStylesheetSetUnchecked self
    = liftIO
        (fromJust . fromMaybeJSString <$>
           (js_getPreferredStylesheetSet (toDocument self)))
   
  foreign import javascript unsafe
          "$1[\"selectedStylesheetSet\"] = $2;" js_setSelectedStylesheetSet
          :: Document -> Optional JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.selectedStylesheetSet Mozilla Document.selectedStylesheetSet documentation> 
  setSelectedStylesheetSet ::
                           (MonadIO m, IsDocument self, ToJSString val) =>
                             self -> Maybe val -> m ()
  setSelectedStylesheetSet self val
    = liftIO
        (js_setSelectedStylesheetSet (toDocument self)
           (toOptionalJSString val))
   
  foreign import javascript unsafe "$1[\"selectedStylesheetSet\"]"
          js_getSelectedStylesheetSet :: Document -> IO (Nullable JSString)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.selectedStylesheetSet Mozilla Document.selectedStylesheetSet documentation> 
  getSelectedStylesheetSet ::
                           (MonadIO m, IsDocument self, FromJSString result) =>
                             self -> m (Maybe result)
  getSelectedStylesheetSet self
    = liftIO
        (fromMaybeJSString <$>
           (js_getSelectedStylesheetSet (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.selectedStylesheetSet Mozilla Document.selectedStylesheetSet documentation> 
  getSelectedStylesheetSetUnsafe ::
                                 (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
                                   self -> m result
  getSelectedStylesheetSetUnsafe self
    = liftIO
        ((fromMaybeJSString <$>
            (js_getSelectedStylesheetSet (toDocument self)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.selectedStylesheetSet Mozilla Document.selectedStylesheetSet documentation> 
  getSelectedStylesheetSetUnchecked ::
                                    (MonadIO m, IsDocument self, FromJSString result) =>
                                      self -> m result
  getSelectedStylesheetSetUnchecked self
    = liftIO
        (fromJust . fromMaybeJSString <$>
           (js_getSelectedStylesheetSet (toDocument self)))
   
  foreign import javascript unsafe "$1[\"xmlEncoding\"]"
          js_getXmlEncoding :: Document -> IO (Nullable JSString)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlEncoding Mozilla Document.xmlEncoding documentation> 
  getXmlEncoding ::
                 (MonadIO m, IsDocument self, FromJSString result) =>
                   self -> m (Maybe result)
  getXmlEncoding self
    = liftIO
        (fromMaybeJSString <$> (js_getXmlEncoding (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlEncoding Mozilla Document.xmlEncoding documentation> 
  getXmlEncodingUnsafe ::
                       (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
                         self -> m result
  getXmlEncodingUnsafe self
    = liftIO
        ((fromMaybeJSString <$> (js_getXmlEncoding (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlEncoding Mozilla Document.xmlEncoding documentation> 
  getXmlEncodingUnchecked ::
                          (MonadIO m, IsDocument self, FromJSString result) =>
                            self -> m result
  getXmlEncodingUnchecked self
    = liftIO
        (fromJust . fromMaybeJSString <$>
           (js_getXmlEncoding (toDocument self)))
   
  foreign import javascript safe "$1[\"xmlVersion\"] = $2;"
          js_setXmlVersion :: Document -> Optional JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlVersion Mozilla Document.xmlVersion documentation> 
  setXmlVersion ::
                (MonadIO m, IsDocument self, ToJSString val) =>
                  self -> Maybe val -> m ()
  setXmlVersion self val
    = liftIO
        (js_setXmlVersion (toDocument self) (toOptionalJSString val))
   
  foreign import javascript unsafe "$1[\"xmlVersion\"]"
          js_getXmlVersion :: Document -> IO (Nullable JSString)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlVersion Mozilla Document.xmlVersion documentation> 
  getXmlVersion ::
                (MonadIO m, IsDocument self, FromJSString result) =>
                  self -> m (Maybe result)
  getXmlVersion self
    = liftIO
        (fromMaybeJSString <$> (js_getXmlVersion (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlVersion Mozilla Document.xmlVersion documentation> 
  getXmlVersionUnsafe ::
                      (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
                        self -> m result
  getXmlVersionUnsafe self
    = liftIO
        ((fromMaybeJSString <$> (js_getXmlVersion (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlVersion Mozilla Document.xmlVersion documentation> 
  getXmlVersionUnchecked ::
                         (MonadIO m, IsDocument self, FromJSString result) =>
                           self -> m result
  getXmlVersionUnchecked self
    = liftIO
        (fromJust . fromMaybeJSString <$>
           (js_getXmlVersion (toDocument self)))
   
  foreign import javascript unsafe "$1[\"xmlStandalone\"] = $2;"
          js_setXmlStandalone :: Document -> Bool -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlStandalone Mozilla Document.xmlStandalone documentation> 
  setXmlStandalone ::
                   (MonadIO m, IsDocument self) => self -> Bool -> m ()
  setXmlStandalone self val
    = liftIO (js_setXmlStandalone (toDocument self) val)
   
  foreign import javascript unsafe "($1[\"xmlStandalone\"] ? 1 : 0)"
          js_getXmlStandalone :: Document -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlStandalone Mozilla Document.xmlStandalone documentation> 
  getXmlStandalone :: (MonadIO m, IsDocument self) => self -> m Bool
  getXmlStandalone self
    = liftIO (js_getXmlStandalone (toDocument self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onselectstart Mozilla Document.onselectstart documentation> 
  selectStart ::
              (IsDocument self, IsEventTarget self) => EventName self Event
  selectStart = unsafeEventName (toJSString "selectstart")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.onselectionchange Mozilla Document.onselectionchange documentation> 
  selectionchange ::
                  (IsDocument self, IsEventTarget self) =>
                    EventName self onselectionchange
  selectionchange = unsafeEventName (toJSString "selectionchange")
   
  foreign import javascript unsafe "$1[\"rootElement\"]"
          js_getRootElement :: Document -> IO (Nullable SVGSVGElement)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.rootElement Mozilla Document.rootElement documentation> 
  getRootElement ::
                 (MonadIO m, IsDocument self) => self -> m (Maybe SVGSVGElement)
  getRootElement self
    = liftIO
        (nullableToMaybe <$> (js_getRootElement (toDocument self)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.rootElement Mozilla Document.rootElement documentation> 
  getRootElementUnsafe ::
                       (MonadIO m, IsDocument self, HasCallStack) =>
                         self -> m SVGSVGElement
  getRootElementUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getRootElement (toDocument self))) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.rootElement Mozilla Document.rootElement documentation> 
  getRootElementUnchecked ::
                          (MonadIO m, IsDocument self) => self -> m SVGSVGElement
  getRootElementUnchecked self
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_getRootElement (toDocument self)))