{- |
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.DOMShadowRoot
    ( 

-- * Exported types
    DOMShadowRoot(..)                       ,
    IsDOMShadowRoot                         ,
    toDOMShadowRoot                         ,
    noDOMShadowRoot                         ,


 -- * Methods
-- ** elementFromPoint #method:elementFromPoint#
    DOMShadowRootElementFromPointMethodInfo ,
    dOMShadowRootElementFromPoint           ,


-- ** getActiveElement #method:getActiveElement#
    DOMShadowRootGetActiveElementMethodInfo ,
    dOMShadowRootGetActiveElement           ,


-- ** getApplyAuthorStyles #method:getApplyAuthorStyles#
    DOMShadowRootGetApplyAuthorStylesMethodInfo,
    dOMShadowRootGetApplyAuthorStyles       ,


-- ** getElementById #method:getElementById#
    DOMShadowRootGetElementByIdMethodInfo   ,
    dOMShadowRootGetElementById             ,


-- ** getElementsByClassName #method:getElementsByClassName#
    DOMShadowRootGetElementsByClassNameMethodInfo,
    dOMShadowRootGetElementsByClassName     ,


-- ** getElementsByTagName #method:getElementsByTagName#
    DOMShadowRootGetElementsByTagNameMethodInfo,
    dOMShadowRootGetElementsByTagName       ,


-- ** getElementsByTagNameNs #method:getElementsByTagNameNs#
    DOMShadowRootGetElementsByTagNameNsMethodInfo,
    dOMShadowRootGetElementsByTagNameNs     ,


-- ** getInnerHtml #method:getInnerHtml#
    DOMShadowRootGetInnerHtmlMethodInfo     ,
    dOMShadowRootGetInnerHtml               ,


-- ** getResetStyleInheritance #method:getResetStyleInheritance#
    DOMShadowRootGetResetStyleInheritanceMethodInfo,
    dOMShadowRootGetResetStyleInheritance   ,


-- ** getSelection #method:getSelection#
    DOMShadowRootGetSelectionMethodInfo     ,
    dOMShadowRootGetSelection               ,


-- ** setApplyAuthorStyles #method:setApplyAuthorStyles#
    DOMShadowRootSetApplyAuthorStylesMethodInfo,
    dOMShadowRootSetApplyAuthorStyles       ,


-- ** setInnerHtml #method:setInnerHtml#
    DOMShadowRootSetInnerHtmlMethodInfo     ,
    dOMShadowRootSetInnerHtml               ,


-- ** setResetStyleInheritance #method:setResetStyleInheritance#
    DOMShadowRootSetResetStyleInheritanceMethodInfo,
    dOMShadowRootSetResetStyleInheritance   ,




 -- * Properties
-- ** activeElement #attr:activeElement#
    DOMShadowRootActiveElementPropertyInfo  ,
    dOMShadowRootActiveElement              ,
    getDOMShadowRootActiveElement           ,


-- ** applyAuthorStyles #attr:applyAuthorStyles#
    DOMShadowRootApplyAuthorStylesPropertyInfo,
    constructDOMShadowRootApplyAuthorStyles ,
    dOMShadowRootApplyAuthorStyles          ,
    getDOMShadowRootApplyAuthorStyles       ,
    setDOMShadowRootApplyAuthorStyles       ,


-- ** innerHtml #attr:innerHtml#
    DOMShadowRootInnerHtmlPropertyInfo      ,
    clearDOMShadowRootInnerHtml             ,
    constructDOMShadowRootInnerHtml         ,
    dOMShadowRootInnerHtml                  ,
    getDOMShadowRootInnerHtml               ,
    setDOMShadowRootInnerHtml               ,


-- ** resetStyleInheritance #attr:resetStyleInheritance#
    DOMShadowRootResetStyleInheritancePropertyInfo,
    constructDOMShadowRootResetStyleInheritance,
    dOMShadowRootResetStyleInheritance      ,
    getDOMShadowRootResetStyleInheritance   ,
    setDOMShadowRootResetStyleInheritance   ,




    ) 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.DOMDOMSelection as WebKit.DOMDOMSelection
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDocumentFragment as WebKit.DOMDocumentFragment
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMElement as WebKit.DOMElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNode as WebKit.DOMNode
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNodeList as WebKit.DOMNodeList
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMObject as WebKit.DOMObject

newtype DOMShadowRoot = DOMShadowRoot (ManagedPtr DOMShadowRoot)
foreign import ccall "webkit_dom_shadow_root_get_type"
    c_webkit_dom_shadow_root_get_type :: IO GType

instance GObject DOMShadowRoot where
    gobjectType _ = c_webkit_dom_shadow_root_get_type
    

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

toDOMShadowRoot :: IsDOMShadowRoot o => o -> IO DOMShadowRoot
toDOMShadowRoot = unsafeCastTo DOMShadowRoot

noDOMShadowRoot :: Maybe DOMShadowRoot
noDOMShadowRoot = Nothing

type family ResolveDOMShadowRootMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMShadowRootMethod "addEventListener" o = WebKit.DOMEventTarget.DOMEventTargetAddEventListenerMethodInfo
    ResolveDOMShadowRootMethod "appendChild" o = WebKit.DOMNode.DOMNodeAppendChildMethodInfo
    ResolveDOMShadowRootMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMShadowRootMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMShadowRootMethod "cloneNode" o = WebKit.DOMNode.DOMNodeCloneNodeMethodInfo
    ResolveDOMShadowRootMethod "compareDocumentPosition" o = WebKit.DOMNode.DOMNodeCompareDocumentPositionMethodInfo
    ResolveDOMShadowRootMethod "contains" o = WebKit.DOMNode.DOMNodeContainsMethodInfo
    ResolveDOMShadowRootMethod "dispatchEvent" o = WebKit.DOMNode.DOMNodeDispatchEventMethodInfo
    ResolveDOMShadowRootMethod "elementFromPoint" o = DOMShadowRootElementFromPointMethodInfo
    ResolveDOMShadowRootMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMShadowRootMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMShadowRootMethod "hasAttributes" o = WebKit.DOMNode.DOMNodeHasAttributesMethodInfo
    ResolveDOMShadowRootMethod "hasChildNodes" o = WebKit.DOMNode.DOMNodeHasChildNodesMethodInfo
    ResolveDOMShadowRootMethod "insertBefore" o = WebKit.DOMNode.DOMNodeInsertBeforeMethodInfo
    ResolveDOMShadowRootMethod "isDefaultNamespace" o = WebKit.DOMNode.DOMNodeIsDefaultNamespaceMethodInfo
    ResolveDOMShadowRootMethod "isEqualNode" o = WebKit.DOMNode.DOMNodeIsEqualNodeMethodInfo
    ResolveDOMShadowRootMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMShadowRootMethod "isSameNode" o = WebKit.DOMNode.DOMNodeIsSameNodeMethodInfo
    ResolveDOMShadowRootMethod "isSupported" o = WebKit.DOMNode.DOMNodeIsSupportedMethodInfo
    ResolveDOMShadowRootMethod "lookupNamespaceUri" o = WebKit.DOMNode.DOMNodeLookupNamespaceUriMethodInfo
    ResolveDOMShadowRootMethod "lookupPrefix" o = WebKit.DOMNode.DOMNodeLookupPrefixMethodInfo
    ResolveDOMShadowRootMethod "normalize" o = WebKit.DOMNode.DOMNodeNormalizeMethodInfo
    ResolveDOMShadowRootMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMShadowRootMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMShadowRootMethod "querySelector" o = WebKit.DOMDocumentFragment.DOMDocumentFragmentQuerySelectorMethodInfo
    ResolveDOMShadowRootMethod "querySelectorAll" o = WebKit.DOMDocumentFragment.DOMDocumentFragmentQuerySelectorAllMethodInfo
    ResolveDOMShadowRootMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMShadowRootMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMShadowRootMethod "removeChild" o = WebKit.DOMNode.DOMNodeRemoveChildMethodInfo
    ResolveDOMShadowRootMethod "removeEventListener" o = WebKit.DOMEventTarget.DOMEventTargetRemoveEventListenerMethodInfo
    ResolveDOMShadowRootMethod "replaceChild" o = WebKit.DOMNode.DOMNodeReplaceChildMethodInfo
    ResolveDOMShadowRootMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMShadowRootMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMShadowRootMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMShadowRootMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMShadowRootMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMShadowRootMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMShadowRootMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMShadowRootMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMShadowRootMethod "getActiveElement" o = DOMShadowRootGetActiveElementMethodInfo
    ResolveDOMShadowRootMethod "getApplyAuthorStyles" o = DOMShadowRootGetApplyAuthorStylesMethodInfo
    ResolveDOMShadowRootMethod "getAttributes" o = WebKit.DOMNode.DOMNodeGetAttributesMethodInfo
    ResolveDOMShadowRootMethod "getBaseUri" o = WebKit.DOMNode.DOMNodeGetBaseUriMethodInfo
    ResolveDOMShadowRootMethod "getChildNodes" o = WebKit.DOMNode.DOMNodeGetChildNodesMethodInfo
    ResolveDOMShadowRootMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMShadowRootMethod "getElementById" o = DOMShadowRootGetElementByIdMethodInfo
    ResolveDOMShadowRootMethod "getElementsByClassName" o = DOMShadowRootGetElementsByClassNameMethodInfo
    ResolveDOMShadowRootMethod "getElementsByTagName" o = DOMShadowRootGetElementsByTagNameMethodInfo
    ResolveDOMShadowRootMethod "getElementsByTagNameNs" o = DOMShadowRootGetElementsByTagNameNsMethodInfo
    ResolveDOMShadowRootMethod "getFirstChild" o = WebKit.DOMNode.DOMNodeGetFirstChildMethodInfo
    ResolveDOMShadowRootMethod "getInnerHtml" o = DOMShadowRootGetInnerHtmlMethodInfo
    ResolveDOMShadowRootMethod "getLastChild" o = WebKit.DOMNode.DOMNodeGetLastChildMethodInfo
    ResolveDOMShadowRootMethod "getLocalName" o = WebKit.DOMNode.DOMNodeGetLocalNameMethodInfo
    ResolveDOMShadowRootMethod "getNamespaceUri" o = WebKit.DOMNode.DOMNodeGetNamespaceUriMethodInfo
    ResolveDOMShadowRootMethod "getNextSibling" o = WebKit.DOMNode.DOMNodeGetNextSiblingMethodInfo
    ResolveDOMShadowRootMethod "getNodeName" o = WebKit.DOMNode.DOMNodeGetNodeNameMethodInfo
    ResolveDOMShadowRootMethod "getNodeType" o = WebKit.DOMNode.DOMNodeGetNodeTypeMethodInfo
    ResolveDOMShadowRootMethod "getNodeValue" o = WebKit.DOMNode.DOMNodeGetNodeValueMethodInfo
    ResolveDOMShadowRootMethod "getOwnerDocument" o = WebKit.DOMNode.DOMNodeGetOwnerDocumentMethodInfo
    ResolveDOMShadowRootMethod "getParentElement" o = WebKit.DOMNode.DOMNodeGetParentElementMethodInfo
    ResolveDOMShadowRootMethod "getParentNode" o = WebKit.DOMNode.DOMNodeGetParentNodeMethodInfo
    ResolveDOMShadowRootMethod "getPrefix" o = WebKit.DOMNode.DOMNodeGetPrefixMethodInfo
    ResolveDOMShadowRootMethod "getPreviousSibling" o = WebKit.DOMNode.DOMNodeGetPreviousSiblingMethodInfo
    ResolveDOMShadowRootMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMShadowRootMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMShadowRootMethod "getResetStyleInheritance" o = DOMShadowRootGetResetStyleInheritanceMethodInfo
    ResolveDOMShadowRootMethod "getSelection" o = DOMShadowRootGetSelectionMethodInfo
    ResolveDOMShadowRootMethod "getTextContent" o = WebKit.DOMNode.DOMNodeGetTextContentMethodInfo
    ResolveDOMShadowRootMethod "setApplyAuthorStyles" o = DOMShadowRootSetApplyAuthorStylesMethodInfo
    ResolveDOMShadowRootMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMShadowRootMethod "setInnerHtml" o = DOMShadowRootSetInnerHtmlMethodInfo
    ResolveDOMShadowRootMethod "setNodeValue" o = WebKit.DOMNode.DOMNodeSetNodeValueMethodInfo
    ResolveDOMShadowRootMethod "setPrefix" o = WebKit.DOMNode.DOMNodeSetPrefixMethodInfo
    ResolveDOMShadowRootMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMShadowRootMethod "setResetStyleInheritance" o = DOMShadowRootSetResetStyleInheritanceMethodInfo
    ResolveDOMShadowRootMethod "setTextContent" o = WebKit.DOMNode.DOMNodeSetTextContentMethodInfo
    ResolveDOMShadowRootMethod l o = O.MethodResolutionFailed l o

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

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

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

getDOMShadowRootActiveElement :: (MonadIO m, IsDOMShadowRoot o) => o -> m WebKit.DOMElement.DOMElement
getDOMShadowRootActiveElement obj = liftIO $ checkUnexpectedNothing "getDOMShadowRootActiveElement" $ getObjectPropertyObject obj "active-element" WebKit.DOMElement.DOMElement

data DOMShadowRootActiveElementPropertyInfo
instance AttrInfo DOMShadowRootActiveElementPropertyInfo where
    type AttrAllowedOps DOMShadowRootActiveElementPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMShadowRootActiveElementPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMShadowRootActiveElementPropertyInfo = IsDOMShadowRoot
    type AttrGetType DOMShadowRootActiveElementPropertyInfo = WebKit.DOMElement.DOMElement
    type AttrLabel DOMShadowRootActiveElementPropertyInfo = "active-element"
    type AttrOrigin DOMShadowRootActiveElementPropertyInfo = DOMShadowRoot
    attrGet _ = getDOMShadowRootActiveElement
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "apply-author-styles"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDOMShadowRootApplyAuthorStyles :: (MonadIO m, IsDOMShadowRoot o) => o -> m Bool
getDOMShadowRootApplyAuthorStyles obj = liftIO $ getObjectPropertyBool obj "apply-author-styles"

setDOMShadowRootApplyAuthorStyles :: (MonadIO m, IsDOMShadowRoot o) => o -> Bool -> m ()
setDOMShadowRootApplyAuthorStyles obj val = liftIO $ setObjectPropertyBool obj "apply-author-styles" val

constructDOMShadowRootApplyAuthorStyles :: (IsDOMShadowRoot o) => Bool -> IO (GValueConstruct o)
constructDOMShadowRootApplyAuthorStyles val = constructObjectPropertyBool "apply-author-styles" val

data DOMShadowRootApplyAuthorStylesPropertyInfo
instance AttrInfo DOMShadowRootApplyAuthorStylesPropertyInfo where
    type AttrAllowedOps DOMShadowRootApplyAuthorStylesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMShadowRootApplyAuthorStylesPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMShadowRootApplyAuthorStylesPropertyInfo = IsDOMShadowRoot
    type AttrGetType DOMShadowRootApplyAuthorStylesPropertyInfo = Bool
    type AttrLabel DOMShadowRootApplyAuthorStylesPropertyInfo = "apply-author-styles"
    type AttrOrigin DOMShadowRootApplyAuthorStylesPropertyInfo = DOMShadowRoot
    attrGet _ = getDOMShadowRootApplyAuthorStyles
    attrSet _ = setDOMShadowRootApplyAuthorStyles
    attrConstruct _ = constructDOMShadowRootApplyAuthorStyles
    attrClear _ = undefined

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

getDOMShadowRootInnerHtml :: (MonadIO m, IsDOMShadowRoot o) => o -> m (Maybe T.Text)
getDOMShadowRootInnerHtml obj = liftIO $ getObjectPropertyString obj "inner-html"

setDOMShadowRootInnerHtml :: (MonadIO m, IsDOMShadowRoot o) => o -> T.Text -> m ()
setDOMShadowRootInnerHtml obj val = liftIO $ setObjectPropertyString obj "inner-html" (Just val)

constructDOMShadowRootInnerHtml :: (IsDOMShadowRoot o) => T.Text -> IO (GValueConstruct o)
constructDOMShadowRootInnerHtml val = constructObjectPropertyString "inner-html" (Just val)

clearDOMShadowRootInnerHtml :: (MonadIO m, IsDOMShadowRoot o) => o -> m ()
clearDOMShadowRootInnerHtml obj = liftIO $ setObjectPropertyString obj "inner-html" (Nothing :: Maybe T.Text)

data DOMShadowRootInnerHtmlPropertyInfo
instance AttrInfo DOMShadowRootInnerHtmlPropertyInfo where
    type AttrAllowedOps DOMShadowRootInnerHtmlPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMShadowRootInnerHtmlPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMShadowRootInnerHtmlPropertyInfo = IsDOMShadowRoot
    type AttrGetType DOMShadowRootInnerHtmlPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMShadowRootInnerHtmlPropertyInfo = "inner-html"
    type AttrOrigin DOMShadowRootInnerHtmlPropertyInfo = DOMShadowRoot
    attrGet _ = getDOMShadowRootInnerHtml
    attrSet _ = setDOMShadowRootInnerHtml
    attrConstruct _ = constructDOMShadowRootInnerHtml
    attrClear _ = clearDOMShadowRootInnerHtml

-- VVV Prop "reset-style-inheritance"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDOMShadowRootResetStyleInheritance :: (MonadIO m, IsDOMShadowRoot o) => o -> m Bool
getDOMShadowRootResetStyleInheritance obj = liftIO $ getObjectPropertyBool obj "reset-style-inheritance"

setDOMShadowRootResetStyleInheritance :: (MonadIO m, IsDOMShadowRoot o) => o -> Bool -> m ()
setDOMShadowRootResetStyleInheritance obj val = liftIO $ setObjectPropertyBool obj "reset-style-inheritance" val

constructDOMShadowRootResetStyleInheritance :: (IsDOMShadowRoot o) => Bool -> IO (GValueConstruct o)
constructDOMShadowRootResetStyleInheritance val = constructObjectPropertyBool "reset-style-inheritance" val

data DOMShadowRootResetStyleInheritancePropertyInfo
instance AttrInfo DOMShadowRootResetStyleInheritancePropertyInfo where
    type AttrAllowedOps DOMShadowRootResetStyleInheritancePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMShadowRootResetStyleInheritancePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMShadowRootResetStyleInheritancePropertyInfo = IsDOMShadowRoot
    type AttrGetType DOMShadowRootResetStyleInheritancePropertyInfo = Bool
    type AttrLabel DOMShadowRootResetStyleInheritancePropertyInfo = "reset-style-inheritance"
    type AttrOrigin DOMShadowRootResetStyleInheritancePropertyInfo = DOMShadowRoot
    attrGet _ = getDOMShadowRootResetStyleInheritance
    attrSet _ = setDOMShadowRootResetStyleInheritance
    attrConstruct _ = constructDOMShadowRootResetStyleInheritance
    attrClear _ = undefined

instance O.HasAttributeList DOMShadowRoot
type instance O.AttributeList DOMShadowRoot = DOMShadowRootAttributeList
type DOMShadowRootAttributeList = ('[ '("activeElement", DOMShadowRootActiveElementPropertyInfo), '("applyAuthorStyles", DOMShadowRootApplyAuthorStylesPropertyInfo), '("baseUri", WebKit.DOMNode.DOMNodeBaseUriPropertyInfo), '("childNodes", WebKit.DOMNode.DOMNodeChildNodesPropertyInfo), '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("firstChild", WebKit.DOMNode.DOMNodeFirstChildPropertyInfo), '("innerHtml", DOMShadowRootInnerHtmlPropertyInfo), '("lastChild", WebKit.DOMNode.DOMNodeLastChildPropertyInfo), '("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), '("prefix", WebKit.DOMNode.DOMNodePrefixPropertyInfo), '("previousSibling", WebKit.DOMNode.DOMNodePreviousSiblingPropertyInfo), '("resetStyleInheritance", DOMShadowRootResetStyleInheritancePropertyInfo), '("textContent", WebKit.DOMNode.DOMNodeTextContentPropertyInfo)] :: [(Symbol, *)])

dOMShadowRootActiveElement :: AttrLabelProxy "activeElement"
dOMShadowRootActiveElement = AttrLabelProxy

dOMShadowRootApplyAuthorStyles :: AttrLabelProxy "applyAuthorStyles"
dOMShadowRootApplyAuthorStyles = AttrLabelProxy

dOMShadowRootInnerHtml :: AttrLabelProxy "innerHtml"
dOMShadowRootInnerHtml = AttrLabelProxy

dOMShadowRootResetStyleInheritance :: AttrLabelProxy "resetStyleInheritance"
dOMShadowRootResetStyleInheritance = AttrLabelProxy

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

-- method DOMShadowRoot::element_from_point
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_element_from_point" webkit_dom_shadow_root_element_from_point :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    CLong ->                                -- x : TBasicType TLong
    CLong ->                                -- y : TBasicType TLong
    IO (Ptr WebKit.DOMElement.DOMElement)

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

data DOMShadowRootElementFromPointMethodInfo
instance (signature ~ (CLong -> CLong -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootElementFromPointMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootElementFromPoint

-- method DOMShadowRoot::get_active_element
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_active_element" webkit_dom_shadow_root_get_active_element :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    IO (Ptr WebKit.DOMElement.DOMElement)

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

data DOMShadowRootGetActiveElementMethodInfo
instance (signature ~ (m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetActiveElementMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetActiveElement

-- method DOMShadowRoot::get_apply_author_styles
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_apply_author_styles" webkit_dom_shadow_root_get_apply_author_styles :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    IO CInt

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

data DOMShadowRootGetApplyAuthorStylesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetApplyAuthorStylesMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetApplyAuthorStyles

-- method DOMShadowRoot::get_element_by_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_element_by_id" webkit_dom_shadow_root_get_element_by_id :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    CString ->                              -- elementId : TBasicType TUTF8
    IO (Ptr WebKit.DOMElement.DOMElement)

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

data DOMShadowRootGetElementByIdMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMElement.DOMElement), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetElementByIdMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetElementById

-- method DOMShadowRoot::get_elements_by_class_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "className", 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_shadow_root_get_elements_by_class_name" webkit_dom_shadow_root_get_elements_by_class_name :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    CString ->                              -- className : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

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

data DOMShadowRootGetElementsByClassNameMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetElementsByClassNameMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetElementsByClassName

-- method DOMShadowRoot::get_elements_by_tag_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_elements_by_tag_name" webkit_dom_shadow_root_get_elements_by_tag_name :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    CString ->                              -- tagName : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

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

data DOMShadowRootGetElementsByTagNameMethodInfo
instance (signature ~ (T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetElementsByTagNameMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetElementsByTagName

-- method DOMShadowRoot::get_elements_by_tag_name_ns
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_elements_by_tag_name_ns" webkit_dom_shadow_root_get_elements_by_tag_name_ns :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    CString ->                              -- namespaceURI : TBasicType TUTF8
    CString ->                              -- localName : TBasicType TUTF8
    IO (Ptr WebKit.DOMNodeList.DOMNodeList)

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

data DOMShadowRootGetElementsByTagNameNsMethodInfo
instance (signature ~ (T.Text -> T.Text -> m WebKit.DOMNodeList.DOMNodeList), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetElementsByTagNameNsMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetElementsByTagNameNs

-- method DOMShadowRoot::get_inner_html
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_inner_html" webkit_dom_shadow_root_get_inner_html :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    IO CString

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

data DOMShadowRootGetInnerHtmlMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetInnerHtmlMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetInnerHtml

-- method DOMShadowRoot::get_reset_style_inheritance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_get_reset_style_inheritance" webkit_dom_shadow_root_get_reset_style_inheritance :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    IO CInt

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

data DOMShadowRootGetResetStyleInheritanceMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetResetStyleInheritanceMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetResetStyleInheritance

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

foreign import ccall "webkit_dom_shadow_root_get_selection" webkit_dom_shadow_root_get_selection :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    IO (Ptr WebKit.DOMDOMSelection.DOMDOMSelection)

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

data DOMShadowRootGetSelectionMethodInfo
instance (signature ~ (m WebKit.DOMDOMSelection.DOMDOMSelection), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootGetSelectionMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootGetSelection

-- method DOMShadowRoot::set_apply_author_styles
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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 : False
-- Skip return : False

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

{- |
/No description available in the introspection data./
-}
dOMShadowRootSetApplyAuthorStyles ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMShadowRoot a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMShadowRoot.DOMShadowRoot' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMShadowRootSetApplyAuthorStyles self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_shadow_root_set_apply_author_styles self' value'
    touchManagedPtr self
    return ()

data DOMShadowRootSetApplyAuthorStylesMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootSetApplyAuthorStylesMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootSetApplyAuthorStyles

-- method DOMShadowRoot::set_inner_html
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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_shadow_root_set_inner_html" webkit_dom_shadow_root_set_inner_html :: 
    Ptr DOMShadowRoot ->                    -- self : TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"})
    CString ->                              -- value : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO ()

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

data DOMShadowRootSetInnerHtmlMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootSetInnerHtmlMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootSetInnerHtml

-- method DOMShadowRoot::set_reset_style_inheritance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMShadowRoot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMShadowRoot", 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 : False
-- Skip return : False

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

{- |
/No description available in the introspection data./
-}
dOMShadowRootSetResetStyleInheritance ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMShadowRoot a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMShadowRoot.DOMShadowRoot' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMShadowRootSetResetStyleInheritance self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_shadow_root_set_reset_style_inheritance self' value'
    touchManagedPtr self
    return ()

data DOMShadowRootSetResetStyleInheritanceMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMShadowRoot a) => O.MethodInfo DOMShadowRootSetResetStyleInheritanceMethodInfo a signature where
    overloadedMethod _ = dOMShadowRootSetResetStyleInheritance