{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.WebKit.Objects.DOMDocument
    ( 

-- * Exported types
    DOMDocument(..)                         ,
    IsDOMDocument                           ,
    toDOMDocument                           ,
    noDOMDocument                           ,


 -- * Methods
-- ** adoptNode #method:adoptNode#
    DOMDocumentAdoptNodeMethodInfo          ,
    dOMDocumentAdoptNode                    ,


-- ** caretRangeFromPoint #method:caretRangeFromPoint#
    DOMDocumentCaretRangeFromPointMethodInfo,
    dOMDocumentCaretRangeFromPoint          ,


-- ** createAttribute #method:createAttribute#
    DOMDocumentCreateAttributeMethodInfo    ,
    dOMDocumentCreateAttribute              ,


-- ** createAttributeNs #method:createAttributeNs#
    DOMDocumentCreateAttributeNsMethodInfo  ,
    dOMDocumentCreateAttributeNs            ,


-- ** createCdataSection #method:createCdataSection#
    DOMDocumentCreateCdataSectionMethodInfo ,
    dOMDocumentCreateCdataSection           ,


-- ** createComment #method:createComment#
    DOMDocumentCreateCommentMethodInfo      ,
    dOMDocumentCreateComment                ,


-- ** createCssStyleDeclaration #method:createCssStyleDeclaration#
    DOMDocumentCreateCssStyleDeclarationMethodInfo,
    dOMDocumentCreateCssStyleDeclaration    ,


-- ** createDocumentFragment #method:createDocumentFragment#
    DOMDocumentCreateDocumentFragmentMethodInfo,
    dOMDocumentCreateDocumentFragment       ,


-- ** createElement #method:createElement#
    DOMDocumentCreateElementMethodInfo      ,
    dOMDocumentCreateElement                ,


-- ** createElementNs #method:createElementNs#
    DOMDocumentCreateElementNsMethodInfo    ,
    dOMDocumentCreateElementNs              ,


-- ** createEntityReference #method:createEntityReference#
    DOMDocumentCreateEntityReferenceMethodInfo,
    dOMDocumentCreateEntityReference        ,


-- ** createEvent #method:createEvent#
    DOMDocumentCreateEventMethodInfo        ,
    dOMDocumentCreateEvent                  ,


-- ** createExpression #method:createExpression#
    DOMDocumentCreateExpressionMethodInfo   ,
    dOMDocumentCreateExpression             ,


-- ** createNodeIterator #method:createNodeIterator#
    DOMDocumentCreateNodeIteratorMethodInfo ,
    dOMDocumentCreateNodeIterator           ,


-- ** createNsResolver #method:createNsResolver#
    DOMDocumentCreateNsResolverMethodInfo   ,
    dOMDocumentCreateNsResolver             ,


-- ** createProcessingInstruction #method:createProcessingInstruction#
    DOMDocumentCreateProcessingInstructionMethodInfo,
    dOMDocumentCreateProcessingInstruction  ,


-- ** createRange #method:createRange#
    DOMDocumentCreateRangeMethodInfo        ,
    dOMDocumentCreateRange                  ,


-- ** createTextNode #method:createTextNode#
    DOMDocumentCreateTextNodeMethodInfo     ,
    dOMDocumentCreateTextNode               ,


-- ** createTouch #method:createTouch#
    DOMDocumentCreateTouchMethodInfo        ,
    dOMDocumentCreateTouch                  ,


-- ** createTreeWalker #method:createTreeWalker#
    DOMDocumentCreateTreeWalkerMethodInfo   ,
    dOMDocumentCreateTreeWalker             ,


-- ** elementFromPoint #method:elementFromPoint#
    DOMDocumentElementFromPointMethodInfo   ,
    dOMDocumentElementFromPoint             ,


-- ** evaluate #method:evaluate#
    DOMDocumentEvaluateMethodInfo           ,
    dOMDocumentEvaluate                     ,


-- ** execCommand #method:execCommand#
    DOMDocumentExecCommandMethodInfo        ,
    dOMDocumentExecCommand                  ,


-- ** getAnchors #method:getAnchors#
    DOMDocumentGetAnchorsMethodInfo         ,
    dOMDocumentGetAnchors                   ,


-- ** getApplets #method:getApplets#
    DOMDocumentGetAppletsMethodInfo         ,
    dOMDocumentGetApplets                   ,


-- ** getBody #method:getBody#
    DOMDocumentGetBodyMethodInfo            ,
    dOMDocumentGetBody                      ,


-- ** getCharacterSet #method:getCharacterSet#
    DOMDocumentGetCharacterSetMethodInfo    ,
    dOMDocumentGetCharacterSet              ,


-- ** getCharset #method:getCharset#
    DOMDocumentGetCharsetMethodInfo         ,
    dOMDocumentGetCharset                   ,


-- ** getCompatMode #method:getCompatMode#
    DOMDocumentGetCompatModeMethodInfo      ,
    dOMDocumentGetCompatMode                ,


-- ** getCookie #method:getCookie#
    DOMDocumentGetCookieMethodInfo          ,
    dOMDocumentGetCookie                    ,


-- ** getCurrentScript #method:getCurrentScript#
    DOMDocumentGetCurrentScriptMethodInfo   ,
    dOMDocumentGetCurrentScript             ,


-- ** getDefaultCharset #method:getDefaultCharset#
    DOMDocumentGetDefaultCharsetMethodInfo  ,
    dOMDocumentGetDefaultCharset            ,


-- ** getDefaultView #method:getDefaultView#
    DOMDocumentGetDefaultViewMethodInfo     ,
    dOMDocumentGetDefaultView               ,


-- ** getDoctype #method:getDoctype#
    DOMDocumentGetDoctypeMethodInfo         ,
    dOMDocumentGetDoctype                   ,


-- ** getDocumentElement #method:getDocumentElement#
    DOMDocumentGetDocumentElementMethodInfo ,
    dOMDocumentGetDocumentElement           ,


-- ** getDocumentUri #method:getDocumentUri#
    DOMDocumentGetDocumentUriMethodInfo     ,
    dOMDocumentGetDocumentUri               ,


-- ** getDomain #method:getDomain#
    DOMDocumentGetDomainMethodInfo          ,
    dOMDocumentGetDomain                    ,


-- ** getElementById #method:getElementById#
    DOMDocumentGetElementByIdMethodInfo     ,
    dOMDocumentGetElementById               ,


-- ** getElementsByClassName #method:getElementsByClassName#
    DOMDocumentGetElementsByClassNameMethodInfo,
    dOMDocumentGetElementsByClassName       ,


-- ** getElementsByName #method:getElementsByName#
    DOMDocumentGetElementsByNameMethodInfo  ,
    dOMDocumentGetElementsByName            ,


-- ** getElementsByTagName #method:getElementsByTagName#
    DOMDocumentGetElementsByTagNameMethodInfo,
    dOMDocumentGetElementsByTagName         ,


-- ** getElementsByTagNameNs #method:getElementsByTagNameNs#
    DOMDocumentGetElementsByTagNameNsMethodInfo,
    dOMDocumentGetElementsByTagNameNs       ,


-- ** getForms #method:getForms#
    DOMDocumentGetFormsMethodInfo           ,
    dOMDocumentGetForms                     ,


-- ** getHead #method:getHead#
    DOMDocumentGetHeadMethodInfo            ,
    dOMDocumentGetHead                      ,


-- ** getHidden #method:getHidden#
    DOMDocumentGetHiddenMethodInfo          ,
    dOMDocumentGetHidden                    ,


-- ** getImages #method:getImages#
    DOMDocumentGetImagesMethodInfo          ,
    dOMDocumentGetImages                    ,


-- ** getImplementation #method:getImplementation#
    DOMDocumentGetImplementationMethodInfo  ,
    dOMDocumentGetImplementation            ,


-- ** getInputEncoding #method:getInputEncoding#
    DOMDocumentGetInputEncodingMethodInfo   ,
    dOMDocumentGetInputEncoding             ,


-- ** getLastModified #method:getLastModified#
    DOMDocumentGetLastModifiedMethodInfo    ,
    dOMDocumentGetLastModified              ,


-- ** getLinks #method:getLinks#
    DOMDocumentGetLinksMethodInfo           ,
    dOMDocumentGetLinks                     ,


-- ** getOverrideStyle #method:getOverrideStyle#
    DOMDocumentGetOverrideStyleMethodInfo   ,
    dOMDocumentGetOverrideStyle             ,


-- ** getPreferredStylesheetSet #method:getPreferredStylesheetSet#
    DOMDocumentGetPreferredStylesheetSetMethodInfo,
    dOMDocumentGetPreferredStylesheetSet    ,


-- ** getReadyState #method:getReadyState#
    DOMDocumentGetReadyStateMethodInfo      ,
    dOMDocumentGetReadyState                ,


-- ** getReferrer #method:getReferrer#
    DOMDocumentGetReferrerMethodInfo        ,
    dOMDocumentGetReferrer                  ,


-- ** getSecurityPolicy #method:getSecurityPolicy#
    DOMDocumentGetSecurityPolicyMethodInfo  ,
    dOMDocumentGetSecurityPolicy            ,


-- ** getSelectedStylesheetSet #method:getSelectedStylesheetSet#
    DOMDocumentGetSelectedStylesheetSetMethodInfo,
    dOMDocumentGetSelectedStylesheetSet     ,


-- ** getStyleSheets #method:getStyleSheets#
    DOMDocumentGetStyleSheetsMethodInfo     ,
    dOMDocumentGetStyleSheets               ,


-- ** getTitle #method:getTitle#
    DOMDocumentGetTitleMethodInfo           ,
    dOMDocumentGetTitle                     ,


-- ** getUrl #method:getUrl#
    DOMDocumentGetUrlMethodInfo             ,
    dOMDocumentGetUrl                       ,


-- ** getVisibilityState #method:getVisibilityState#
    DOMDocumentGetVisibilityStateMethodInfo ,
    dOMDocumentGetVisibilityState           ,


-- ** getWebkitCurrentFullScreenElement #method:getWebkitCurrentFullScreenElement#
    DOMDocumentGetWebkitCurrentFullScreenElementMethodInfo,
    dOMDocumentGetWebkitCurrentFullScreenElement,


-- ** getWebkitFullScreenKeyboardInputAllowed #method:getWebkitFullScreenKeyboardInputAllowed#
    DOMDocumentGetWebkitFullScreenKeyboardInputAllowedMethodInfo,
    dOMDocumentGetWebkitFullScreenKeyboardInputAllowed,


-- ** getWebkitFullscreenElement #method:getWebkitFullscreenElement#
    DOMDocumentGetWebkitFullscreenElementMethodInfo,
    dOMDocumentGetWebkitFullscreenElement   ,


-- ** getWebkitFullscreenEnabled #method:getWebkitFullscreenEnabled#
    DOMDocumentGetWebkitFullscreenEnabledMethodInfo,
    dOMDocumentGetWebkitFullscreenEnabled   ,


-- ** getWebkitHidden #method:getWebkitHidden#
    DOMDocumentGetWebkitHiddenMethodInfo    ,
    dOMDocumentGetWebkitHidden              ,


-- ** getWebkitIsFullScreen #method:getWebkitIsFullScreen#
    DOMDocumentGetWebkitIsFullScreenMethodInfo,
    dOMDocumentGetWebkitIsFullScreen        ,


-- ** getWebkitPointerLockElement #method:getWebkitPointerLockElement#
    DOMDocumentGetWebkitPointerLockElementMethodInfo,
    dOMDocumentGetWebkitPointerLockElement  ,


-- ** getWebkitVisibilityState #method:getWebkitVisibilityState#
    DOMDocumentGetWebkitVisibilityStateMethodInfo,
    dOMDocumentGetWebkitVisibilityState     ,


-- ** getXmlEncoding #method:getXmlEncoding#
    DOMDocumentGetXmlEncodingMethodInfo     ,
    dOMDocumentGetXmlEncoding               ,


-- ** getXmlStandalone #method:getXmlStandalone#
    DOMDocumentGetXmlStandaloneMethodInfo   ,
    dOMDocumentGetXmlStandalone             ,


-- ** getXmlVersion #method:getXmlVersion#
    DOMDocumentGetXmlVersionMethodInfo      ,
    dOMDocumentGetXmlVersion                ,


-- ** importNode #method:importNode#
    DOMDocumentImportNodeMethodInfo         ,
    dOMDocumentImportNode                   ,


-- ** queryCommandEnabled #method:queryCommandEnabled#
    DOMDocumentQueryCommandEnabledMethodInfo,
    dOMDocumentQueryCommandEnabled          ,


-- ** queryCommandIndeterm #method:queryCommandIndeterm#
    DOMDocumentQueryCommandIndetermMethodInfo,
    dOMDocumentQueryCommandIndeterm         ,


-- ** queryCommandState #method:queryCommandState#
    DOMDocumentQueryCommandStateMethodInfo  ,
    dOMDocumentQueryCommandState            ,


-- ** queryCommandSupported #method:queryCommandSupported#
    DOMDocumentQueryCommandSupportedMethodInfo,
    dOMDocumentQueryCommandSupported        ,


-- ** queryCommandValue #method:queryCommandValue#
    DOMDocumentQueryCommandValueMethodInfo  ,
    dOMDocumentQueryCommandValue            ,


-- ** querySelector #method:querySelector#
    DOMDocumentQuerySelectorMethodInfo      ,
    dOMDocumentQuerySelector                ,


-- ** querySelectorAll #method:querySelectorAll#
    DOMDocumentQuerySelectorAllMethodInfo   ,
    dOMDocumentQuerySelectorAll             ,


-- ** setBody #method:setBody#
    DOMDocumentSetBodyMethodInfo            ,
    dOMDocumentSetBody                      ,


-- ** setCharset #method:setCharset#
    DOMDocumentSetCharsetMethodInfo         ,
    dOMDocumentSetCharset                   ,


-- ** setCookie #method:setCookie#
    DOMDocumentSetCookieMethodInfo          ,
    dOMDocumentSetCookie                    ,


-- ** setDocumentUri #method:setDocumentUri#
    DOMDocumentSetDocumentUriMethodInfo     ,
    dOMDocumentSetDocumentUri               ,


-- ** setSelectedStylesheetSet #method:setSelectedStylesheetSet#
    DOMDocumentSetSelectedStylesheetSetMethodInfo,
    dOMDocumentSetSelectedStylesheetSet     ,


-- ** setTitle #method:setTitle#
    DOMDocumentSetTitleMethodInfo           ,
    dOMDocumentSetTitle                     ,


-- ** setXmlStandalone #method:setXmlStandalone#
    DOMDocumentSetXmlStandaloneMethodInfo   ,
    dOMDocumentSetXmlStandalone             ,


-- ** setXmlVersion #method:setXmlVersion#
    DOMDocumentSetXmlVersionMethodInfo      ,
    dOMDocumentSetXmlVersion                ,


-- ** webkitCancelFullScreen #method:webkitCancelFullScreen#
    DOMDocumentWebkitCancelFullScreenMethodInfo,
    dOMDocumentWebkitCancelFullScreen       ,


-- ** webkitExitFullscreen #method:webkitExitFullscreen#
    DOMDocumentWebkitExitFullscreenMethodInfo,
    dOMDocumentWebkitExitFullscreen         ,


-- ** webkitExitPointerLock #method:webkitExitPointerLock#
    DOMDocumentWebkitExitPointerLockMethodInfo,
    dOMDocumentWebkitExitPointerLock        ,


-- ** webkitGetNamedFlows #method:webkitGetNamedFlows#
    DOMDocumentWebkitGetNamedFlowsMethodInfo,
    dOMDocumentWebkitGetNamedFlows          ,




 -- * Properties
-- ** anchors #attr:anchors#
    DOMDocumentAnchorsPropertyInfo          ,
    dOMDocumentAnchors                      ,
    getDOMDocumentAnchors                   ,


-- ** applets #attr:applets#
    DOMDocumentAppletsPropertyInfo          ,
    dOMDocumentApplets                      ,
    getDOMDocumentApplets                   ,


-- ** body #attr:body#
    DOMDocumentBodyPropertyInfo             ,
    dOMDocumentBody                         ,
    getDOMDocumentBody                      ,


-- ** characterSet #attr:characterSet#
    DOMDocumentCharacterSetPropertyInfo     ,
    dOMDocumentCharacterSet                 ,
    getDOMDocumentCharacterSet              ,


-- ** charset #attr:charset#
    DOMDocumentCharsetPropertyInfo          ,
    constructDOMDocumentCharset             ,
    dOMDocumentCharset                      ,
    getDOMDocumentCharset                   ,
    setDOMDocumentCharset                   ,


-- ** compatMode #attr:compatMode#
    DOMDocumentCompatModePropertyInfo       ,
    dOMDocumentCompatMode                   ,
    getDOMDocumentCompatMode                ,


-- ** cookie #attr:cookie#
    DOMDocumentCookiePropertyInfo           ,
    clearDOMDocumentCookie                  ,
    constructDOMDocumentCookie              ,
    dOMDocumentCookie                       ,
    getDOMDocumentCookie                    ,
    setDOMDocumentCookie                    ,


-- ** currentScript #attr:currentScript#
    DOMDocumentCurrentScriptPropertyInfo    ,
    dOMDocumentCurrentScript                ,
    getDOMDocumentCurrentScript             ,


-- ** defaultCharset #attr:defaultCharset#
    DOMDocumentDefaultCharsetPropertyInfo   ,
    dOMDocumentDefaultCharset               ,
    getDOMDocumentDefaultCharset            ,


-- ** defaultView #attr:defaultView#
    DOMDocumentDefaultViewPropertyInfo      ,
    dOMDocumentDefaultView                  ,
    getDOMDocumentDefaultView               ,


-- ** doctype #attr:doctype#
    DOMDocumentDoctypePropertyInfo          ,
    dOMDocumentDoctype                      ,
    getDOMDocumentDoctype                   ,


-- ** documentElement #attr:documentElement#
    DOMDocumentDocumentElementPropertyInfo  ,
    dOMDocumentDocumentElement              ,
    getDOMDocumentDocumentElement           ,


-- ** documentUri #attr:documentUri#
    DOMDocumentDocumentUriPropertyInfo      ,
    constructDOMDocumentDocumentUri         ,
    dOMDocumentDocumentUri                  ,
    getDOMDocumentDocumentUri               ,
    setDOMDocumentDocumentUri               ,


-- ** domain #attr:domain#
    DOMDocumentDomainPropertyInfo           ,
    dOMDocumentDomain                       ,
    getDOMDocumentDomain                    ,


-- ** forms #attr:forms#
    DOMDocumentFormsPropertyInfo            ,
    dOMDocumentForms                        ,
    getDOMDocumentForms                     ,


-- ** head #attr:head#
    DOMDocumentHeadPropertyInfo             ,
    dOMDocumentHead                         ,
    getDOMDocumentHead                      ,


-- ** hidden #attr:hidden#
    DOMDocumentHiddenPropertyInfo           ,
    dOMDocumentHidden                       ,
    getDOMDocumentHidden                    ,


-- ** images #attr:images#
    DOMDocumentImagesPropertyInfo           ,
    dOMDocumentImages                       ,
    getDOMDocumentImages                    ,


-- ** implementation #attr:implementation#
    DOMDocumentImplementationPropertyInfo   ,
    dOMDocumentImplementation               ,
    getDOMDocumentImplementation            ,


-- ** inputEncoding #attr:inputEncoding#
    DOMDocumentInputEncodingPropertyInfo    ,
    dOMDocumentInputEncoding                ,
    getDOMDocumentInputEncoding             ,


-- ** lastModified #attr:lastModified#
    DOMDocumentLastModifiedPropertyInfo     ,
    dOMDocumentLastModified                 ,
    getDOMDocumentLastModified              ,


-- ** links #attr:links#
    DOMDocumentLinksPropertyInfo            ,
    dOMDocumentLinks                        ,
    getDOMDocumentLinks                     ,


-- ** preferredStylesheetSet #attr:preferredStylesheetSet#
    DOMDocumentPreferredStylesheetSetPropertyInfo,
    dOMDocumentPreferredStylesheetSet       ,
    getDOMDocumentPreferredStylesheetSet    ,


-- ** readyState #attr:readyState#
    DOMDocumentReadyStatePropertyInfo       ,
    dOMDocumentReadyState                   ,
    getDOMDocumentReadyState                ,


-- ** referrer #attr:referrer#
    DOMDocumentReferrerPropertyInfo         ,
    dOMDocumentReferrer                     ,
    getDOMDocumentReferrer                  ,


-- ** securityPolicy #attr:securityPolicy#
    DOMDocumentSecurityPolicyPropertyInfo   ,
    dOMDocumentSecurityPolicy               ,
    getDOMDocumentSecurityPolicy            ,


-- ** selectedStylesheetSet #attr:selectedStylesheetSet#
    DOMDocumentSelectedStylesheetSetPropertyInfo,
    constructDOMDocumentSelectedStylesheetSet,
    dOMDocumentSelectedStylesheetSet        ,
    getDOMDocumentSelectedStylesheetSet     ,
    setDOMDocumentSelectedStylesheetSet     ,


-- ** styleSheets #attr:styleSheets#
    DOMDocumentStyleSheetsPropertyInfo      ,
    dOMDocumentStyleSheets                  ,
    getDOMDocumentStyleSheets               ,


-- ** title #attr:title#
    DOMDocumentTitlePropertyInfo            ,
    constructDOMDocumentTitle               ,
    dOMDocumentTitle                        ,
    getDOMDocumentTitle                     ,
    setDOMDocumentTitle                     ,


-- ** url #attr:url#
    DOMDocumentUrlPropertyInfo              ,
    dOMDocumentUrl                          ,
    getDOMDocumentUrl                       ,


-- ** visibilityState #attr:visibilityState#
    DOMDocumentVisibilityStatePropertyInfo  ,
    dOMDocumentVisibilityState              ,
    getDOMDocumentVisibilityState           ,


-- ** webkitCurrentFullScreenElement #attr:webkitCurrentFullScreenElement#
    DOMDocumentWebkitCurrentFullScreenElementPropertyInfo,
    dOMDocumentWebkitCurrentFullScreenElement,
    getDOMDocumentWebkitCurrentFullScreenElement,


-- ** webkitFullScreenKeyboardInputAllowed #attr:webkitFullScreenKeyboardInputAllowed#
    DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo,
    dOMDocumentWebkitFullScreenKeyboardInputAllowed,
    getDOMDocumentWebkitFullScreenKeyboardInputAllowed,


-- ** webkitFullscreenElement #attr:webkitFullscreenElement#
    DOMDocumentWebkitFullscreenElementPropertyInfo,
    dOMDocumentWebkitFullscreenElement      ,
    getDOMDocumentWebkitFullscreenElement   ,


-- ** webkitFullscreenEnabled #attr:webkitFullscreenEnabled#
    DOMDocumentWebkitFullscreenEnabledPropertyInfo,
    dOMDocumentWebkitFullscreenEnabled      ,
    getDOMDocumentWebkitFullscreenEnabled   ,


-- ** webkitIsFullScreen #attr:webkitIsFullScreen#
    DOMDocumentWebkitIsFullScreenPropertyInfo,
    dOMDocumentWebkitIsFullScreen           ,
    getDOMDocumentWebkitIsFullScreen        ,


-- ** webkitPointerLockElement #attr:webkitPointerLockElement#
    DOMDocumentWebkitPointerLockElementPropertyInfo,
    dOMDocumentWebkitPointerLockElement     ,
    getDOMDocumentWebkitPointerLockElement  ,


-- ** xmlEncoding #attr:xmlEncoding#
    DOMDocumentXmlEncodingPropertyInfo      ,
    dOMDocumentXmlEncoding                  ,
    getDOMDocumentXmlEncoding               ,


-- ** xmlStandalone #attr:xmlStandalone#
    DOMDocumentXmlStandalonePropertyInfo    ,
    constructDOMDocumentXmlStandalone       ,
    dOMDocumentXmlStandalone                ,
    getDOMDocumentXmlStandalone             ,
    setDOMDocumentXmlStandalone             ,


-- ** xmlVersion #attr:xmlVersion#
    DOMDocumentXmlVersionPropertyInfo       ,
    clearDOMDocumentXmlVersion              ,
    constructDOMDocumentXmlVersion          ,
    dOMDocumentXmlVersion                   ,
    getDOMDocumentXmlVersion                ,
    setDOMDocumentXmlVersion                ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit.Interfaces.DOMEventTarget as WebKit.DOMEventTarget
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMAttr as WebKit.DOMAttr
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMCDATASection as WebKit.DOMCDATASection
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMCSSStyleDeclaration as WebKit.DOMCSSStyleDeclaration
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMComment as WebKit.DOMComment
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDOMImplementation as WebKit.DOMDOMImplementation
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDOMNamedFlowCollection as WebKit.DOMDOMNamedFlowCollection
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDOMSecurityPolicy as WebKit.DOMDOMSecurityPolicy
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDOMWindow as WebKit.DOMDOMWindow
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDocumentFragment as WebKit.DOMDocumentFragment
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDocumentType as WebKit.DOMDocumentType
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMElement as WebKit.DOMElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMEntityReference as WebKit.DOMEntityReference
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMEvent as WebKit.DOMEvent
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMHTMLCollection as WebKit.DOMHTMLCollection
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMHTMLElement as WebKit.DOMHTMLElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMHTMLHeadElement as WebKit.DOMHTMLHeadElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMHTMLScriptElement as WebKit.DOMHTMLScriptElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNode as WebKit.DOMNode
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNodeFilter as WebKit.DOMNodeFilter
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNodeIterator as WebKit.DOMNodeIterator
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNodeList as WebKit.DOMNodeList
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMObject as WebKit.DOMObject
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMProcessingInstruction as WebKit.DOMProcessingInstruction
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMRange as WebKit.DOMRange
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMStyleSheetList as WebKit.DOMStyleSheetList
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMText as WebKit.DOMText
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTouch as WebKit.DOMTouch
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTreeWalker as WebKit.DOMTreeWalker
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMXPathExpression as WebKit.DOMXPathExpression
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMXPathNSResolver as WebKit.DOMXPathNSResolver
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMXPathResult as WebKit.DOMXPathResult

newtype DOMDocument = DOMDocument (ManagedPtr DOMDocument)
foreign import ccall "webkit_dom_document_get_type"
    c_webkit_dom_document_get_type :: IO GType

instance GObject DOMDocument where
    gobjectType _ = c_webkit_dom_document_get_type
    

class GObject o => IsDOMDocument o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DOMDocument a) =>
    IsDOMDocument a
#endif
instance IsDOMDocument DOMDocument
instance WebKit.DOMNode.IsDOMNode DOMDocument
instance WebKit.DOMObject.IsDOMObject DOMDocument
instance GObject.Object.IsObject DOMDocument
instance WebKit.DOMEventTarget.IsDOMEventTarget DOMDocument

toDOMDocument :: IsDOMDocument o => o -> IO DOMDocument
toDOMDocument = unsafeCastTo DOMDocument

noDOMDocument :: Maybe DOMDocument
noDOMDocument = Nothing

type family ResolveDOMDocumentMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMDocumentMethod "addEventListener" o = WebKit.DOMEventTarget.DOMEventTargetAddEventListenerMethodInfo
    ResolveDOMDocumentMethod "adoptNode" o = DOMDocumentAdoptNodeMethodInfo
    ResolveDOMDocumentMethod "appendChild" o = WebKit.DOMNode.DOMNodeAppendChildMethodInfo
    ResolveDOMDocumentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMDocumentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMDocumentMethod "caretRangeFromPoint" o = DOMDocumentCaretRangeFromPointMethodInfo
    ResolveDOMDocumentMethod "cloneNode" o = WebKit.DOMNode.DOMNodeCloneNodeMethodInfo
    ResolveDOMDocumentMethod "compareDocumentPosition" o = WebKit.DOMNode.DOMNodeCompareDocumentPositionMethodInfo
    ResolveDOMDocumentMethod "contains" o = WebKit.DOMNode.DOMNodeContainsMethodInfo
    ResolveDOMDocumentMethod "createAttribute" o = DOMDocumentCreateAttributeMethodInfo
    ResolveDOMDocumentMethod "createAttributeNs" o = DOMDocumentCreateAttributeNsMethodInfo
    ResolveDOMDocumentMethod "createCdataSection" o = DOMDocumentCreateCdataSectionMethodInfo
    ResolveDOMDocumentMethod "createComment" o = DOMDocumentCreateCommentMethodInfo
    ResolveDOMDocumentMethod "createCssStyleDeclaration" o = DOMDocumentCreateCssStyleDeclarationMethodInfo
    ResolveDOMDocumentMethod "createDocumentFragment" o = DOMDocumentCreateDocumentFragmentMethodInfo
    ResolveDOMDocumentMethod "createElement" o = DOMDocumentCreateElementMethodInfo
    ResolveDOMDocumentMethod "createElementNs" o = DOMDocumentCreateElementNsMethodInfo
    ResolveDOMDocumentMethod "createEntityReference" o = DOMDocumentCreateEntityReferenceMethodInfo
    ResolveDOMDocumentMethod "createEvent" o = DOMDocumentCreateEventMethodInfo
    ResolveDOMDocumentMethod "createExpression" o = DOMDocumentCreateExpressionMethodInfo
    ResolveDOMDocumentMethod "createNodeIterator" o = DOMDocumentCreateNodeIteratorMethodInfo
    ResolveDOMDocumentMethod "createNsResolver" o = DOMDocumentCreateNsResolverMethodInfo
    ResolveDOMDocumentMethod "createProcessingInstruction" o = DOMDocumentCreateProcessingInstructionMethodInfo
    ResolveDOMDocumentMethod "createRange" o = DOMDocumentCreateRangeMethodInfo
    ResolveDOMDocumentMethod "createTextNode" o = DOMDocumentCreateTextNodeMethodInfo
    ResolveDOMDocumentMethod "createTouch" o = DOMDocumentCreateTouchMethodInfo
    ResolveDOMDocumentMethod "createTreeWalker" o = DOMDocumentCreateTreeWalkerMethodInfo
    ResolveDOMDocumentMethod "dispatchEvent" o = WebKit.DOMNode.DOMNodeDispatchEventMethodInfo
    ResolveDOMDocumentMethod "elementFromPoint" o = DOMDocumentElementFromPointMethodInfo
    ResolveDOMDocumentMethod "evaluate" o = DOMDocumentEvaluateMethodInfo
    ResolveDOMDocumentMethod "execCommand" o = DOMDocumentExecCommandMethodInfo
    ResolveDOMDocumentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMDocumentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMDocumentMethod "hasAttributes" o = WebKit.DOMNode.DOMNodeHasAttributesMethodInfo
    ResolveDOMDocumentMethod "hasChildNodes" o = WebKit.DOMNode.DOMNodeHasChildNodesMethodInfo
    ResolveDOMDocumentMethod "importNode" o = DOMDocumentImportNodeMethodInfo
    ResolveDOMDocumentMethod "insertBefore" o = WebKit.DOMNode.DOMNodeInsertBeforeMethodInfo
    ResolveDOMDocumentMethod "isDefaultNamespace" o = WebKit.DOMNode.DOMNodeIsDefaultNamespaceMethodInfo
    ResolveDOMDocumentMethod "isEqualNode" o = WebKit.DOMNode.DOMNodeIsEqualNodeMethodInfo
    ResolveDOMDocumentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMDocumentMethod "isSameNode" o = WebKit.DOMNode.DOMNodeIsSameNodeMethodInfo
    ResolveDOMDocumentMethod "isSupported" o = WebKit.DOMNode.DOMNodeIsSupportedMethodInfo
    ResolveDOMDocumentMethod "lookupNamespaceUri" o = WebKit.DOMNode.DOMNodeLookupNamespaceUriMethodInfo
    ResolveDOMDocumentMethod "lookupPrefix" o = WebKit.DOMNode.DOMNodeLookupPrefixMethodInfo
    ResolveDOMDocumentMethod "normalize" o = WebKit.DOMNode.DOMNodeNormalizeMethodInfo
    ResolveDOMDocumentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMDocumentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMDocumentMethod "queryCommandEnabled" o = DOMDocumentQueryCommandEnabledMethodInfo
    ResolveDOMDocumentMethod "queryCommandIndeterm" o = DOMDocumentQueryCommandIndetermMethodInfo
    ResolveDOMDocumentMethod "queryCommandState" o = DOMDocumentQueryCommandStateMethodInfo
    ResolveDOMDocumentMethod "queryCommandSupported" o = DOMDocumentQueryCommandSupportedMethodInfo
    ResolveDOMDocumentMethod "queryCommandValue" o = DOMDocumentQueryCommandValueMethodInfo
    ResolveDOMDocumentMethod "querySelector" o = DOMDocumentQuerySelectorMethodInfo
    ResolveDOMDocumentMethod "querySelectorAll" o = DOMDocumentQuerySelectorAllMethodInfo
    ResolveDOMDocumentMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMDocumentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMDocumentMethod "removeChild" o = WebKit.DOMNode.DOMNodeRemoveChildMethodInfo
    ResolveDOMDocumentMethod "removeEventListener" o = WebKit.DOMEventTarget.DOMEventTargetRemoveEventListenerMethodInfo
    ResolveDOMDocumentMethod "replaceChild" o = WebKit.DOMNode.DOMNodeReplaceChildMethodInfo
    ResolveDOMDocumentMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMDocumentMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMDocumentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMDocumentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMDocumentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMDocumentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMDocumentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMDocumentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMDocumentMethod "webkitCancelFullScreen" o = DOMDocumentWebkitCancelFullScreenMethodInfo
    ResolveDOMDocumentMethod "webkitExitFullscreen" o = DOMDocumentWebkitExitFullscreenMethodInfo
    ResolveDOMDocumentMethod "webkitExitPointerLock" o = DOMDocumentWebkitExitPointerLockMethodInfo
    ResolveDOMDocumentMethod "webkitGetNamedFlows" o = DOMDocumentWebkitGetNamedFlowsMethodInfo
    ResolveDOMDocumentMethod "getAnchors" o = DOMDocumentGetAnchorsMethodInfo
    ResolveDOMDocumentMethod "getApplets" o = DOMDocumentGetAppletsMethodInfo
    ResolveDOMDocumentMethod "getAttributes" o = WebKit.DOMNode.DOMNodeGetAttributesMethodInfo
    ResolveDOMDocumentMethod "getBaseUri" o = WebKit.DOMNode.DOMNodeGetBaseUriMethodInfo
    ResolveDOMDocumentMethod "getBody" o = DOMDocumentGetBodyMethodInfo
    ResolveDOMDocumentMethod "getCharacterSet" o = DOMDocumentGetCharacterSetMethodInfo
    ResolveDOMDocumentMethod "getCharset" o = DOMDocumentGetCharsetMethodInfo
    ResolveDOMDocumentMethod "getChildNodes" o = WebKit.DOMNode.DOMNodeGetChildNodesMethodInfo
    ResolveDOMDocumentMethod "getCompatMode" o = DOMDocumentGetCompatModeMethodInfo
    ResolveDOMDocumentMethod "getCookie" o = DOMDocumentGetCookieMethodInfo
    ResolveDOMDocumentMethod "getCurrentScript" o = DOMDocumentGetCurrentScriptMethodInfo
    ResolveDOMDocumentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMDocumentMethod "getDefaultCharset" o = DOMDocumentGetDefaultCharsetMethodInfo
    ResolveDOMDocumentMethod "getDefaultView" o = DOMDocumentGetDefaultViewMethodInfo
    ResolveDOMDocumentMethod "getDoctype" o = DOMDocumentGetDoctypeMethodInfo
    ResolveDOMDocumentMethod "getDocumentElement" o = DOMDocumentGetDocumentElementMethodInfo
    ResolveDOMDocumentMethod "getDocumentUri" o = DOMDocumentGetDocumentUriMethodInfo
    ResolveDOMDocumentMethod "getDomain" o = DOMDocumentGetDomainMethodInfo
    ResolveDOMDocumentMethod "getElementById" o = DOMDocumentGetElementByIdMethodInfo
    ResolveDOMDocumentMethod "getElementsByClassName" o = DOMDocumentGetElementsByClassNameMethodInfo
    ResolveDOMDocumentMethod "getElementsByName" o = DOMDocumentGetElementsByNameMethodInfo
    ResolveDOMDocumentMethod "getElementsByTagName" o = DOMDocumentGetElementsByTagNameMethodInfo
    ResolveDOMDocumentMethod "getElementsByTagNameNs" o = DOMDocumentGetElementsByTagNameNsMethodInfo
    ResolveDOMDocumentMethod "getFirstChild" o = WebKit.DOMNode.DOMNodeGetFirstChildMethodInfo
    ResolveDOMDocumentMethod "getForms" o = DOMDocumentGetFormsMethodInfo
    ResolveDOMDocumentMethod "getHead" o = DOMDocumentGetHeadMethodInfo
    ResolveDOMDocumentMethod "getHidden" o = DOMDocumentGetHiddenMethodInfo
    ResolveDOMDocumentMethod "getImages" o = DOMDocumentGetImagesMethodInfo
    ResolveDOMDocumentMethod "getImplementation" o = DOMDocumentGetImplementationMethodInfo
    ResolveDOMDocumentMethod "getInputEncoding" o = DOMDocumentGetInputEncodingMethodInfo
    ResolveDOMDocumentMethod "getLastChild" o = WebKit.DOMNode.DOMNodeGetLastChildMethodInfo
    ResolveDOMDocumentMethod "getLastModified" o = DOMDocumentGetLastModifiedMethodInfo
    ResolveDOMDocumentMethod "getLinks" o = DOMDocumentGetLinksMethodInfo
    ResolveDOMDocumentMethod "getLocalName" o = WebKit.DOMNode.DOMNodeGetLocalNameMethodInfo
    ResolveDOMDocumentMethod "getNamespaceUri" o = WebKit.DOMNode.DOMNodeGetNamespaceUriMethodInfo
    ResolveDOMDocumentMethod "getNextSibling" o = WebKit.DOMNode.DOMNodeGetNextSiblingMethodInfo
    ResolveDOMDocumentMethod "getNodeName" o = WebKit.DOMNode.DOMNodeGetNodeNameMethodInfo
    ResolveDOMDocumentMethod "getNodeType" o = WebKit.DOMNode.DOMNodeGetNodeTypeMethodInfo
    ResolveDOMDocumentMethod "getNodeValue" o = WebKit.DOMNode.DOMNodeGetNodeValueMethodInfo
    ResolveDOMDocumentMethod "getOverrideStyle" o = DOMDocumentGetOverrideStyleMethodInfo
    ResolveDOMDocumentMethod "getOwnerDocument" o = WebKit.DOMNode.DOMNodeGetOwnerDocumentMethodInfo
    ResolveDOMDocumentMethod "getParentElement" o = WebKit.DOMNode.DOMNodeGetParentElementMethodInfo
    ResolveDOMDocumentMethod "getParentNode" o = WebKit.DOMNode.DOMNodeGetParentNodeMethodInfo
    ResolveDOMDocumentMethod "getPreferredStylesheetSet" o = DOMDocumentGetPreferredStylesheetSetMethodInfo
    ResolveDOMDocumentMethod "getPrefix" o = WebKit.DOMNode.DOMNodeGetPrefixMethodInfo
    ResolveDOMDocumentMethod "getPreviousSibling" o = WebKit.DOMNode.DOMNodeGetPreviousSiblingMethodInfo
    ResolveDOMDocumentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMDocumentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMDocumentMethod "getReadyState" o = DOMDocumentGetReadyStateMethodInfo
    ResolveDOMDocumentMethod "getReferrer" o = DOMDocumentGetReferrerMethodInfo
    ResolveDOMDocumentMethod "getSecurityPolicy" o = DOMDocumentGetSecurityPolicyMethodInfo
    ResolveDOMDocumentMethod "getSelectedStylesheetSet" o = DOMDocumentGetSelectedStylesheetSetMethodInfo
    ResolveDOMDocumentMethod "getStyleSheets" o = DOMDocumentGetStyleSheetsMethodInfo
    ResolveDOMDocumentMethod "getTextContent" o = WebKit.DOMNode.DOMNodeGetTextContentMethodInfo
    ResolveDOMDocumentMethod "getTitle" o = DOMDocumentGetTitleMethodInfo
    ResolveDOMDocumentMethod "getUrl" o = DOMDocumentGetUrlMethodInfo
    ResolveDOMDocumentMethod "getVisibilityState" o = DOMDocumentGetVisibilityStateMethodInfo
    ResolveDOMDocumentMethod "getWebkitCurrentFullScreenElement" o = DOMDocumentGetWebkitCurrentFullScreenElementMethodInfo
    ResolveDOMDocumentMethod "getWebkitFullScreenKeyboardInputAllowed" o = DOMDocumentGetWebkitFullScreenKeyboardInputAllowedMethodInfo
    ResolveDOMDocumentMethod "getWebkitFullscreenElement" o = DOMDocumentGetWebkitFullscreenElementMethodInfo
    ResolveDOMDocumentMethod "getWebkitFullscreenEnabled" o = DOMDocumentGetWebkitFullscreenEnabledMethodInfo
    ResolveDOMDocumentMethod "getWebkitHidden" o = DOMDocumentGetWebkitHiddenMethodInfo
    ResolveDOMDocumentMethod "getWebkitIsFullScreen" o = DOMDocumentGetWebkitIsFullScreenMethodInfo
    ResolveDOMDocumentMethod "getWebkitPointerLockElement" o = DOMDocumentGetWebkitPointerLockElementMethodInfo
    ResolveDOMDocumentMethod "getWebkitVisibilityState" o = DOMDocumentGetWebkitVisibilityStateMethodInfo
    ResolveDOMDocumentMethod "getXmlEncoding" o = DOMDocumentGetXmlEncodingMethodInfo
    ResolveDOMDocumentMethod "getXmlStandalone" o = DOMDocumentGetXmlStandaloneMethodInfo
    ResolveDOMDocumentMethod "getXmlVersion" o = DOMDocumentGetXmlVersionMethodInfo
    ResolveDOMDocumentMethod "setBody" o = DOMDocumentSetBodyMethodInfo
    ResolveDOMDocumentMethod "setCharset" o = DOMDocumentSetCharsetMethodInfo
    ResolveDOMDocumentMethod "setCookie" o = DOMDocumentSetCookieMethodInfo
    ResolveDOMDocumentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMDocumentMethod "setDocumentUri" o = DOMDocumentSetDocumentUriMethodInfo
    ResolveDOMDocumentMethod "setNodeValue" o = WebKit.DOMNode.DOMNodeSetNodeValueMethodInfo
    ResolveDOMDocumentMethod "setPrefix" o = WebKit.DOMNode.DOMNodeSetPrefixMethodInfo
    ResolveDOMDocumentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMDocumentMethod "setSelectedStylesheetSet" o = DOMDocumentSetSelectedStylesheetSetMethodInfo
    ResolveDOMDocumentMethod "setTextContent" o = WebKit.DOMNode.DOMNodeSetTextContentMethodInfo
    ResolveDOMDocumentMethod "setTitle" o = DOMDocumentSetTitleMethodInfo
    ResolveDOMDocumentMethod "setXmlStandalone" o = DOMDocumentSetXmlStandaloneMethodInfo
    ResolveDOMDocumentMethod "setXmlVersion" o = DOMDocumentSetXmlVersionMethodInfo
    ResolveDOMDocumentMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDOMDocumentMethod t DOMDocument, O.MethodInfo info DOMDocument p) => O.IsLabelProxy t (DOMDocument -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDOMDocumentMethod t DOMDocument, O.MethodInfo info DOMDocument p) => O.IsLabel t (DOMDocument -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "anchors"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentAnchors :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
getDOMDocumentAnchors obj = liftIO $ getObjectPropertyObject obj "anchors" WebKit.DOMHTMLCollection.DOMHTMLCollection

data DOMDocumentAnchorsPropertyInfo
instance AttrInfo DOMDocumentAnchorsPropertyInfo where
    type AttrAllowedOps DOMDocumentAnchorsPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentAnchorsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentAnchorsPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentAnchorsPropertyInfo = (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
    type AttrLabel DOMDocumentAnchorsPropertyInfo = "anchors"
    type AttrOrigin DOMDocumentAnchorsPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentAnchors
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "applets"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentApplets :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
getDOMDocumentApplets obj = liftIO $ getObjectPropertyObject obj "applets" WebKit.DOMHTMLCollection.DOMHTMLCollection

data DOMDocumentAppletsPropertyInfo
instance AttrInfo DOMDocumentAppletsPropertyInfo where
    type AttrAllowedOps DOMDocumentAppletsPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentAppletsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentAppletsPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentAppletsPropertyInfo = (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
    type AttrLabel DOMDocumentAppletsPropertyInfo = "applets"
    type AttrOrigin DOMDocumentAppletsPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentApplets
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "body"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentBody :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMHTMLElement.DOMHTMLElement
getDOMDocumentBody obj = liftIO $ checkUnexpectedNothing "getDOMDocumentBody" $ getObjectPropertyObject obj "body" WebKit.DOMHTMLElement.DOMHTMLElement

data DOMDocumentBodyPropertyInfo
instance AttrInfo DOMDocumentBodyPropertyInfo where
    type AttrAllowedOps DOMDocumentBodyPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentBodyPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentBodyPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentBodyPropertyInfo = WebKit.DOMHTMLElement.DOMHTMLElement
    type AttrLabel DOMDocumentBodyPropertyInfo = "body"
    type AttrOrigin DOMDocumentBodyPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentBody
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "character-set"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentCharacterSet :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentCharacterSet obj = liftIO $ getObjectPropertyString obj "character-set"

data DOMDocumentCharacterSetPropertyInfo
instance AttrInfo DOMDocumentCharacterSetPropertyInfo where
    type AttrAllowedOps DOMDocumentCharacterSetPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentCharacterSetPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentCharacterSetPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentCharacterSetPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentCharacterSetPropertyInfo = "character-set"
    type AttrOrigin DOMDocumentCharacterSetPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentCharacterSet
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "charset"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getDOMDocumentCharset :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentCharset obj = liftIO $ getObjectPropertyString obj "charset"

setDOMDocumentCharset :: (MonadIO m, IsDOMDocument o) => o -> T.Text -> m ()
setDOMDocumentCharset obj val = liftIO $ setObjectPropertyString obj "charset" (Just val)

constructDOMDocumentCharset :: (IsDOMDocument o) => T.Text -> IO (GValueConstruct o)
constructDOMDocumentCharset val = constructObjectPropertyString "charset" (Just val)

data DOMDocumentCharsetPropertyInfo
instance AttrInfo DOMDocumentCharsetPropertyInfo where
    type AttrAllowedOps DOMDocumentCharsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentCharsetPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMDocumentCharsetPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentCharsetPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentCharsetPropertyInfo = "charset"
    type AttrOrigin DOMDocumentCharsetPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentCharset
    attrSet _ = setDOMDocumentCharset
    attrConstruct _ = constructDOMDocumentCharset
    attrClear _ = undefined

-- VVV Prop "compat-mode"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentCompatMode :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentCompatMode obj = liftIO $ getObjectPropertyString obj "compat-mode"

data DOMDocumentCompatModePropertyInfo
instance AttrInfo DOMDocumentCompatModePropertyInfo where
    type AttrAllowedOps DOMDocumentCompatModePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentCompatModePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentCompatModePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentCompatModePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentCompatModePropertyInfo = "compat-mode"
    type AttrOrigin DOMDocumentCompatModePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentCompatMode
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "cookie"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentCookie :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentCookie obj = liftIO $ getObjectPropertyString obj "cookie"

setDOMDocumentCookie :: (MonadIO m, IsDOMDocument o) => o -> T.Text -> m ()
setDOMDocumentCookie obj val = liftIO $ setObjectPropertyString obj "cookie" (Just val)

constructDOMDocumentCookie :: (IsDOMDocument o) => T.Text -> IO (GValueConstruct o)
constructDOMDocumentCookie val = constructObjectPropertyString "cookie" (Just val)

clearDOMDocumentCookie :: (MonadIO m, IsDOMDocument o) => o -> m ()
clearDOMDocumentCookie obj = liftIO $ setObjectPropertyString obj "cookie" (Nothing :: Maybe T.Text)

data DOMDocumentCookiePropertyInfo
instance AttrInfo DOMDocumentCookiePropertyInfo where
    type AttrAllowedOps DOMDocumentCookiePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentCookiePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMDocumentCookiePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentCookiePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentCookiePropertyInfo = "cookie"
    type AttrOrigin DOMDocumentCookiePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentCookie
    attrSet _ = setDOMDocumentCookie
    attrConstruct _ = constructDOMDocumentCookie
    attrClear _ = clearDOMDocumentCookie

-- VVV Prop "current-script"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLScriptElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentCurrentScript :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement
getDOMDocumentCurrentScript obj = liftIO $ checkUnexpectedNothing "getDOMDocumentCurrentScript" $ getObjectPropertyObject obj "current-script" WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement

data DOMDocumentCurrentScriptPropertyInfo
instance AttrInfo DOMDocumentCurrentScriptPropertyInfo where
    type AttrAllowedOps DOMDocumentCurrentScriptPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentCurrentScriptPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentCurrentScriptPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentCurrentScriptPropertyInfo = WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement
    type AttrLabel DOMDocumentCurrentScriptPropertyInfo = "current-script"
    type AttrOrigin DOMDocumentCurrentScriptPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentCurrentScript
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "default-charset"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentDefaultCharset :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentDefaultCharset obj = liftIO $ getObjectPropertyString obj "default-charset"

data DOMDocumentDefaultCharsetPropertyInfo
instance AttrInfo DOMDocumentDefaultCharsetPropertyInfo where
    type AttrAllowedOps DOMDocumentDefaultCharsetPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentDefaultCharsetPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentDefaultCharsetPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentDefaultCharsetPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentDefaultCharsetPropertyInfo = "default-charset"
    type AttrOrigin DOMDocumentDefaultCharsetPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentDefaultCharset
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "default-view"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMDOMWindow"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentDefaultView :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMDOMWindow.DOMDOMWindow)
getDOMDocumentDefaultView obj = liftIO $ getObjectPropertyObject obj "default-view" WebKit.DOMDOMWindow.DOMDOMWindow

data DOMDocumentDefaultViewPropertyInfo
instance AttrInfo DOMDocumentDefaultViewPropertyInfo where
    type AttrAllowedOps DOMDocumentDefaultViewPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentDefaultViewPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentDefaultViewPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentDefaultViewPropertyInfo = (Maybe WebKit.DOMDOMWindow.DOMDOMWindow)
    type AttrLabel DOMDocumentDefaultViewPropertyInfo = "default-view"
    type AttrOrigin DOMDocumentDefaultViewPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentDefaultView
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "doctype"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMDocumentType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentDoctype :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMDocumentType.DOMDocumentType
getDOMDocumentDoctype obj = liftIO $ checkUnexpectedNothing "getDOMDocumentDoctype" $ getObjectPropertyObject obj "doctype" WebKit.DOMDocumentType.DOMDocumentType

data DOMDocumentDoctypePropertyInfo
instance AttrInfo DOMDocumentDoctypePropertyInfo where
    type AttrAllowedOps DOMDocumentDoctypePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentDoctypePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentDoctypePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentDoctypePropertyInfo = WebKit.DOMDocumentType.DOMDocumentType
    type AttrLabel DOMDocumentDoctypePropertyInfo = "doctype"
    type AttrOrigin DOMDocumentDoctypePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentDoctype
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "document-element"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentDocumentElement :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMElement.DOMElement
getDOMDocumentDocumentElement obj = liftIO $ checkUnexpectedNothing "getDOMDocumentDocumentElement" $ getObjectPropertyObject obj "document-element" WebKit.DOMElement.DOMElement

data DOMDocumentDocumentElementPropertyInfo
instance AttrInfo DOMDocumentDocumentElementPropertyInfo where
    type AttrAllowedOps DOMDocumentDocumentElementPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentDocumentElementPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentDocumentElementPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentDocumentElementPropertyInfo = WebKit.DOMElement.DOMElement
    type AttrLabel DOMDocumentDocumentElementPropertyInfo = "document-element"
    type AttrOrigin DOMDocumentDocumentElementPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentDocumentElement
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "document-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getDOMDocumentDocumentUri :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentDocumentUri obj = liftIO $ getObjectPropertyString obj "document-uri"

setDOMDocumentDocumentUri :: (MonadIO m, IsDOMDocument o) => o -> T.Text -> m ()
setDOMDocumentDocumentUri obj val = liftIO $ setObjectPropertyString obj "document-uri" (Just val)

constructDOMDocumentDocumentUri :: (IsDOMDocument o) => T.Text -> IO (GValueConstruct o)
constructDOMDocumentDocumentUri val = constructObjectPropertyString "document-uri" (Just val)

data DOMDocumentDocumentUriPropertyInfo
instance AttrInfo DOMDocumentDocumentUriPropertyInfo where
    type AttrAllowedOps DOMDocumentDocumentUriPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentDocumentUriPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMDocumentDocumentUriPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentDocumentUriPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentDocumentUriPropertyInfo = "document-uri"
    type AttrOrigin DOMDocumentDocumentUriPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentDocumentUri
    attrSet _ = setDOMDocumentDocumentUri
    attrConstruct _ = constructDOMDocumentDocumentUri
    attrClear _ = undefined

-- VVV Prop "domain"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentDomain :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentDomain obj = liftIO $ getObjectPropertyString obj "domain"

data DOMDocumentDomainPropertyInfo
instance AttrInfo DOMDocumentDomainPropertyInfo where
    type AttrAllowedOps DOMDocumentDomainPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentDomainPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentDomainPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentDomainPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentDomainPropertyInfo = "domain"
    type AttrOrigin DOMDocumentDomainPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentDomain
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "forms"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentForms :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
getDOMDocumentForms obj = liftIO $ getObjectPropertyObject obj "forms" WebKit.DOMHTMLCollection.DOMHTMLCollection

data DOMDocumentFormsPropertyInfo
instance AttrInfo DOMDocumentFormsPropertyInfo where
    type AttrAllowedOps DOMDocumentFormsPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentFormsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentFormsPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentFormsPropertyInfo = (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
    type AttrLabel DOMDocumentFormsPropertyInfo = "forms"
    type AttrOrigin DOMDocumentFormsPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentForms
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "head"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLHeadElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentHead :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement
getDOMDocumentHead obj = liftIO $ checkUnexpectedNothing "getDOMDocumentHead" $ getObjectPropertyObject obj "head" WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement

data DOMDocumentHeadPropertyInfo
instance AttrInfo DOMDocumentHeadPropertyInfo where
    type AttrAllowedOps DOMDocumentHeadPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentHeadPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentHeadPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentHeadPropertyInfo = WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement
    type AttrLabel DOMDocumentHeadPropertyInfo = "head"
    type AttrOrigin DOMDocumentHeadPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentHead
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "hidden"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentHidden :: (MonadIO m, IsDOMDocument o) => o -> m Bool
getDOMDocumentHidden obj = liftIO $ getObjectPropertyBool obj "hidden"

data DOMDocumentHiddenPropertyInfo
instance AttrInfo DOMDocumentHiddenPropertyInfo where
    type AttrAllowedOps DOMDocumentHiddenPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentHiddenPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentHiddenPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentHiddenPropertyInfo = Bool
    type AttrLabel DOMDocumentHiddenPropertyInfo = "hidden"
    type AttrOrigin DOMDocumentHiddenPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentHidden
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "images"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentImages :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
getDOMDocumentImages obj = liftIO $ getObjectPropertyObject obj "images" WebKit.DOMHTMLCollection.DOMHTMLCollection

data DOMDocumentImagesPropertyInfo
instance AttrInfo DOMDocumentImagesPropertyInfo where
    type AttrAllowedOps DOMDocumentImagesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentImagesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentImagesPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentImagesPropertyInfo = (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
    type AttrLabel DOMDocumentImagesPropertyInfo = "images"
    type AttrOrigin DOMDocumentImagesPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentImages
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "implementation"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMDOMImplementation"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentImplementation :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMDOMImplementation.DOMDOMImplementation)
getDOMDocumentImplementation obj = liftIO $ getObjectPropertyObject obj "implementation" WebKit.DOMDOMImplementation.DOMDOMImplementation

data DOMDocumentImplementationPropertyInfo
instance AttrInfo DOMDocumentImplementationPropertyInfo where
    type AttrAllowedOps DOMDocumentImplementationPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentImplementationPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentImplementationPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentImplementationPropertyInfo = (Maybe WebKit.DOMDOMImplementation.DOMDOMImplementation)
    type AttrLabel DOMDocumentImplementationPropertyInfo = "implementation"
    type AttrOrigin DOMDocumentImplementationPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentImplementation
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "input-encoding"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentInputEncoding :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentInputEncoding obj = liftIO $ getObjectPropertyString obj "input-encoding"

data DOMDocumentInputEncodingPropertyInfo
instance AttrInfo DOMDocumentInputEncodingPropertyInfo where
    type AttrAllowedOps DOMDocumentInputEncodingPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentInputEncodingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentInputEncodingPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentInputEncodingPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentInputEncodingPropertyInfo = "input-encoding"
    type AttrOrigin DOMDocumentInputEncodingPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentInputEncoding
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "last-modified"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentLastModified :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentLastModified obj = liftIO $ getObjectPropertyString obj "last-modified"

data DOMDocumentLastModifiedPropertyInfo
instance AttrInfo DOMDocumentLastModifiedPropertyInfo where
    type AttrAllowedOps DOMDocumentLastModifiedPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentLastModifiedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentLastModifiedPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentLastModifiedPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentLastModifiedPropertyInfo = "last-modified"
    type AttrOrigin DOMDocumentLastModifiedPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentLastModified
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "links"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentLinks :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
getDOMDocumentLinks obj = liftIO $ getObjectPropertyObject obj "links" WebKit.DOMHTMLCollection.DOMHTMLCollection

data DOMDocumentLinksPropertyInfo
instance AttrInfo DOMDocumentLinksPropertyInfo where
    type AttrAllowedOps DOMDocumentLinksPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentLinksPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentLinksPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentLinksPropertyInfo = (Maybe WebKit.DOMHTMLCollection.DOMHTMLCollection)
    type AttrLabel DOMDocumentLinksPropertyInfo = "links"
    type AttrOrigin DOMDocumentLinksPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentLinks
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "preferred-stylesheet-set"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentPreferredStylesheetSet :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentPreferredStylesheetSet obj = liftIO $ getObjectPropertyString obj "preferred-stylesheet-set"

data DOMDocumentPreferredStylesheetSetPropertyInfo
instance AttrInfo DOMDocumentPreferredStylesheetSetPropertyInfo where
    type AttrAllowedOps DOMDocumentPreferredStylesheetSetPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentPreferredStylesheetSetPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentPreferredStylesheetSetPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentPreferredStylesheetSetPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentPreferredStylesheetSetPropertyInfo = "preferred-stylesheet-set"
    type AttrOrigin DOMDocumentPreferredStylesheetSetPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentPreferredStylesheetSet
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "ready-state"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentReadyState :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentReadyState obj = liftIO $ getObjectPropertyString obj "ready-state"

data DOMDocumentReadyStatePropertyInfo
instance AttrInfo DOMDocumentReadyStatePropertyInfo where
    type AttrAllowedOps DOMDocumentReadyStatePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentReadyStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentReadyStatePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentReadyStatePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentReadyStatePropertyInfo = "ready-state"
    type AttrOrigin DOMDocumentReadyStatePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentReadyState
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "referrer"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentReferrer :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentReferrer obj = liftIO $ getObjectPropertyString obj "referrer"

data DOMDocumentReferrerPropertyInfo
instance AttrInfo DOMDocumentReferrerPropertyInfo where
    type AttrAllowedOps DOMDocumentReferrerPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentReferrerPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentReferrerPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentReferrerPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentReferrerPropertyInfo = "referrer"
    type AttrOrigin DOMDocumentReferrerPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentReferrer
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "security-policy"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMDOMSecurityPolicy"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentSecurityPolicy :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy)
getDOMDocumentSecurityPolicy obj = liftIO $ getObjectPropertyObject obj "security-policy" WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy

data DOMDocumentSecurityPolicyPropertyInfo
instance AttrInfo DOMDocumentSecurityPolicyPropertyInfo where
    type AttrAllowedOps DOMDocumentSecurityPolicyPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentSecurityPolicyPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentSecurityPolicyPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentSecurityPolicyPropertyInfo = (Maybe WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy)
    type AttrLabel DOMDocumentSecurityPolicyPropertyInfo = "security-policy"
    type AttrOrigin DOMDocumentSecurityPolicyPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentSecurityPolicy
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "selected-stylesheet-set"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getDOMDocumentSelectedStylesheetSet :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentSelectedStylesheetSet obj = liftIO $ getObjectPropertyString obj "selected-stylesheet-set"

setDOMDocumentSelectedStylesheetSet :: (MonadIO m, IsDOMDocument o) => o -> T.Text -> m ()
setDOMDocumentSelectedStylesheetSet obj val = liftIO $ setObjectPropertyString obj "selected-stylesheet-set" (Just val)

constructDOMDocumentSelectedStylesheetSet :: (IsDOMDocument o) => T.Text -> IO (GValueConstruct o)
constructDOMDocumentSelectedStylesheetSet val = constructObjectPropertyString "selected-stylesheet-set" (Just val)

data DOMDocumentSelectedStylesheetSetPropertyInfo
instance AttrInfo DOMDocumentSelectedStylesheetSetPropertyInfo where
    type AttrAllowedOps DOMDocumentSelectedStylesheetSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentSelectedStylesheetSetPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMDocumentSelectedStylesheetSetPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentSelectedStylesheetSetPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentSelectedStylesheetSetPropertyInfo = "selected-stylesheet-set"
    type AttrOrigin DOMDocumentSelectedStylesheetSetPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentSelectedStylesheetSet
    attrSet _ = setDOMDocumentSelectedStylesheetSet
    attrConstruct _ = constructDOMDocumentSelectedStylesheetSet
    attrClear _ = undefined

-- VVV Prop "style-sheets"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMStyleSheetList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentStyleSheets :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMStyleSheetList.DOMStyleSheetList
getDOMDocumentStyleSheets obj = liftIO $ checkUnexpectedNothing "getDOMDocumentStyleSheets" $ getObjectPropertyObject obj "style-sheets" WebKit.DOMStyleSheetList.DOMStyleSheetList

data DOMDocumentStyleSheetsPropertyInfo
instance AttrInfo DOMDocumentStyleSheetsPropertyInfo where
    type AttrAllowedOps DOMDocumentStyleSheetsPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentStyleSheetsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentStyleSheetsPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentStyleSheetsPropertyInfo = WebKit.DOMStyleSheetList.DOMStyleSheetList
    type AttrLabel DOMDocumentStyleSheetsPropertyInfo = "style-sheets"
    type AttrOrigin DOMDocumentStyleSheetsPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentStyleSheets
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getDOMDocumentTitle :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentTitle obj = liftIO $ getObjectPropertyString obj "title"

setDOMDocumentTitle :: (MonadIO m, IsDOMDocument o) => o -> T.Text -> m ()
setDOMDocumentTitle obj val = liftIO $ setObjectPropertyString obj "title" (Just val)

constructDOMDocumentTitle :: (IsDOMDocument o) => T.Text -> IO (GValueConstruct o)
constructDOMDocumentTitle val = constructObjectPropertyString "title" (Just val)

data DOMDocumentTitlePropertyInfo
instance AttrInfo DOMDocumentTitlePropertyInfo where
    type AttrAllowedOps DOMDocumentTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentTitlePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMDocumentTitlePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentTitlePropertyInfo = "title"
    type AttrOrigin DOMDocumentTitlePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentTitle
    attrSet _ = setDOMDocumentTitle
    attrConstruct _ = constructDOMDocumentTitle
    attrClear _ = undefined

-- VVV Prop "url"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentUrl :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentUrl obj = liftIO $ getObjectPropertyString obj "url"

data DOMDocumentUrlPropertyInfo
instance AttrInfo DOMDocumentUrlPropertyInfo where
    type AttrAllowedOps DOMDocumentUrlPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentUrlPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentUrlPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentUrlPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentUrlPropertyInfo = "url"
    type AttrOrigin DOMDocumentUrlPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentUrl
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "visibility-state"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentVisibilityState :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentVisibilityState obj = liftIO $ getObjectPropertyString obj "visibility-state"

data DOMDocumentVisibilityStatePropertyInfo
instance AttrInfo DOMDocumentVisibilityStatePropertyInfo where
    type AttrAllowedOps DOMDocumentVisibilityStatePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentVisibilityStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentVisibilityStatePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentVisibilityStatePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentVisibilityStatePropertyInfo = "visibility-state"
    type AttrOrigin DOMDocumentVisibilityStatePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentVisibilityState
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-current-full-screen-element"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentWebkitCurrentFullScreenElement :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMElement.DOMElement
getDOMDocumentWebkitCurrentFullScreenElement obj = liftIO $ checkUnexpectedNothing "getDOMDocumentWebkitCurrentFullScreenElement" $ getObjectPropertyObject obj "webkit-current-full-screen-element" WebKit.DOMElement.DOMElement

data DOMDocumentWebkitCurrentFullScreenElementPropertyInfo
instance AttrInfo DOMDocumentWebkitCurrentFullScreenElementPropertyInfo where
    type AttrAllowedOps DOMDocumentWebkitCurrentFullScreenElementPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentWebkitCurrentFullScreenElementPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentWebkitCurrentFullScreenElementPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentWebkitCurrentFullScreenElementPropertyInfo = WebKit.DOMElement.DOMElement
    type AttrLabel DOMDocumentWebkitCurrentFullScreenElementPropertyInfo = "webkit-current-full-screen-element"
    type AttrOrigin DOMDocumentWebkitCurrentFullScreenElementPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentWebkitCurrentFullScreenElement
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-full-screen-keyboard-input-allowed"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentWebkitFullScreenKeyboardInputAllowed :: (MonadIO m, IsDOMDocument o) => o -> m Bool
getDOMDocumentWebkitFullScreenKeyboardInputAllowed obj = liftIO $ getObjectPropertyBool obj "webkit-full-screen-keyboard-input-allowed"

data DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo
instance AttrInfo DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo where
    type AttrAllowedOps DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo = Bool
    type AttrLabel DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo = "webkit-full-screen-keyboard-input-allowed"
    type AttrOrigin DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentWebkitFullScreenKeyboardInputAllowed
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-fullscreen-element"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentWebkitFullscreenElement :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMElement.DOMElement
getDOMDocumentWebkitFullscreenElement obj = liftIO $ checkUnexpectedNothing "getDOMDocumentWebkitFullscreenElement" $ getObjectPropertyObject obj "webkit-fullscreen-element" WebKit.DOMElement.DOMElement

data DOMDocumentWebkitFullscreenElementPropertyInfo
instance AttrInfo DOMDocumentWebkitFullscreenElementPropertyInfo where
    type AttrAllowedOps DOMDocumentWebkitFullscreenElementPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentWebkitFullscreenElementPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentWebkitFullscreenElementPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentWebkitFullscreenElementPropertyInfo = WebKit.DOMElement.DOMElement
    type AttrLabel DOMDocumentWebkitFullscreenElementPropertyInfo = "webkit-fullscreen-element"
    type AttrOrigin DOMDocumentWebkitFullscreenElementPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentWebkitFullscreenElement
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-fullscreen-enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentWebkitFullscreenEnabled :: (MonadIO m, IsDOMDocument o) => o -> m Bool
getDOMDocumentWebkitFullscreenEnabled obj = liftIO $ getObjectPropertyBool obj "webkit-fullscreen-enabled"

data DOMDocumentWebkitFullscreenEnabledPropertyInfo
instance AttrInfo DOMDocumentWebkitFullscreenEnabledPropertyInfo where
    type AttrAllowedOps DOMDocumentWebkitFullscreenEnabledPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentWebkitFullscreenEnabledPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentWebkitFullscreenEnabledPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentWebkitFullscreenEnabledPropertyInfo = Bool
    type AttrLabel DOMDocumentWebkitFullscreenEnabledPropertyInfo = "webkit-fullscreen-enabled"
    type AttrOrigin DOMDocumentWebkitFullscreenEnabledPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentWebkitFullscreenEnabled
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-is-full-screen"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentWebkitIsFullScreen :: (MonadIO m, IsDOMDocument o) => o -> m Bool
getDOMDocumentWebkitIsFullScreen obj = liftIO $ getObjectPropertyBool obj "webkit-is-full-screen"

data DOMDocumentWebkitIsFullScreenPropertyInfo
instance AttrInfo DOMDocumentWebkitIsFullScreenPropertyInfo where
    type AttrAllowedOps DOMDocumentWebkitIsFullScreenPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentWebkitIsFullScreenPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentWebkitIsFullScreenPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentWebkitIsFullScreenPropertyInfo = Bool
    type AttrLabel DOMDocumentWebkitIsFullScreenPropertyInfo = "webkit-is-full-screen"
    type AttrOrigin DOMDocumentWebkitIsFullScreenPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentWebkitIsFullScreen
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-pointer-lock-element"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMElement"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentWebkitPointerLockElement :: (MonadIO m, IsDOMDocument o) => o -> m WebKit.DOMElement.DOMElement
getDOMDocumentWebkitPointerLockElement obj = liftIO $ checkUnexpectedNothing "getDOMDocumentWebkitPointerLockElement" $ getObjectPropertyObject obj "webkit-pointer-lock-element" WebKit.DOMElement.DOMElement

data DOMDocumentWebkitPointerLockElementPropertyInfo
instance AttrInfo DOMDocumentWebkitPointerLockElementPropertyInfo where
    type AttrAllowedOps DOMDocumentWebkitPointerLockElementPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentWebkitPointerLockElementPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentWebkitPointerLockElementPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentWebkitPointerLockElementPropertyInfo = WebKit.DOMElement.DOMElement
    type AttrLabel DOMDocumentWebkitPointerLockElementPropertyInfo = "webkit-pointer-lock-element"
    type AttrOrigin DOMDocumentWebkitPointerLockElementPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentWebkitPointerLockElement
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "xml-encoding"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentXmlEncoding :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentXmlEncoding obj = liftIO $ getObjectPropertyString obj "xml-encoding"

data DOMDocumentXmlEncodingPropertyInfo
instance AttrInfo DOMDocumentXmlEncodingPropertyInfo where
    type AttrAllowedOps DOMDocumentXmlEncodingPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentXmlEncodingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMDocumentXmlEncodingPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentXmlEncodingPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentXmlEncodingPropertyInfo = "xml-encoding"
    type AttrOrigin DOMDocumentXmlEncodingPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentXmlEncoding
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "xml-standalone"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

getDOMDocumentXmlStandalone :: (MonadIO m, IsDOMDocument o) => o -> m Bool
getDOMDocumentXmlStandalone obj = liftIO $ getObjectPropertyBool obj "xml-standalone"

setDOMDocumentXmlStandalone :: (MonadIO m, IsDOMDocument o) => o -> Bool -> m ()
setDOMDocumentXmlStandalone obj val = liftIO $ setObjectPropertyBool obj "xml-standalone" val

constructDOMDocumentXmlStandalone :: (IsDOMDocument o) => Bool -> IO (GValueConstruct o)
constructDOMDocumentXmlStandalone val = constructObjectPropertyBool "xml-standalone" val

data DOMDocumentXmlStandalonePropertyInfo
instance AttrInfo DOMDocumentXmlStandalonePropertyInfo where
    type AttrAllowedOps DOMDocumentXmlStandalonePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMDocumentXmlStandalonePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMDocumentXmlStandalonePropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentXmlStandalonePropertyInfo = Bool
    type AttrLabel DOMDocumentXmlStandalonePropertyInfo = "xml-standalone"
    type AttrOrigin DOMDocumentXmlStandalonePropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentXmlStandalone
    attrSet _ = setDOMDocumentXmlStandalone
    attrConstruct _ = constructDOMDocumentXmlStandalone
    attrClear _ = undefined

-- VVV Prop "xml-version"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getDOMDocumentXmlVersion :: (MonadIO m, IsDOMDocument o) => o -> m (Maybe T.Text)
getDOMDocumentXmlVersion obj = liftIO $ getObjectPropertyString obj "xml-version"

setDOMDocumentXmlVersion :: (MonadIO m, IsDOMDocument o) => o -> T.Text -> m ()
setDOMDocumentXmlVersion obj val = liftIO $ setObjectPropertyString obj "xml-version" (Just val)

constructDOMDocumentXmlVersion :: (IsDOMDocument o) => T.Text -> IO (GValueConstruct o)
constructDOMDocumentXmlVersion val = constructObjectPropertyString "xml-version" (Just val)

clearDOMDocumentXmlVersion :: (MonadIO m, IsDOMDocument o) => o -> m ()
clearDOMDocumentXmlVersion obj = liftIO $ setObjectPropertyString obj "xml-version" (Nothing :: Maybe T.Text)

data DOMDocumentXmlVersionPropertyInfo
instance AttrInfo DOMDocumentXmlVersionPropertyInfo where
    type AttrAllowedOps DOMDocumentXmlVersionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMDocumentXmlVersionPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMDocumentXmlVersionPropertyInfo = IsDOMDocument
    type AttrGetType DOMDocumentXmlVersionPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMDocumentXmlVersionPropertyInfo = "xml-version"
    type AttrOrigin DOMDocumentXmlVersionPropertyInfo = DOMDocument
    attrGet _ = getDOMDocumentXmlVersion
    attrSet _ = setDOMDocumentXmlVersion
    attrConstruct _ = constructDOMDocumentXmlVersion
    attrClear _ = clearDOMDocumentXmlVersion

instance O.HasAttributeList DOMDocument
type instance O.AttributeList DOMDocument = DOMDocumentAttributeList
type DOMDocumentAttributeList = ('[ '("anchors", DOMDocumentAnchorsPropertyInfo), '("applets", DOMDocumentAppletsPropertyInfo), '("baseUri", WebKit.DOMNode.DOMNodeBaseUriPropertyInfo), '("body", DOMDocumentBodyPropertyInfo), '("characterSet", DOMDocumentCharacterSetPropertyInfo), '("charset", DOMDocumentCharsetPropertyInfo), '("childNodes", WebKit.DOMNode.DOMNodeChildNodesPropertyInfo), '("compatMode", DOMDocumentCompatModePropertyInfo), '("cookie", DOMDocumentCookiePropertyInfo), '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("currentScript", DOMDocumentCurrentScriptPropertyInfo), '("defaultCharset", DOMDocumentDefaultCharsetPropertyInfo), '("defaultView", DOMDocumentDefaultViewPropertyInfo), '("doctype", DOMDocumentDoctypePropertyInfo), '("documentElement", DOMDocumentDocumentElementPropertyInfo), '("documentUri", DOMDocumentDocumentUriPropertyInfo), '("domain", DOMDocumentDomainPropertyInfo), '("firstChild", WebKit.DOMNode.DOMNodeFirstChildPropertyInfo), '("forms", DOMDocumentFormsPropertyInfo), '("head", DOMDocumentHeadPropertyInfo), '("hidden", DOMDocumentHiddenPropertyInfo), '("images", DOMDocumentImagesPropertyInfo), '("implementation", DOMDocumentImplementationPropertyInfo), '("inputEncoding", DOMDocumentInputEncodingPropertyInfo), '("lastChild", WebKit.DOMNode.DOMNodeLastChildPropertyInfo), '("lastModified", DOMDocumentLastModifiedPropertyInfo), '("links", DOMDocumentLinksPropertyInfo), '("localName", WebKit.DOMNode.DOMNodeLocalNamePropertyInfo), '("namespaceUri", WebKit.DOMNode.DOMNodeNamespaceUriPropertyInfo), '("nextSibling", WebKit.DOMNode.DOMNodeNextSiblingPropertyInfo), '("nodeName", WebKit.DOMNode.DOMNodeNodeNamePropertyInfo), '("nodeType", WebKit.DOMNode.DOMNodeNodeTypePropertyInfo), '("nodeValue", WebKit.DOMNode.DOMNodeNodeValuePropertyInfo), '("ownerDocument", WebKit.DOMNode.DOMNodeOwnerDocumentPropertyInfo), '("parentElement", WebKit.DOMNode.DOMNodeParentElementPropertyInfo), '("parentNode", WebKit.DOMNode.DOMNodeParentNodePropertyInfo), '("preferredStylesheetSet", DOMDocumentPreferredStylesheetSetPropertyInfo), '("prefix", WebKit.DOMNode.DOMNodePrefixPropertyInfo), '("previousSibling", WebKit.DOMNode.DOMNodePreviousSiblingPropertyInfo), '("readyState", DOMDocumentReadyStatePropertyInfo), '("referrer", DOMDocumentReferrerPropertyInfo), '("securityPolicy", DOMDocumentSecurityPolicyPropertyInfo), '("selectedStylesheetSet", DOMDocumentSelectedStylesheetSetPropertyInfo), '("styleSheets", DOMDocumentStyleSheetsPropertyInfo), '("textContent", WebKit.DOMNode.DOMNodeTextContentPropertyInfo), '("title", DOMDocumentTitlePropertyInfo), '("url", DOMDocumentUrlPropertyInfo), '("visibilityState", DOMDocumentVisibilityStatePropertyInfo), '("webkitCurrentFullScreenElement", DOMDocumentWebkitCurrentFullScreenElementPropertyInfo), '("webkitFullScreenKeyboardInputAllowed", DOMDocumentWebkitFullScreenKeyboardInputAllowedPropertyInfo), '("webkitFullscreenElement", DOMDocumentWebkitFullscreenElementPropertyInfo), '("webkitFullscreenEnabled", DOMDocumentWebkitFullscreenEnabledPropertyInfo), '("webkitIsFullScreen", DOMDocumentWebkitIsFullScreenPropertyInfo), '("webkitPointerLockElement", DOMDocumentWebkitPointerLockElementPropertyInfo), '("xmlEncoding", DOMDocumentXmlEncodingPropertyInfo), '("xmlStandalone", DOMDocumentXmlStandalonePropertyInfo), '("xmlVersion", DOMDocumentXmlVersionPropertyInfo)] :: [(Symbol, *)])

dOMDocumentAnchors :: AttrLabelProxy "anchors"
dOMDocumentAnchors = AttrLabelProxy

dOMDocumentApplets :: AttrLabelProxy "applets"
dOMDocumentApplets = AttrLabelProxy

dOMDocumentBody :: AttrLabelProxy "body"
dOMDocumentBody = AttrLabelProxy

dOMDocumentCharacterSet :: AttrLabelProxy "characterSet"
dOMDocumentCharacterSet = AttrLabelProxy

dOMDocumentCharset :: AttrLabelProxy "charset"
dOMDocumentCharset = AttrLabelProxy

dOMDocumentCompatMode :: AttrLabelProxy "compatMode"
dOMDocumentCompatMode = AttrLabelProxy

dOMDocumentCookie :: AttrLabelProxy "cookie"
dOMDocumentCookie = AttrLabelProxy

dOMDocumentCurrentScript :: AttrLabelProxy "currentScript"
dOMDocumentCurrentScript = AttrLabelProxy

dOMDocumentDefaultCharset :: AttrLabelProxy "defaultCharset"
dOMDocumentDefaultCharset = AttrLabelProxy

dOMDocumentDefaultView :: AttrLabelProxy "defaultView"
dOMDocumentDefaultView = AttrLabelProxy

dOMDocumentDoctype :: AttrLabelProxy "doctype"
dOMDocumentDoctype = AttrLabelProxy

dOMDocumentDocumentElement :: AttrLabelProxy "documentElement"
dOMDocumentDocumentElement = AttrLabelProxy

dOMDocumentDocumentUri :: AttrLabelProxy "documentUri"
dOMDocumentDocumentUri = AttrLabelProxy

dOMDocumentDomain :: AttrLabelProxy "domain"
dOMDocumentDomain = AttrLabelProxy

dOMDocumentForms :: AttrLabelProxy "forms"
dOMDocumentForms = AttrLabelProxy

dOMDocumentHead :: AttrLabelProxy "head"
dOMDocumentHead = AttrLabelProxy

dOMDocumentHidden :: AttrLabelProxy "hidden"
dOMDocumentHidden = AttrLabelProxy

dOMDocumentImages :: AttrLabelProxy "images"
dOMDocumentImages = AttrLabelProxy

dOMDocumentImplementation :: AttrLabelProxy "implementation"
dOMDocumentImplementation = AttrLabelProxy

dOMDocumentInputEncoding :: AttrLabelProxy "inputEncoding"
dOMDocumentInputEncoding = AttrLabelProxy

dOMDocumentLastModified :: AttrLabelProxy "lastModified"
dOMDocumentLastModified = AttrLabelProxy

dOMDocumentLinks :: AttrLabelProxy "links"
dOMDocumentLinks = AttrLabelProxy

dOMDocumentPreferredStylesheetSet :: AttrLabelProxy "preferredStylesheetSet"
dOMDocumentPreferredStylesheetSet = AttrLabelProxy

dOMDocumentReadyState :: AttrLabelProxy "readyState"
dOMDocumentReadyState = AttrLabelProxy

dOMDocumentReferrer :: AttrLabelProxy "referrer"
dOMDocumentReferrer = AttrLabelProxy

dOMDocumentSecurityPolicy :: AttrLabelProxy "securityPolicy"
dOMDocumentSecurityPolicy = AttrLabelProxy

dOMDocumentSelectedStylesheetSet :: AttrLabelProxy "selectedStylesheetSet"
dOMDocumentSelectedStylesheetSet = AttrLabelProxy

dOMDocumentStyleSheets :: AttrLabelProxy "styleSheets"
dOMDocumentStyleSheets = AttrLabelProxy

dOMDocumentTitle :: AttrLabelProxy "title"
dOMDocumentTitle = AttrLabelProxy

dOMDocumentUrl :: AttrLabelProxy "url"
dOMDocumentUrl = AttrLabelProxy

dOMDocumentVisibilityState :: AttrLabelProxy "visibilityState"
dOMDocumentVisibilityState = AttrLabelProxy

dOMDocumentWebkitCurrentFullScreenElement :: AttrLabelProxy "webkitCurrentFullScreenElement"
dOMDocumentWebkitCurrentFullScreenElement = AttrLabelProxy

dOMDocumentWebkitFullScreenKeyboardInputAllowed :: AttrLabelProxy "webkitFullScreenKeyboardInputAllowed"
dOMDocumentWebkitFullScreenKeyboardInputAllowed = AttrLabelProxy

dOMDocumentWebkitFullscreenElement :: AttrLabelProxy "webkitFullscreenElement"
dOMDocumentWebkitFullscreenElement = AttrLabelProxy

dOMDocumentWebkitFullscreenEnabled :: AttrLabelProxy "webkitFullscreenEnabled"
dOMDocumentWebkitFullscreenEnabled = AttrLabelProxy

dOMDocumentWebkitIsFullScreen :: AttrLabelProxy "webkitIsFullScreen"
dOMDocumentWebkitIsFullScreen = AttrLabelProxy

dOMDocumentWebkitPointerLockElement :: AttrLabelProxy "webkitPointerLockElement"
dOMDocumentWebkitPointerLockElement = AttrLabelProxy

dOMDocumentXmlEncoding :: AttrLabelProxy "xmlEncoding"
dOMDocumentXmlEncoding = AttrLabelProxy

dOMDocumentXmlStandalone :: AttrLabelProxy "xmlStandalone"
dOMDocumentXmlStandalone = AttrLabelProxy

dOMDocumentXmlVersion :: AttrLabelProxy "xmlVersion"
dOMDocumentXmlVersion = AttrLabelProxy

type instance O.SignalList DOMDocument = DOMDocumentSignalList
type DOMDocumentSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method DOMDocument::adopt_node
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "WebKit", name = "DOMNode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNode"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_adopt_node" webkit_dom_document_adopt_node :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMNode.DOMNode ->           -- source : TInterface (Name {namespace = "WebKit", name = "DOMNode"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMDocumentAdoptNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@source@/: A 'GI.WebKit.Objects.DOMNode.DOMNode' -}
    -> m WebKit.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNode.DOMNode' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentAdoptNode self source = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    source' <- unsafeManagedPtrCastPtr source
    onException (do
        result <- propagateGError $ webkit_dom_document_adopt_node self' source'
        checkUnexpectedReturnNULL "dOMDocumentAdoptNode" result
        result' <- (newObject WebKit.DOMNode.DOMNode) result
        touchManagedPtr self
        touchManagedPtr source
        return result'
     ) (do
        return ()
     )

data DOMDocumentAdoptNodeMethodInfo
instance (signature ~ (b -> m WebKit.DOMNode.DOMNode), MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b) => O.MethodInfo DOMDocumentAdoptNodeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentAdoptNode

-- method DOMDocument::caret_range_from_point
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMRange"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_caret_range_from_point" webkit_dom_document_caret_range_from_point :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CLong ->                                -- x : TBasicType TLong
    CLong ->                                -- y : TBasicType TLong
    IO (Ptr WebKit.DOMRange.DOMRange)

{- |
/No description available in the introspection data./
-}
dOMDocumentCaretRangeFromPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> CLong
    {- ^ /@x@/: A @/glong/@ -}
    -> CLong
    {- ^ /@y@/: A @/glong/@ -}
    -> m WebKit.DOMRange.DOMRange
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMRange.DOMRange' -}
dOMDocumentCaretRangeFromPoint self x y = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_caret_range_from_point self' x y
    checkUnexpectedReturnNULL "dOMDocumentCaretRangeFromPoint" result
    result' <- (wrapObject WebKit.DOMRange.DOMRange) result
    touchManagedPtr self
    return result'

data DOMDocumentCaretRangeFromPointMethodInfo
instance (signature ~ (CLong -> CLong -> m WebKit.DOMRange.DOMRange), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCaretRangeFromPointMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCaretRangeFromPoint

-- method DOMDocument::create_attribute
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMAttr"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_attribute" webkit_dom_document_create_attribute :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMAttr.DOMAttr)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateAttribute ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@name@/: A @/gchar/@ -}
    -> m WebKit.DOMAttr.DOMAttr
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMAttr.DOMAttr' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateAttribute self name = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    name' <- textToCString name
    onException (do
        result <- propagateGError $ webkit_dom_document_create_attribute self' name'
        checkUnexpectedReturnNULL "dOMDocumentCreateAttribute" result
        result' <- (newObject WebKit.DOMAttr.DOMAttr) result
        touchManagedPtr self
        freeMem name'
        return result'
     ) (do
        freeMem name'
     )

data DOMDocumentCreateAttributeMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMAttr.DOMAttr), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateAttributeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateAttribute

-- method DOMDocument::create_attribute_ns
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespaceURI", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "qualifiedName", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMAttr"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_attribute_ns" webkit_dom_document_create_attribute_ns :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- namespaceURI : TBasicType TUTF8
    CString ->                              -- qualifiedName : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMAttr.DOMAttr)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateAttributeNs ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> Maybe (T.Text)
    {- ^ /@namespaceURI@/: A @/gchar/@ -}
    -> T.Text
    {- ^ /@qualifiedName@/: A @/gchar/@ -}
    -> m WebKit.DOMAttr.DOMAttr
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMAttr.DOMAttr' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateAttributeNs self namespaceURI qualifiedName = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeNamespaceURI <- case namespaceURI of
        Nothing -> return nullPtr
        Just jNamespaceURI -> do
            jNamespaceURI' <- textToCString jNamespaceURI
            return jNamespaceURI'
    qualifiedName' <- textToCString qualifiedName
    onException (do
        result <- propagateGError $ webkit_dom_document_create_attribute_ns self' maybeNamespaceURI qualifiedName'
        checkUnexpectedReturnNULL "dOMDocumentCreateAttributeNs" result
        result' <- (newObject WebKit.DOMAttr.DOMAttr) result
        touchManagedPtr self
        freeMem maybeNamespaceURI
        freeMem qualifiedName'
        return result'
     ) (do
        freeMem maybeNamespaceURI
        freeMem qualifiedName'
     )

data DOMDocumentCreateAttributeNsMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> m WebKit.DOMAttr.DOMAttr), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateAttributeNsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateAttributeNs

-- method DOMDocument::create_cdata_section
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMCDATASection"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_cdata_section" webkit_dom_document_create_cdata_section :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- data : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMCDATASection.DOMCDATASection)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateCdataSection ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@data@/: A @/gchar/@ -}
    -> m WebKit.DOMCDATASection.DOMCDATASection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMCDATASection.DOMCDATASection' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateCdataSection self data_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    data_' <- textToCString data_
    onException (do
        result <- propagateGError $ webkit_dom_document_create_cdata_section self' data_'
        checkUnexpectedReturnNULL "dOMDocumentCreateCdataSection" result
        result' <- (newObject WebKit.DOMCDATASection.DOMCDATASection) result
        touchManagedPtr self
        freeMem data_'
        return result'
     ) (do
        freeMem data_'
     )

data DOMDocumentCreateCdataSectionMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMCDATASection.DOMCDATASection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateCdataSectionMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateCdataSection

-- method DOMDocument::create_comment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMComment"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_create_comment" webkit_dom_document_create_comment :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- data : TBasicType TUTF8
    IO (Ptr WebKit.DOMComment.DOMComment)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateComment ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@data@/: A @/gchar/@ -}
    -> m WebKit.DOMComment.DOMComment
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMComment.DOMComment' -}
dOMDocumentCreateComment self data_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    data_' <- textToCString data_
    result <- webkit_dom_document_create_comment self' data_'
    checkUnexpectedReturnNULL "dOMDocumentCreateComment" result
    result' <- (newObject WebKit.DOMComment.DOMComment) result
    touchManagedPtr self
    freeMem data_'
    return result'

data DOMDocumentCreateCommentMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMComment.DOMComment), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateCommentMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateComment

-- method DOMDocument::create_css_style_declaration
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMCSSStyleDeclaration"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_create_css_style_declaration" webkit_dom_document_create_css_style_declaration :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateCssStyleDeclaration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration' -}
dOMDocumentCreateCssStyleDeclaration self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_create_css_style_declaration self'
    checkUnexpectedReturnNULL "dOMDocumentCreateCssStyleDeclaration" result
    result' <- (wrapObject WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration) result
    touchManagedPtr self
    return result'

data DOMDocumentCreateCssStyleDeclarationMethodInfo
instance (signature ~ (m WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateCssStyleDeclarationMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateCssStyleDeclaration

-- method DOMDocument::create_document_fragment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMDocumentFragment"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_create_document_fragment" webkit_dom_document_create_document_fragment :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMDocumentFragment.DOMDocumentFragment)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateDocumentFragment ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMDocumentFragment.DOMDocumentFragment
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMDocumentFragment.DOMDocumentFragment' -}
dOMDocumentCreateDocumentFragment self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_create_document_fragment self'
    checkUnexpectedReturnNULL "dOMDocumentCreateDocumentFragment" result
    result' <- (newObject WebKit.DOMDocumentFragment.DOMDocumentFragment) result
    touchManagedPtr self
    return result'

data DOMDocumentCreateDocumentFragmentMethodInfo
instance (signature ~ (m WebKit.DOMDocumentFragment.DOMDocumentFragment), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateDocumentFragmentMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateDocumentFragment

-- method DOMDocument::create_element
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tagName", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_element" webkit_dom_document_create_element :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- tagName : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@tagName@/: A @/gchar/@ -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateElement self tagName = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    tagName' <- textToCString tagName
    onException (do
        result <- propagateGError $ webkit_dom_document_create_element self' tagName'
        checkUnexpectedReturnNULL "dOMDocumentCreateElement" result
        result' <- (newObject WebKit.DOMElement.DOMElement) result
        touchManagedPtr self
        freeMem tagName'
        return result'
     ) (do
        freeMem tagName'
     )

data DOMDocumentCreateElementMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateElementMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateElement

-- method DOMDocument::create_element_ns
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespaceURI", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "qualifiedName", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_element_ns" webkit_dom_document_create_element_ns :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- namespaceURI : TBasicType TUTF8
    CString ->                              -- qualifiedName : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateElementNs ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> Maybe (T.Text)
    {- ^ /@namespaceURI@/: A @/gchar/@ -}
    -> T.Text
    {- ^ /@qualifiedName@/: A @/gchar/@ -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateElementNs self namespaceURI qualifiedName = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeNamespaceURI <- case namespaceURI of
        Nothing -> return nullPtr
        Just jNamespaceURI -> do
            jNamespaceURI' <- textToCString jNamespaceURI
            return jNamespaceURI'
    qualifiedName' <- textToCString qualifiedName
    onException (do
        result <- propagateGError $ webkit_dom_document_create_element_ns self' maybeNamespaceURI qualifiedName'
        checkUnexpectedReturnNULL "dOMDocumentCreateElementNs" result
        result' <- (newObject WebKit.DOMElement.DOMElement) result
        touchManagedPtr self
        freeMem maybeNamespaceURI
        freeMem qualifiedName'
        return result'
     ) (do
        freeMem maybeNamespaceURI
        freeMem qualifiedName'
     )

data DOMDocumentCreateElementNsMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateElementNsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateElementNs

-- method DOMDocument::create_entity_reference
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMEntityReference"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_entity_reference" webkit_dom_document_create_entity_reference :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMEntityReference.DOMEntityReference)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateEntityReference ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> Maybe (T.Text)
    {- ^ /@name@/: A @/gchar/@ -}
    -> m WebKit.DOMEntityReference.DOMEntityReference
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMEntityReference.DOMEntityReference' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateEntityReference self name = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeName <- case name of
        Nothing -> return nullPtr
        Just jName -> do
            jName' <- textToCString jName
            return jName'
    onException (do
        result <- propagateGError $ webkit_dom_document_create_entity_reference self' maybeName
        checkUnexpectedReturnNULL "dOMDocumentCreateEntityReference" result
        result' <- (newObject WebKit.DOMEntityReference.DOMEntityReference) result
        touchManagedPtr self
        freeMem maybeName
        return result'
     ) (do
        freeMem maybeName
     )

data DOMDocumentCreateEntityReferenceMethodInfo
instance (signature ~ (Maybe (T.Text) -> m WebKit.DOMEntityReference.DOMEntityReference), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateEntityReferenceMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateEntityReference

-- method DOMDocument::create_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "eventType", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMEvent"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_event" webkit_dom_document_create_event :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- eventType : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMEvent.DOMEvent)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@eventType@/: A @/gchar/@ -}
    -> m WebKit.DOMEvent.DOMEvent
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMEvent.DOMEvent' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateEvent self eventType = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    eventType' <- textToCString eventType
    onException (do
        result <- propagateGError $ webkit_dom_document_create_event self' eventType'
        checkUnexpectedReturnNULL "dOMDocumentCreateEvent" result
        result' <- (wrapObject WebKit.DOMEvent.DOMEvent) result
        touchManagedPtr self
        freeMem eventType'
        return result'
     ) (do
        freeMem eventType'
     )

data DOMDocumentCreateEventMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMEvent.DOMEvent), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateEventMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateEvent

-- method DOMDocument::create_expression
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expression", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resolver", argType = TInterface (Name {namespace = "WebKit", name = "DOMXPathNSResolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMXPathNSResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMXPathExpression"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_expression" webkit_dom_document_create_expression :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- expression : TBasicType TUTF8
    Ptr WebKit.DOMXPathNSResolver.DOMXPathNSResolver -> -- resolver : TInterface (Name {namespace = "WebKit", name = "DOMXPathNSResolver"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMXPathExpression.DOMXPathExpression)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMXPathNSResolver.IsDOMXPathNSResolver b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@expression@/: A @/gchar/@ -}
    -> b
    {- ^ /@resolver@/: A 'GI.WebKit.Objects.DOMXPathNSResolver.DOMXPathNSResolver' -}
    -> m WebKit.DOMXPathExpression.DOMXPathExpression
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMXPathExpression.DOMXPathExpression' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateExpression self expression resolver = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    expression' <- textToCString expression
    resolver' <- unsafeManagedPtrCastPtr resolver
    onException (do
        result <- propagateGError $ webkit_dom_document_create_expression self' expression' resolver'
        checkUnexpectedReturnNULL "dOMDocumentCreateExpression" result
        result' <- (wrapObject WebKit.DOMXPathExpression.DOMXPathExpression) result
        touchManagedPtr self
        touchManagedPtr resolver
        freeMem expression'
        return result'
     ) (do
        freeMem expression'
     )

data DOMDocumentCreateExpressionMethodInfo
instance (signature ~ (T.Text -> b -> m WebKit.DOMXPathExpression.DOMXPathExpression), MonadIO m, IsDOMDocument a, WebKit.DOMXPathNSResolver.IsDOMXPathNSResolver b) => O.MethodInfo DOMDocumentCreateExpressionMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateExpression

-- method DOMDocument::create_node_iterator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "root", argType = TInterface (Name {namespace = "WebKit", name = "DOMNode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "whatToShow", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gulong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "WebKit", name = "DOMNodeFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNodeFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expandEntityReferences", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNodeIterator"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_node_iterator" webkit_dom_document_create_node_iterator :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMNode.DOMNode ->           -- root : TInterface (Name {namespace = "WebKit", name = "DOMNode"})
    CULong ->                               -- whatToShow : TBasicType TULong
    Ptr WebKit.DOMNodeFilter.DOMNodeFilter -> -- filter : TInterface (Name {namespace = "WebKit", name = "DOMNodeFilter"})
    CInt ->                                 -- expandEntityReferences : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMNodeIterator.DOMNodeIterator)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateNodeIterator ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b, WebKit.DOMNodeFilter.IsDOMNodeFilter c) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@root@/: A 'GI.WebKit.Objects.DOMNode.DOMNode' -}
    -> CULong
    {- ^ /@whatToShow@/: A @/gulong/@ -}
    -> c
    {- ^ /@filter@/: A 'GI.WebKit.Objects.DOMNodeFilter.DOMNodeFilter' -}
    -> Bool
    {- ^ /@expandEntityReferences@/: A 'Bool' -}
    -> m WebKit.DOMNodeIterator.DOMNodeIterator
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNodeIterator.DOMNodeIterator' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateNodeIterator self root whatToShow filter expandEntityReferences = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    root' <- unsafeManagedPtrCastPtr root
    filter' <- unsafeManagedPtrCastPtr filter
    let expandEntityReferences' = (fromIntegral . fromEnum) expandEntityReferences
    onException (do
        result <- propagateGError $ webkit_dom_document_create_node_iterator self' root' whatToShow filter' expandEntityReferences'
        checkUnexpectedReturnNULL "dOMDocumentCreateNodeIterator" result
        result' <- (wrapObject WebKit.DOMNodeIterator.DOMNodeIterator) result
        touchManagedPtr self
        touchManagedPtr root
        touchManagedPtr filter
        return result'
     ) (do
        return ()
     )

data DOMDocumentCreateNodeIteratorMethodInfo
instance (signature ~ (b -> CULong -> c -> Bool -> m WebKit.DOMNodeIterator.DOMNodeIterator), MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b, WebKit.DOMNodeFilter.IsDOMNodeFilter c) => O.MethodInfo DOMDocumentCreateNodeIteratorMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateNodeIterator

-- method DOMDocument::create_ns_resolver
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nodeResolver", argType = TInterface (Name {namespace = "WebKit", name = "DOMNode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMXPathNSResolver"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_create_ns_resolver" webkit_dom_document_create_ns_resolver :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMNode.DOMNode ->           -- nodeResolver : TInterface (Name {namespace = "WebKit", name = "DOMNode"})
    IO (Ptr WebKit.DOMXPathNSResolver.DOMXPathNSResolver)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateNsResolver ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@nodeResolver@/: A 'GI.WebKit.Objects.DOMNode.DOMNode' -}
    -> m WebKit.DOMXPathNSResolver.DOMXPathNSResolver
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMXPathNSResolver.DOMXPathNSResolver' -}
dOMDocumentCreateNsResolver self nodeResolver = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    nodeResolver' <- unsafeManagedPtrCastPtr nodeResolver
    result <- webkit_dom_document_create_ns_resolver self' nodeResolver'
    checkUnexpectedReturnNULL "dOMDocumentCreateNsResolver" result
    result' <- (wrapObject WebKit.DOMXPathNSResolver.DOMXPathNSResolver) result
    touchManagedPtr self
    touchManagedPtr nodeResolver
    return result'

data DOMDocumentCreateNsResolverMethodInfo
instance (signature ~ (b -> m WebKit.DOMXPathNSResolver.DOMXPathNSResolver), MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b) => O.MethodInfo DOMDocumentCreateNsResolverMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateNsResolver

-- method DOMDocument::create_processing_instruction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMProcessingInstruction"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_processing_instruction" webkit_dom_document_create_processing_instruction :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- target : TBasicType TUTF8
    CString ->                              -- data : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMProcessingInstruction.DOMProcessingInstruction)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateProcessingInstruction ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@target@/: A @/gchar/@ -}
    -> T.Text
    {- ^ /@data@/: A @/gchar/@ -}
    -> m WebKit.DOMProcessingInstruction.DOMProcessingInstruction
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMProcessingInstruction.DOMProcessingInstruction' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateProcessingInstruction self target data_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    target' <- textToCString target
    data_' <- textToCString data_
    onException (do
        result <- propagateGError $ webkit_dom_document_create_processing_instruction self' target' data_'
        checkUnexpectedReturnNULL "dOMDocumentCreateProcessingInstruction" result
        result' <- (newObject WebKit.DOMProcessingInstruction.DOMProcessingInstruction) result
        touchManagedPtr self
        freeMem target'
        freeMem data_'
        return result'
     ) (do
        freeMem target'
        freeMem data_'
     )

data DOMDocumentCreateProcessingInstructionMethodInfo
instance (signature ~ (T.Text -> T.Text -> m WebKit.DOMProcessingInstruction.DOMProcessingInstruction), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateProcessingInstructionMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateProcessingInstruction

-- method DOMDocument::create_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMRange"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_create_range" webkit_dom_document_create_range :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMRange.DOMRange)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateRange ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMRange.DOMRange
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMRange.DOMRange' -}
dOMDocumentCreateRange self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_create_range self'
    checkUnexpectedReturnNULL "dOMDocumentCreateRange" result
    result' <- (wrapObject WebKit.DOMRange.DOMRange) result
    touchManagedPtr self
    return result'

data DOMDocumentCreateRangeMethodInfo
instance (signature ~ (m WebKit.DOMRange.DOMRange), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateRangeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateRange

-- method DOMDocument::create_text_node
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMText"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_create_text_node" webkit_dom_document_create_text_node :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- data : TBasicType TUTF8
    IO (Ptr WebKit.DOMText.DOMText)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateTextNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@data@/: A @/gchar/@ -}
    -> m WebKit.DOMText.DOMText
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMText.DOMText' -}
dOMDocumentCreateTextNode self data_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    data_' <- textToCString data_
    result <- webkit_dom_document_create_text_node self' data_'
    checkUnexpectedReturnNULL "dOMDocumentCreateTextNode" result
    result' <- (newObject WebKit.DOMText.DOMText) result
    touchManagedPtr self
    freeMem data_'
    return result'

data DOMDocumentCreateTextNodeMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMText.DOMText), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentCreateTextNodeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateTextNode

-- method DOMDocument::create_touch
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "WebKit", name = "DOMDOMWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDOMWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "WebKit", name = "DOMEventTarget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMEventTarget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identifier", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pageX", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pageY", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screenX", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screenY", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "webkitRadiusX", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "webkitRadiusY", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "webkitRotationAngle", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gfloat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "webkitForce", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gfloat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTouch"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_touch" webkit_dom_document_create_touch :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMDOMWindow.DOMDOMWindow -> -- window : TInterface (Name {namespace = "WebKit", name = "DOMDOMWindow"})
    Ptr WebKit.DOMEventTarget.DOMEventTarget -> -- target : TInterface (Name {namespace = "WebKit", name = "DOMEventTarget"})
    CLong ->                                -- identifier : TBasicType TLong
    CLong ->                                -- pageX : TBasicType TLong
    CLong ->                                -- pageY : TBasicType TLong
    CLong ->                                -- screenX : TBasicType TLong
    CLong ->                                -- screenY : TBasicType TLong
    CLong ->                                -- webkitRadiusX : TBasicType TLong
    CLong ->                                -- webkitRadiusY : TBasicType TLong
    CFloat ->                               -- webkitRotationAngle : TBasicType TFloat
    CFloat ->                               -- webkitForce : TBasicType TFloat
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMTouch.DOMTouch)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateTouch ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMDOMWindow.IsDOMDOMWindow b, WebKit.DOMEventTarget.IsDOMEventTarget c) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@window@/: A 'GI.WebKit.Objects.DOMDOMWindow.DOMDOMWindow' -}
    -> c
    {- ^ /@target@/: A 'GI.WebKit.Interfaces.DOMEventTarget.DOMEventTarget' -}
    -> CLong
    {- ^ /@identifier@/: A @/glong/@ -}
    -> CLong
    {- ^ /@pageX@/: A @/glong/@ -}
    -> CLong
    {- ^ /@pageY@/: A @/glong/@ -}
    -> CLong
    {- ^ /@screenX@/: A @/glong/@ -}
    -> CLong
    {- ^ /@screenY@/: A @/glong/@ -}
    -> CLong
    {- ^ /@webkitRadiusX@/: A @/glong/@ -}
    -> CLong
    {- ^ /@webkitRadiusY@/: A @/glong/@ -}
    -> Float
    {- ^ /@webkitRotationAngle@/: A @/gfloat/@ -}
    -> Float
    {- ^ /@webkitForce@/: A @/gfloat/@ -}
    -> m WebKit.DOMTouch.DOMTouch
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTouch.DOMTouch' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateTouch self window target identifier pageX pageY screenX screenY webkitRadiusX webkitRadiusY webkitRotationAngle webkitForce = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    window' <- unsafeManagedPtrCastPtr window
    target' <- unsafeManagedPtrCastPtr target
    let webkitRotationAngle' = realToFrac webkitRotationAngle
    let webkitForce' = realToFrac webkitForce
    onException (do
        result <- propagateGError $ webkit_dom_document_create_touch self' window' target' identifier pageX pageY screenX screenY webkitRadiusX webkitRadiusY webkitRotationAngle' webkitForce'
        checkUnexpectedReturnNULL "dOMDocumentCreateTouch" result
        result' <- (wrapObject WebKit.DOMTouch.DOMTouch) result
        touchManagedPtr self
        touchManagedPtr window
        touchManagedPtr target
        return result'
     ) (do
        return ()
     )

data DOMDocumentCreateTouchMethodInfo
instance (signature ~ (b -> c -> CLong -> CLong -> CLong -> CLong -> CLong -> CLong -> CLong -> Float -> Float -> m WebKit.DOMTouch.DOMTouch), MonadIO m, IsDOMDocument a, WebKit.DOMDOMWindow.IsDOMDOMWindow b, WebKit.DOMEventTarget.IsDOMEventTarget c) => O.MethodInfo DOMDocumentCreateTouchMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateTouch

-- method DOMDocument::create_tree_walker
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "root", argType = TInterface (Name {namespace = "WebKit", name = "DOMNode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "whatToShow", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gulong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "WebKit", name = "DOMNodeFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNodeFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expandEntityReferences", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTreeWalker"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_create_tree_walker" webkit_dom_document_create_tree_walker :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMNode.DOMNode ->           -- root : TInterface (Name {namespace = "WebKit", name = "DOMNode"})
    CULong ->                               -- whatToShow : TBasicType TULong
    Ptr WebKit.DOMNodeFilter.DOMNodeFilter -> -- filter : TInterface (Name {namespace = "WebKit", name = "DOMNodeFilter"})
    CInt ->                                 -- expandEntityReferences : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMTreeWalker.DOMTreeWalker)

{- |
/No description available in the introspection data./
-}
dOMDocumentCreateTreeWalker ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b, WebKit.DOMNodeFilter.IsDOMNodeFilter c) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@root@/: A 'GI.WebKit.Objects.DOMNode.DOMNode' -}
    -> CULong
    {- ^ /@whatToShow@/: A @/gulong/@ -}
    -> c
    {- ^ /@filter@/: A 'GI.WebKit.Objects.DOMNodeFilter.DOMNodeFilter' -}
    -> Bool
    {- ^ /@expandEntityReferences@/: A 'Bool' -}
    -> m WebKit.DOMTreeWalker.DOMTreeWalker
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTreeWalker.DOMTreeWalker' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentCreateTreeWalker self root whatToShow filter expandEntityReferences = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    root' <- unsafeManagedPtrCastPtr root
    filter' <- unsafeManagedPtrCastPtr filter
    let expandEntityReferences' = (fromIntegral . fromEnum) expandEntityReferences
    onException (do
        result <- propagateGError $ webkit_dom_document_create_tree_walker self' root' whatToShow filter' expandEntityReferences'
        checkUnexpectedReturnNULL "dOMDocumentCreateTreeWalker" result
        result' <- (wrapObject WebKit.DOMTreeWalker.DOMTreeWalker) result
        touchManagedPtr self
        touchManagedPtr root
        touchManagedPtr filter
        return result'
     ) (do
        return ()
     )

data DOMDocumentCreateTreeWalkerMethodInfo
instance (signature ~ (b -> CULong -> c -> Bool -> m WebKit.DOMTreeWalker.DOMTreeWalker), MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b, WebKit.DOMNodeFilter.IsDOMNodeFilter c) => O.MethodInfo DOMDocumentCreateTreeWalkerMethodInfo a signature where
    overloadedMethod _ = dOMDocumentCreateTreeWalker

-- method DOMDocument::element_from_point
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #glong", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_element_from_point" webkit_dom_document_element_from_point :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CLong ->                                -- x : TBasicType TLong
    CLong ->                                -- y : TBasicType TLong
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentElementFromPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> CLong
    {- ^ /@x@/: A @/glong/@ -}
    -> CLong
    {- ^ /@y@/: A @/glong/@ -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
dOMDocumentElementFromPoint self x y = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_element_from_point self' x y
    checkUnexpectedReturnNULL "dOMDocumentElementFromPoint" result
    result' <- (newObject WebKit.DOMElement.DOMElement) result
    touchManagedPtr self
    return result'

data DOMDocumentElementFromPointMethodInfo
instance (signature ~ (CLong -> CLong -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentElementFromPointMethodInfo a signature where
    overloadedMethod _ = dOMDocumentElementFromPoint

-- method DOMDocument::evaluate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expression", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "contextNode", argType = TInterface (Name {namespace = "WebKit", name = "DOMNode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resolver", argType = TInterface (Name {namespace = "WebKit", name = "DOMXPathNSResolver"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #WebKitDOMXPathNSResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gushort", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "inResult", argType = TInterface (Name {namespace = "WebKit", name = "DOMXPathResult"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #WebKitDOMXPathResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMXPathResult"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_evaluate" webkit_dom_document_evaluate :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- expression : TBasicType TUTF8
    Ptr WebKit.DOMNode.DOMNode ->           -- contextNode : TInterface (Name {namespace = "WebKit", name = "DOMNode"})
    Ptr WebKit.DOMXPathNSResolver.DOMXPathNSResolver -> -- resolver : TInterface (Name {namespace = "WebKit", name = "DOMXPathNSResolver"})
    Word16 ->                               -- type : TBasicType TUInt16
    Ptr WebKit.DOMXPathResult.DOMXPathResult -> -- inResult : TInterface (Name {namespace = "WebKit", name = "DOMXPathResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMXPathResult.DOMXPathResult)

{- |
/No description available in the introspection data./
-}
dOMDocumentEvaluate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b, WebKit.DOMXPathNSResolver.IsDOMXPathNSResolver c, WebKit.DOMXPathResult.IsDOMXPathResult d) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@expression@/: A @/gchar/@ -}
    -> b
    {- ^ /@contextNode@/: A 'GI.WebKit.Objects.DOMNode.DOMNode' -}
    -> Maybe (c)
    {- ^ /@resolver@/: A 'GI.WebKit.Objects.DOMXPathNSResolver.DOMXPathNSResolver' -}
    -> Word16
    {- ^ /@type@/: A @/gushort/@ -}
    -> Maybe (d)
    {- ^ /@inResult@/: A 'GI.WebKit.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m WebKit.DOMXPathResult.DOMXPathResult
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMXPathResult.DOMXPathResult' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentEvaluate self expression contextNode resolver type_ inResult = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    expression' <- textToCString expression
    contextNode' <- unsafeManagedPtrCastPtr contextNode
    maybeResolver <- case resolver of
        Nothing -> return nullPtr
        Just jResolver -> do
            jResolver' <- unsafeManagedPtrCastPtr jResolver
            return jResolver'
    maybeInResult <- case inResult of
        Nothing -> return nullPtr
        Just jInResult -> do
            jInResult' <- unsafeManagedPtrCastPtr jInResult
            return jInResult'
    onException (do
        result <- propagateGError $ webkit_dom_document_evaluate self' expression' contextNode' maybeResolver type_ maybeInResult
        checkUnexpectedReturnNULL "dOMDocumentEvaluate" result
        result' <- (wrapObject WebKit.DOMXPathResult.DOMXPathResult) result
        touchManagedPtr self
        touchManagedPtr contextNode
        whenJust resolver touchManagedPtr
        whenJust inResult touchManagedPtr
        freeMem expression'
        return result'
     ) (do
        freeMem expression'
     )

data DOMDocumentEvaluateMethodInfo
instance (signature ~ (T.Text -> b -> Maybe (c) -> Word16 -> Maybe (d) -> m WebKit.DOMXPathResult.DOMXPathResult), MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b, WebKit.DOMXPathNSResolver.IsDOMXPathNSResolver c, WebKit.DOMXPathResult.IsDOMXPathResult d) => O.MethodInfo DOMDocumentEvaluateMethodInfo a signature where
    overloadedMethod _ = dOMDocumentEvaluate

-- method DOMDocument::exec_command
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userInterface", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_exec_command" webkit_dom_document_exec_command :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- command : TBasicType TUTF8
    CInt ->                                 -- userInterface : TBasicType TBoolean
    CString ->                              -- value : TBasicType TUTF8
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentExecCommand ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@command@/: A @/gchar/@ -}
    -> Bool
    {- ^ /@userInterface@/: A 'Bool' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentExecCommand self command userInterface value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    command' <- textToCString command
    let userInterface' = (fromIntegral . fromEnum) userInterface
    value' <- textToCString value
    result <- webkit_dom_document_exec_command self' command' userInterface' value'
    let result' = (/= 0) result
    touchManagedPtr self
    freeMem command'
    freeMem value'
    return result'

data DOMDocumentExecCommandMethodInfo
instance (signature ~ (T.Text -> Bool -> T.Text -> m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentExecCommandMethodInfo a signature where
    overloadedMethod _ = dOMDocumentExecCommand

-- method DOMDocument::get_anchors
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_anchors" webkit_dom_document_get_anchors :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLCollection.DOMHTMLCollection)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetAnchors ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLCollection.DOMHTMLCollection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLCollection.DOMHTMLCollection' -}
dOMDocumentGetAnchors self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_anchors self'
    checkUnexpectedReturnNULL "dOMDocumentGetAnchors" result
    result' <- (wrapObject WebKit.DOMHTMLCollection.DOMHTMLCollection) result
    touchManagedPtr self
    return result'

data DOMDocumentGetAnchorsMethodInfo
instance (signature ~ (m WebKit.DOMHTMLCollection.DOMHTMLCollection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetAnchorsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetAnchors

-- method DOMDocument::get_applets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_applets" webkit_dom_document_get_applets :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLCollection.DOMHTMLCollection)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetApplets ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLCollection.DOMHTMLCollection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLCollection.DOMHTMLCollection' -}
dOMDocumentGetApplets self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_applets self'
    checkUnexpectedReturnNULL "dOMDocumentGetApplets" result
    result' <- (wrapObject WebKit.DOMHTMLCollection.DOMHTMLCollection) result
    touchManagedPtr self
    return result'

data DOMDocumentGetAppletsMethodInfo
instance (signature ~ (m WebKit.DOMHTMLCollection.DOMHTMLCollection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetAppletsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetApplets

-- method DOMDocument::get_body
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_body" webkit_dom_document_get_body :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLElement.DOMHTMLElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLElement.DOMHTMLElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLElement.DOMHTMLElement' -}
dOMDocumentGetBody self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_body self'
    checkUnexpectedReturnNULL "dOMDocumentGetBody" result
    result' <- (newObject WebKit.DOMHTMLElement.DOMHTMLElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetBodyMethodInfo
instance (signature ~ (m WebKit.DOMHTMLElement.DOMHTMLElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetBodyMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetBody

-- method DOMDocument::get_character_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_character_set" webkit_dom_document_get_character_set :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetCharacterSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetCharacterSet self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_character_set self'
    checkUnexpectedReturnNULL "dOMDocumentGetCharacterSet" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetCharacterSetMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetCharacterSetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetCharacterSet

-- method DOMDocument::get_charset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_charset" webkit_dom_document_get_charset :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetCharset ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetCharset self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_charset self'
    checkUnexpectedReturnNULL "dOMDocumentGetCharset" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetCharsetMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetCharsetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetCharset

-- method DOMDocument::get_compat_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_compat_mode" webkit_dom_document_get_compat_mode :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetCompatMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetCompatMode self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_compat_mode self'
    checkUnexpectedReturnNULL "dOMDocumentGetCompatMode" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetCompatModeMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetCompatModeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetCompatMode

-- method DOMDocument::get_cookie
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_get_cookie" webkit_dom_document_get_cookie :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr (Ptr GError) ->                     -- error
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetCookie ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentGetCookie self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_document_get_cookie self'
        checkUnexpectedReturnNULL "dOMDocumentGetCookie" result
        result' <- cstringToText result
        freeMem result
        touchManagedPtr self
        return result'
     ) (do
        return ()
     )

data DOMDocumentGetCookieMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetCookieMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetCookie

-- method DOMDocument::get_current_script
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLScriptElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_current_script" webkit_dom_document_get_current_script :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetCurrentScript ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLScriptElement.DOMHTMLScriptElement' -}
dOMDocumentGetCurrentScript self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_current_script self'
    checkUnexpectedReturnNULL "dOMDocumentGetCurrentScript" result
    result' <- (newObject WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetCurrentScriptMethodInfo
instance (signature ~ (m WebKit.DOMHTMLScriptElement.DOMHTMLScriptElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetCurrentScriptMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetCurrentScript

-- method DOMDocument::get_default_charset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_default_charset" webkit_dom_document_get_default_charset :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetDefaultCharset ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetDefaultCharset self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_default_charset self'
    checkUnexpectedReturnNULL "dOMDocumentGetDefaultCharset" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetDefaultCharsetMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetDefaultCharsetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetDefaultCharset

-- method DOMDocument::get_default_view
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMDOMWindow"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_default_view" webkit_dom_document_get_default_view :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMDOMWindow.DOMDOMWindow)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetDefaultView ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMDOMWindow.DOMDOMWindow
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMDOMWindow.DOMDOMWindow' -}
dOMDocumentGetDefaultView self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_default_view self'
    checkUnexpectedReturnNULL "dOMDocumentGetDefaultView" result
    result' <- (wrapObject WebKit.DOMDOMWindow.DOMDOMWindow) result
    touchManagedPtr self
    return result'

data DOMDocumentGetDefaultViewMethodInfo
instance (signature ~ (m WebKit.DOMDOMWindow.DOMDOMWindow), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetDefaultViewMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetDefaultView

-- method DOMDocument::get_doctype
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMDocumentType"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_doctype" webkit_dom_document_get_doctype :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMDocumentType.DOMDocumentType)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetDoctype ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMDocumentType.DOMDocumentType
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMDocumentType.DOMDocumentType' -}
dOMDocumentGetDoctype self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_doctype self'
    checkUnexpectedReturnNULL "dOMDocumentGetDoctype" result
    result' <- (newObject WebKit.DOMDocumentType.DOMDocumentType) result
    touchManagedPtr self
    return result'

data DOMDocumentGetDoctypeMethodInfo
instance (signature ~ (m WebKit.DOMDocumentType.DOMDocumentType), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetDoctypeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetDoctype

-- method DOMDocument::get_document_element
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_document_element" webkit_dom_document_get_document_element :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetDocumentElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
dOMDocumentGetDocumentElement self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_document_element self'
    checkUnexpectedReturnNULL "dOMDocumentGetDocumentElement" result
    result' <- (newObject WebKit.DOMElement.DOMElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetDocumentElementMethodInfo
instance (signature ~ (m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetDocumentElementMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetDocumentElement

-- method DOMDocument::get_document_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_document_uri" webkit_dom_document_get_document_uri :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetDocumentUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetDocumentUri self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_document_uri self'
    checkUnexpectedReturnNULL "dOMDocumentGetDocumentUri" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetDocumentUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetDocumentUriMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetDocumentUri

-- method DOMDocument::get_domain
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_domain" webkit_dom_document_get_domain :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetDomain ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetDomain self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_domain self'
    checkUnexpectedReturnNULL "dOMDocumentGetDomain" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetDomainMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetDomainMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetDomain

-- method DOMDocument::get_element_by_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elementId", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_element_by_id" webkit_dom_document_get_element_by_id :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- elementId : TBasicType TUTF8
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetElementById ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@elementId@/: A @/gchar/@ -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
dOMDocumentGetElementById self elementId = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    elementId' <- textToCString elementId
    result <- webkit_dom_document_get_element_by_id self' elementId'
    checkUnexpectedReturnNULL "dOMDocumentGetElementById" result
    result' <- (newObject WebKit.DOMElement.DOMElement) result
    touchManagedPtr self
    freeMem elementId'
    return result'

data DOMDocumentGetElementByIdMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetElementByIdMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetElementById

-- method DOMDocument::get_elements_by_class_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tagname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNodeList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_elements_by_class_name" webkit_dom_document_get_elements_by_class_name :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- tagname : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetElementsByClassName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@tagname@/: A @/gchar/@ -}
    -> m WebKit.DOMNodeList.DOMNodeList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNodeList.DOMNodeList' -}
dOMDocumentGetElementsByClassName self tagname = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    tagname' <- textToCString tagname
    result <- webkit_dom_document_get_elements_by_class_name self' tagname'
    checkUnexpectedReturnNULL "dOMDocumentGetElementsByClassName" result
    result' <- (wrapObject WebKit.DOMNodeList.DOMNodeList) result
    touchManagedPtr self
    freeMem tagname'
    return result'

data DOMDocumentGetElementsByClassNameMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetElementsByClassNameMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetElementsByClassName

-- method DOMDocument::get_elements_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elementName", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNodeList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_elements_by_name" webkit_dom_document_get_elements_by_name :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- elementName : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetElementsByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@elementName@/: A @/gchar/@ -}
    -> m WebKit.DOMNodeList.DOMNodeList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNodeList.DOMNodeList' -}
dOMDocumentGetElementsByName self elementName = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    elementName' <- textToCString elementName
    result <- webkit_dom_document_get_elements_by_name self' elementName'
    checkUnexpectedReturnNULL "dOMDocumentGetElementsByName" result
    result' <- (wrapObject WebKit.DOMNodeList.DOMNodeList) result
    touchManagedPtr self
    freeMem elementName'
    return result'

data DOMDocumentGetElementsByNameMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetElementsByNameMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetElementsByName

-- method DOMDocument::get_elements_by_tag_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tagname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNodeList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_elements_by_tag_name" webkit_dom_document_get_elements_by_tag_name :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- tagname : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetElementsByTagName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@tagname@/: A @/gchar/@ -}
    -> m WebKit.DOMNodeList.DOMNodeList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNodeList.DOMNodeList' -}
dOMDocumentGetElementsByTagName self tagname = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    tagname' <- textToCString tagname
    result <- webkit_dom_document_get_elements_by_tag_name self' tagname'
    checkUnexpectedReturnNULL "dOMDocumentGetElementsByTagName" result
    result' <- (wrapObject WebKit.DOMNodeList.DOMNodeList) result
    touchManagedPtr self
    freeMem tagname'
    return result'

data DOMDocumentGetElementsByTagNameMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetElementsByTagNameMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetElementsByTagName

-- method DOMDocument::get_elements_by_tag_name_ns
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespaceURI", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "localName", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNodeList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_elements_by_tag_name_ns" webkit_dom_document_get_elements_by_tag_name_ns :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- namespaceURI : TBasicType TUTF8
    CString ->                              -- localName : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetElementsByTagNameNs ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@namespaceURI@/: A @/gchar/@ -}
    -> T.Text
    {- ^ /@localName@/: A @/gchar/@ -}
    -> m WebKit.DOMNodeList.DOMNodeList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNodeList.DOMNodeList' -}
dOMDocumentGetElementsByTagNameNs self namespaceURI localName = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    namespaceURI' <- textToCString namespaceURI
    localName' <- textToCString localName
    result <- webkit_dom_document_get_elements_by_tag_name_ns self' namespaceURI' localName'
    checkUnexpectedReturnNULL "dOMDocumentGetElementsByTagNameNs" result
    result' <- (wrapObject WebKit.DOMNodeList.DOMNodeList) result
    touchManagedPtr self
    freeMem namespaceURI'
    freeMem localName'
    return result'

data DOMDocumentGetElementsByTagNameNsMethodInfo
instance (signature ~ (T.Text -> T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetElementsByTagNameNsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetElementsByTagNameNs

-- method DOMDocument::get_forms
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_forms" webkit_dom_document_get_forms :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLCollection.DOMHTMLCollection)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetForms ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLCollection.DOMHTMLCollection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLCollection.DOMHTMLCollection' -}
dOMDocumentGetForms self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_forms self'
    checkUnexpectedReturnNULL "dOMDocumentGetForms" result
    result' <- (wrapObject WebKit.DOMHTMLCollection.DOMHTMLCollection) result
    touchManagedPtr self
    return result'

data DOMDocumentGetFormsMethodInfo
instance (signature ~ (m WebKit.DOMHTMLCollection.DOMHTMLCollection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetFormsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetForms

-- method DOMDocument::get_head
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLHeadElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_head" webkit_dom_document_get_head :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetHead ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLHeadElement.DOMHTMLHeadElement' -}
dOMDocumentGetHead self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_head self'
    checkUnexpectedReturnNULL "dOMDocumentGetHead" result
    result' <- (newObject WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetHeadMethodInfo
instance (signature ~ (m WebKit.DOMHTMLHeadElement.DOMHTMLHeadElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetHeadMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetHead

-- method DOMDocument::get_hidden
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_hidden" webkit_dom_document_get_hidden :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentGetHidden ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentGetHidden self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_hidden self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMDocumentGetHiddenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetHiddenMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetHidden

-- method DOMDocument::get_images
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_images" webkit_dom_document_get_images :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLCollection.DOMHTMLCollection)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetImages ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLCollection.DOMHTMLCollection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLCollection.DOMHTMLCollection' -}
dOMDocumentGetImages self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_images self'
    checkUnexpectedReturnNULL "dOMDocumentGetImages" result
    result' <- (wrapObject WebKit.DOMHTMLCollection.DOMHTMLCollection) result
    touchManagedPtr self
    return result'

data DOMDocumentGetImagesMethodInfo
instance (signature ~ (m WebKit.DOMHTMLCollection.DOMHTMLCollection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetImagesMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetImages

-- method DOMDocument::get_implementation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMDOMImplementation"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_implementation" webkit_dom_document_get_implementation :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMDOMImplementation.DOMDOMImplementation)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetImplementation ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMDOMImplementation.DOMDOMImplementation
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMDOMImplementation.DOMDOMImplementation' -}
dOMDocumentGetImplementation self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_implementation self'
    checkUnexpectedReturnNULL "dOMDocumentGetImplementation" result
    result' <- (wrapObject WebKit.DOMDOMImplementation.DOMDOMImplementation) result
    touchManagedPtr self
    return result'

data DOMDocumentGetImplementationMethodInfo
instance (signature ~ (m WebKit.DOMDOMImplementation.DOMDOMImplementation), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetImplementationMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetImplementation

-- method DOMDocument::get_input_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_input_encoding" webkit_dom_document_get_input_encoding :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetInputEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetInputEncoding self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_input_encoding self'
    checkUnexpectedReturnNULL "dOMDocumentGetInputEncoding" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetInputEncodingMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetInputEncodingMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetInputEncoding

-- method DOMDocument::get_last_modified
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_last_modified" webkit_dom_document_get_last_modified :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetLastModified ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetLastModified self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_last_modified self'
    checkUnexpectedReturnNULL "dOMDocumentGetLastModified" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetLastModifiedMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetLastModifiedMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetLastModified

-- method DOMDocument::get_links
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMHTMLCollection"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_links" webkit_dom_document_get_links :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMHTMLCollection.DOMHTMLCollection)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetLinks ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMHTMLCollection.DOMHTMLCollection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMHTMLCollection.DOMHTMLCollection' -}
dOMDocumentGetLinks self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_links self'
    checkUnexpectedReturnNULL "dOMDocumentGetLinks" result
    result' <- (wrapObject WebKit.DOMHTMLCollection.DOMHTMLCollection) result
    touchManagedPtr self
    return result'

data DOMDocumentGetLinksMethodInfo
instance (signature ~ (m WebKit.DOMHTMLCollection.DOMHTMLCollection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetLinksMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetLinks

-- method DOMDocument::get_override_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface (Name {namespace = "WebKit", name = "DOMElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pseudoElement", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMCSSStyleDeclaration"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_override_style" webkit_dom_document_get_override_style :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMElement.DOMElement ->     -- element : TInterface (Name {namespace = "WebKit", name = "DOMElement"})
    CString ->                              -- pseudoElement : TBasicType TUTF8
    IO (Ptr WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetOverrideStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMElement.IsDOMElement b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@element@/: A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
    -> Maybe (T.Text)
    {- ^ /@pseudoElement@/: A @/gchar/@ -}
    -> m WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration' -}
dOMDocumentGetOverrideStyle self element pseudoElement = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    element' <- unsafeManagedPtrCastPtr element
    maybePseudoElement <- case pseudoElement of
        Nothing -> return nullPtr
        Just jPseudoElement -> do
            jPseudoElement' <- textToCString jPseudoElement
            return jPseudoElement'
    result <- webkit_dom_document_get_override_style self' element' maybePseudoElement
    checkUnexpectedReturnNULL "dOMDocumentGetOverrideStyle" result
    result' <- (wrapObject WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration) result
    touchManagedPtr self
    touchManagedPtr element
    freeMem maybePseudoElement
    return result'

data DOMDocumentGetOverrideStyleMethodInfo
instance (signature ~ (b -> Maybe (T.Text) -> m WebKit.DOMCSSStyleDeclaration.DOMCSSStyleDeclaration), MonadIO m, IsDOMDocument a, WebKit.DOMElement.IsDOMElement b) => O.MethodInfo DOMDocumentGetOverrideStyleMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetOverrideStyle

-- method DOMDocument::get_preferred_stylesheet_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_preferred_stylesheet_set" webkit_dom_document_get_preferred_stylesheet_set :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetPreferredStylesheetSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetPreferredStylesheetSet self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_preferred_stylesheet_set self'
    checkUnexpectedReturnNULL "dOMDocumentGetPreferredStylesheetSet" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetPreferredStylesheetSetMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetPreferredStylesheetSetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetPreferredStylesheetSet

-- method DOMDocument::get_ready_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_ready_state" webkit_dom_document_get_ready_state :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetReadyState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetReadyState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_ready_state self'
    checkUnexpectedReturnNULL "dOMDocumentGetReadyState" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetReadyStateMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetReadyStateMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetReadyState

-- method DOMDocument::get_referrer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_referrer" webkit_dom_document_get_referrer :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetReferrer ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetReferrer self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_referrer self'
    checkUnexpectedReturnNULL "dOMDocumentGetReferrer" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetReferrerMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetReferrerMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetReferrer

-- method DOMDocument::get_security_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMDOMSecurityPolicy"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_security_policy" webkit_dom_document_get_security_policy :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetSecurityPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy' -}
dOMDocumentGetSecurityPolicy self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_security_policy self'
    checkUnexpectedReturnNULL "dOMDocumentGetSecurityPolicy" result
    result' <- (wrapObject WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy) result
    touchManagedPtr self
    return result'

data DOMDocumentGetSecurityPolicyMethodInfo
instance (signature ~ (m WebKit.DOMDOMSecurityPolicy.DOMDOMSecurityPolicy), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetSecurityPolicyMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetSecurityPolicy

-- method DOMDocument::get_selected_stylesheet_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_selected_stylesheet_set" webkit_dom_document_get_selected_stylesheet_set :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetSelectedStylesheetSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetSelectedStylesheetSet self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_selected_stylesheet_set self'
    checkUnexpectedReturnNULL "dOMDocumentGetSelectedStylesheetSet" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetSelectedStylesheetSetMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetSelectedStylesheetSetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetSelectedStylesheetSet

-- method DOMDocument::get_style_sheets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMStyleSheetList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_style_sheets" webkit_dom_document_get_style_sheets :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMStyleSheetList.DOMStyleSheetList)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetStyleSheets ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMStyleSheetList.DOMStyleSheetList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMStyleSheetList.DOMStyleSheetList' -}
dOMDocumentGetStyleSheets self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_style_sheets self'
    checkUnexpectedReturnNULL "dOMDocumentGetStyleSheets" result
    result' <- (newObject WebKit.DOMStyleSheetList.DOMStyleSheetList) result
    touchManagedPtr self
    return result'

data DOMDocumentGetStyleSheetsMethodInfo
instance (signature ~ (m WebKit.DOMStyleSheetList.DOMStyleSheetList), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetStyleSheetsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetStyleSheets

-- method DOMDocument::get_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_title" webkit_dom_document_get_title :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetTitle self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_title self'
    checkUnexpectedReturnNULL "dOMDocumentGetTitle" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetTitleMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetTitle

-- method DOMDocument::get_url
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_url" webkit_dom_document_get_url :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetUrl ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetUrl self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_url self'
    checkUnexpectedReturnNULL "dOMDocumentGetUrl" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetUrlMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetUrlMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetUrl

-- method DOMDocument::get_visibility_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_visibility_state" webkit_dom_document_get_visibility_state :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetVisibilityState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetVisibilityState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_visibility_state self'
    checkUnexpectedReturnNULL "dOMDocumentGetVisibilityState" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetVisibilityStateMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetVisibilityStateMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetVisibilityState

-- method DOMDocument::get_webkit_current_full_screen_element
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_current_full_screen_element" webkit_dom_document_get_webkit_current_full_screen_element :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetWebkitCurrentFullScreenElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
dOMDocumentGetWebkitCurrentFullScreenElement self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_current_full_screen_element self'
    checkUnexpectedReturnNULL "dOMDocumentGetWebkitCurrentFullScreenElement" result
    result' <- (newObject WebKit.DOMElement.DOMElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitCurrentFullScreenElementMethodInfo
instance (signature ~ (m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitCurrentFullScreenElementMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitCurrentFullScreenElement

-- method DOMDocument::get_webkit_full_screen_keyboard_input_allowed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_full_screen_keyboard_input_allowed" webkit_dom_document_get_webkit_full_screen_keyboard_input_allowed :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentGetWebkitFullScreenKeyboardInputAllowed ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentGetWebkitFullScreenKeyboardInputAllowed self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_full_screen_keyboard_input_allowed self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitFullScreenKeyboardInputAllowedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitFullScreenKeyboardInputAllowedMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitFullScreenKeyboardInputAllowed

-- method DOMDocument::get_webkit_fullscreen_element
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_fullscreen_element" webkit_dom_document_get_webkit_fullscreen_element :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetWebkitFullscreenElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
dOMDocumentGetWebkitFullscreenElement self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_fullscreen_element self'
    checkUnexpectedReturnNULL "dOMDocumentGetWebkitFullscreenElement" result
    result' <- (newObject WebKit.DOMElement.DOMElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitFullscreenElementMethodInfo
instance (signature ~ (m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitFullscreenElementMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitFullscreenElement

-- method DOMDocument::get_webkit_fullscreen_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_fullscreen_enabled" webkit_dom_document_get_webkit_fullscreen_enabled :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentGetWebkitFullscreenEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentGetWebkitFullscreenEnabled self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_fullscreen_enabled self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitFullscreenEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitFullscreenEnabledMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitFullscreenEnabled

-- method DOMDocument::get_webkit_hidden
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_hidden" webkit_dom_document_get_webkit_hidden :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CInt

{-# DEPRECATED dOMDocumentGetWebkitHidden ["(Since version 2.2)"] #-}
{- |
This functionality has been removed from WebKit, this function does nothing.
-}
dOMDocumentGetWebkitHidden ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentGetWebkitHidden self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_hidden self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitHiddenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitHiddenMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitHidden

-- method DOMDocument::get_webkit_is_full_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_is_full_screen" webkit_dom_document_get_webkit_is_full_screen :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentGetWebkitIsFullScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentGetWebkitIsFullScreen self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_is_full_screen self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitIsFullScreenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitIsFullScreenMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitIsFullScreen

-- method DOMDocument::get_webkit_pointer_lock_element
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_pointer_lock_element" webkit_dom_document_get_webkit_pointer_lock_element :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentGetWebkitPointerLockElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' -}
dOMDocumentGetWebkitPointerLockElement self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_pointer_lock_element self'
    checkUnexpectedReturnNULL "dOMDocumentGetWebkitPointerLockElement" result
    result' <- (newObject WebKit.DOMElement.DOMElement) result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitPointerLockElementMethodInfo
instance (signature ~ (m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitPointerLockElementMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitPointerLockElement

-- method DOMDocument::get_webkit_visibility_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_webkit_visibility_state" webkit_dom_document_get_webkit_visibility_state :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{-# DEPRECATED dOMDocumentGetWebkitVisibilityState ["(Since version 2.2)"] #-}
{- |
This functionality has been removed from WebKit, this function does nothing.
-}
dOMDocumentGetWebkitVisibilityState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetWebkitVisibilityState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_webkit_visibility_state self'
    checkUnexpectedReturnNULL "dOMDocumentGetWebkitVisibilityState" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetWebkitVisibilityStateMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetWebkitVisibilityStateMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetWebkitVisibilityState

-- method DOMDocument::get_xml_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_xml_encoding" webkit_dom_document_get_xml_encoding :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetXmlEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetXmlEncoding self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_xml_encoding self'
    checkUnexpectedReturnNULL "dOMDocumentGetXmlEncoding" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetXmlEncodingMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetXmlEncodingMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetXmlEncoding

-- method DOMDocument::get_xml_standalone
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_xml_standalone" webkit_dom_document_get_xml_standalone :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentGetXmlStandalone ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentGetXmlStandalone self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_xml_standalone self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMDocumentGetXmlStandaloneMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetXmlStandaloneMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetXmlStandalone

-- method DOMDocument::get_xml_version
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_get_xml_version" webkit_dom_document_get_xml_version :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentGetXmlVersion ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentGetXmlVersion self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_get_xml_version self'
    checkUnexpectedReturnNULL "dOMDocumentGetXmlVersion" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMDocumentGetXmlVersionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentGetXmlVersionMethodInfo a signature where
    overloadedMethod _ = dOMDocumentGetXmlVersion

-- method DOMDocument::import_node
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "importedNode", argType = TInterface (Name {namespace = "WebKit", name = "DOMNode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deep", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNode"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_import_node" webkit_dom_document_import_node :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMNode.DOMNode ->           -- importedNode : TInterface (Name {namespace = "WebKit", name = "DOMNode"})
    CInt ->                                 -- deep : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMDocumentImportNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@importedNode@/: A 'GI.WebKit.Objects.DOMNode.DOMNode' -}
    -> Bool
    {- ^ /@deep@/: A 'Bool' -}
    -> m WebKit.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNode.DOMNode' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentImportNode self importedNode deep = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    importedNode' <- unsafeManagedPtrCastPtr importedNode
    let deep' = (fromIntegral . fromEnum) deep
    onException (do
        result <- propagateGError $ webkit_dom_document_import_node self' importedNode' deep'
        checkUnexpectedReturnNULL "dOMDocumentImportNode" result
        result' <- (newObject WebKit.DOMNode.DOMNode) result
        touchManagedPtr self
        touchManagedPtr importedNode
        return result'
     ) (do
        return ()
     )

data DOMDocumentImportNodeMethodInfo
instance (signature ~ (b -> Bool -> m WebKit.DOMNode.DOMNode), MonadIO m, IsDOMDocument a, WebKit.DOMNode.IsDOMNode b) => O.MethodInfo DOMDocumentImportNodeMethodInfo a signature where
    overloadedMethod _ = dOMDocumentImportNode

-- method DOMDocument::query_command_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_query_command_enabled" webkit_dom_document_query_command_enabled :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- command : TBasicType TUTF8
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentQueryCommandEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@command@/: A @/gchar/@ -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentQueryCommandEnabled self command = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    command' <- textToCString command
    result <- webkit_dom_document_query_command_enabled self' command'
    let result' = (/= 0) result
    touchManagedPtr self
    freeMem command'
    return result'

data DOMDocumentQueryCommandEnabledMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQueryCommandEnabledMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQueryCommandEnabled

-- method DOMDocument::query_command_indeterm
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_query_command_indeterm" webkit_dom_document_query_command_indeterm :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- command : TBasicType TUTF8
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentQueryCommandIndeterm ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@command@/: A @/gchar/@ -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentQueryCommandIndeterm self command = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    command' <- textToCString command
    result <- webkit_dom_document_query_command_indeterm self' command'
    let result' = (/= 0) result
    touchManagedPtr self
    freeMem command'
    return result'

data DOMDocumentQueryCommandIndetermMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQueryCommandIndetermMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQueryCommandIndeterm

-- method DOMDocument::query_command_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_query_command_state" webkit_dom_document_query_command_state :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- command : TBasicType TUTF8
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentQueryCommandState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@command@/: A @/gchar/@ -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentQueryCommandState self command = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    command' <- textToCString command
    result <- webkit_dom_document_query_command_state self' command'
    let result' = (/= 0) result
    touchManagedPtr self
    freeMem command'
    return result'

data DOMDocumentQueryCommandStateMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQueryCommandStateMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQueryCommandState

-- method DOMDocument::query_command_supported
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_query_command_supported" webkit_dom_document_query_command_supported :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- command : TBasicType TUTF8
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMDocumentQueryCommandSupported ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@command@/: A @/gchar/@ -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMDocumentQueryCommandSupported self command = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    command' <- textToCString command
    result <- webkit_dom_document_query_command_supported self' command'
    let result' = (/= 0) result
    touchManagedPtr self
    freeMem command'
    return result'

data DOMDocumentQueryCommandSupportedMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQueryCommandSupportedMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQueryCommandSupported

-- method DOMDocument::query_command_value
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_query_command_value" webkit_dom_document_query_command_value :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- command : TBasicType TUTF8
    IO CString

{- |
/No description available in the introspection data./
-}
dOMDocumentQueryCommandValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@command@/: A @/gchar/@ -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMDocumentQueryCommandValue self command = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    command' <- textToCString command
    result <- webkit_dom_document_query_command_value self' command'
    checkUnexpectedReturnNULL "dOMDocumentQueryCommandValue" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    freeMem command'
    return result'

data DOMDocumentQueryCommandValueMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQueryCommandValueMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQueryCommandValue

-- method DOMDocument::query_selector
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selectors", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMElement"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_query_selector" webkit_dom_document_query_selector :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- selectors : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMElement.DOMElement)

{- |
/No description available in the introspection data./
-}
dOMDocumentQuerySelector ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@selectors@/: A @/gchar/@ -}
    -> m WebKit.DOMElement.DOMElement
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMElement.DOMElement' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentQuerySelector self selectors = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    selectors' <- textToCString selectors
    onException (do
        result <- propagateGError $ webkit_dom_document_query_selector self' selectors'
        checkUnexpectedReturnNULL "dOMDocumentQuerySelector" result
        result' <- (newObject WebKit.DOMElement.DOMElement) result
        touchManagedPtr self
        freeMem selectors'
        return result'
     ) (do
        freeMem selectors'
     )

data DOMDocumentQuerySelectorMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQuerySelectorMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQuerySelector

-- method DOMDocument::query_selector_all
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selectors", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMNodeList"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_query_selector_all" webkit_dom_document_query_selector_all :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- selectors : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

{- |
/No description available in the introspection data./
-}
dOMDocumentQuerySelectorAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@selectors@/: A @/gchar/@ -}
    -> m WebKit.DOMNodeList.DOMNodeList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMNodeList.DOMNodeList' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentQuerySelectorAll self selectors = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    selectors' <- textToCString selectors
    onException (do
        result <- propagateGError $ webkit_dom_document_query_selector_all self' selectors'
        checkUnexpectedReturnNULL "dOMDocumentQuerySelectorAll" result
        result' <- (wrapObject WebKit.DOMNodeList.DOMNodeList) result
        touchManagedPtr self
        freeMem selectors'
        return result'
     ) (do
        freeMem selectors'
     )

data DOMDocumentQuerySelectorAllMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentQuerySelectorAllMethodInfo a signature where
    overloadedMethod _ = dOMDocumentQuerySelectorAll

-- method DOMDocument::set_body
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_set_body" webkit_dom_document_set_body :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    Ptr WebKit.DOMHTMLElement.DOMHTMLElement -> -- value : TInterface (Name {namespace = "WebKit", name = "DOMHTMLElement"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a, WebKit.DOMHTMLElement.IsDOMHTMLElement b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> b
    {- ^ /@value@/: A 'GI.WebKit.Objects.DOMHTMLElement.DOMHTMLElement' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentSetBody self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- unsafeManagedPtrCastPtr value
    onException (do
        propagateGError $ webkit_dom_document_set_body self' value'
        touchManagedPtr self
        touchManagedPtr value
        return ()
     ) (do
        return ()
     )

data DOMDocumentSetBodyMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMDocument a, WebKit.DOMHTMLElement.IsDOMHTMLElement b) => O.MethodInfo DOMDocumentSetBodyMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetBody

-- method DOMDocument::set_charset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_set_charset" webkit_dom_document_set_charset :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetCharset ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
dOMDocumentSetCharset self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    webkit_dom_document_set_charset self' value'
    touchManagedPtr self
    freeMem value'
    return ()

data DOMDocumentSetCharsetMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetCharsetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetCharset

-- method DOMDocument::set_cookie
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_set_cookie" webkit_dom_document_set_cookie :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- value : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetCookie ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentSetCookie self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    onException (do
        propagateGError $ webkit_dom_document_set_cookie self' value'
        touchManagedPtr self
        freeMem value'
        return ()
     ) (do
        freeMem value'
     )

data DOMDocumentSetCookieMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetCookieMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetCookie

-- method DOMDocument::set_document_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_set_document_uri" webkit_dom_document_set_document_uri :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetDocumentUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
dOMDocumentSetDocumentUri self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    webkit_dom_document_set_document_uri self' value'
    touchManagedPtr self
    freeMem value'
    return ()

data DOMDocumentSetDocumentUriMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetDocumentUriMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetDocumentUri

-- method DOMDocument::set_selected_stylesheet_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_set_selected_stylesheet_set" webkit_dom_document_set_selected_stylesheet_set :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetSelectedStylesheetSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
dOMDocumentSetSelectedStylesheetSet self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    webkit_dom_document_set_selected_stylesheet_set self' value'
    touchManagedPtr self
    freeMem value'
    return ()

data DOMDocumentSetSelectedStylesheetSetMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetSelectedStylesheetSetMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetSelectedStylesheetSet

-- method DOMDocument::set_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_set_title" webkit_dom_document_set_title :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
dOMDocumentSetTitle self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    webkit_dom_document_set_title self' value'
    touchManagedPtr self
    freeMem value'
    return ()

data DOMDocumentSetTitleMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetTitleMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetTitle

-- method DOMDocument::set_xml_standalone
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_set_xml_standalone" webkit_dom_document_set_xml_standalone :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CInt ->                                 -- value : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetXmlStandalone ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentSetXmlStandalone self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    onException (do
        propagateGError $ webkit_dom_document_set_xml_standalone self' value'
        touchManagedPtr self
        return ()
     ) (do
        return ()
     )

data DOMDocumentSetXmlStandaloneMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetXmlStandaloneMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetXmlStandalone

-- method DOMDocument::set_xml_version
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_document_set_xml_version" webkit_dom_document_set_xml_version :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    CString ->                              -- value : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentSetXmlVersion ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMDocumentSetXmlVersion self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    onException (do
        propagateGError $ webkit_dom_document_set_xml_version self' value'
        touchManagedPtr self
        freeMem value'
        return ()
     ) (do
        freeMem value'
     )

data DOMDocumentSetXmlVersionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentSetXmlVersionMethodInfo a signature where
    overloadedMethod _ = dOMDocumentSetXmlVersion

-- method DOMDocument::webkit_cancel_full_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_webkit_cancel_full_screen" webkit_dom_document_webkit_cancel_full_screen :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentWebkitCancelFullScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m ()
dOMDocumentWebkitCancelFullScreen self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_document_webkit_cancel_full_screen self'
    touchManagedPtr self
    return ()

data DOMDocumentWebkitCancelFullScreenMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentWebkitCancelFullScreenMethodInfo a signature where
    overloadedMethod _ = dOMDocumentWebkitCancelFullScreen

-- method DOMDocument::webkit_exit_fullscreen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_webkit_exit_fullscreen" webkit_dom_document_webkit_exit_fullscreen :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentWebkitExitFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m ()
dOMDocumentWebkitExitFullscreen self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_document_webkit_exit_fullscreen self'
    touchManagedPtr self
    return ()

data DOMDocumentWebkitExitFullscreenMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentWebkitExitFullscreenMethodInfo a signature where
    overloadedMethod _ = dOMDocumentWebkitExitFullscreen

-- method DOMDocument::webkit_exit_pointer_lock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_webkit_exit_pointer_lock" webkit_dom_document_webkit_exit_pointer_lock :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMDocumentWebkitExitPointerLock ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m ()
dOMDocumentWebkitExitPointerLock self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_document_webkit_exit_pointer_lock self'
    touchManagedPtr self
    return ()

data DOMDocumentWebkitExitPointerLockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentWebkitExitPointerLockMethodInfo a signature where
    overloadedMethod _ = dOMDocumentWebkitExitPointerLock

-- method DOMDocument::webkit_get_named_flows
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMDocument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMDOMNamedFlowCollection"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_document_webkit_get_named_flows" webkit_dom_document_webkit_get_named_flows :: 
    Ptr DOMDocument ->                      -- self : TInterface (Name {namespace = "WebKit", name = "DOMDocument"})
    IO (Ptr WebKit.DOMDOMNamedFlowCollection.DOMDOMNamedFlowCollection)

{- |
/No description available in the introspection data./
-}
dOMDocumentWebkitGetNamedFlows ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMDocument a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMDocument.DOMDocument' -}
    -> m WebKit.DOMDOMNamedFlowCollection.DOMDOMNamedFlowCollection
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMDOMNamedFlowCollection.DOMDOMNamedFlowCollection' -}
dOMDocumentWebkitGetNamedFlows self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_document_webkit_get_named_flows self'
    checkUnexpectedReturnNULL "dOMDocumentWebkitGetNamedFlows" result
    result' <- (wrapObject WebKit.DOMDOMNamedFlowCollection.DOMDOMNamedFlowCollection) result
    touchManagedPtr self
    return result'

data DOMDocumentWebkitGetNamedFlowsMethodInfo
instance (signature ~ (m WebKit.DOMDOMNamedFlowCollection.DOMDOMNamedFlowCollection), MonadIO m, IsDOMDocument a) => O.MethodInfo DOMDocumentWebkitGetNamedFlowsMethodInfo a signature where
    overloadedMethod _ = dOMDocumentWebkitGetNamedFlows