{- |
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.WebKit2WebExtension.Objects.DOMTreeWalker
    ( 

-- * Exported types
    DOMTreeWalker(..)                       ,
    IsDOMTreeWalker                         ,
    toDOMTreeWalker                         ,
    noDOMTreeWalker                         ,


 -- * Methods
-- ** firstChild #method:firstChild#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerFirstChildMethodInfo       ,
#endif
    dOMTreeWalkerFirstChild                 ,


-- ** getCurrentNode #method:getCurrentNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerGetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerGetCurrentNode             ,


-- ** getExpandEntityReferences #method:getExpandEntityReferences#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerGetExpandEntityReferencesMethodInfo,
#endif
    dOMTreeWalkerGetExpandEntityReferences  ,


-- ** getFilter #method:getFilter#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerGetFilterMethodInfo        ,
#endif
    dOMTreeWalkerGetFilter                  ,


-- ** getRoot #method:getRoot#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerGetRootMethodInfo          ,
#endif
    dOMTreeWalkerGetRoot                    ,


-- ** getWhatToShow #method:getWhatToShow#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerGetWhatToShowMethodInfo    ,
#endif
    dOMTreeWalkerGetWhatToShow              ,


-- ** lastChild #method:lastChild#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerLastChildMethodInfo        ,
#endif
    dOMTreeWalkerLastChild                  ,


-- ** nextNode #method:nextNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerNextNodeMethodInfo         ,
#endif
    dOMTreeWalkerNextNode                   ,


-- ** nextSibling #method:nextSibling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerNextSiblingMethodInfo      ,
#endif
    dOMTreeWalkerNextSibling                ,


-- ** parentNode #method:parentNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerParentNodeMethodInfo       ,
#endif
    dOMTreeWalkerParentNode                 ,


-- ** previousNode #method:previousNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerPreviousNodeMethodInfo     ,
#endif
    dOMTreeWalkerPreviousNode               ,


-- ** previousSibling #method:previousSibling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerPreviousSiblingMethodInfo  ,
#endif
    dOMTreeWalkerPreviousSibling            ,


-- ** setCurrentNode #method:setCurrentNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerSetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerSetCurrentNode             ,




 -- * Properties
-- ** currentNode #attr:currentNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerCurrentNodePropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTreeWalkerCurrentNode                ,
#endif
    getDOMTreeWalkerCurrentNode             ,


-- ** filter #attr:filter#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerFilterPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTreeWalkerFilter                     ,
#endif
    getDOMTreeWalkerFilter                  ,


-- ** root #attr:root#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerRootPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTreeWalkerRoot                       ,
#endif
    getDOMTreeWalkerRoot                    ,


-- ** whatToShow #attr:whatToShow#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTreeWalkerWhatToShowPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTreeWalkerWhatToShow                 ,
#endif
    getDOMTreeWalkerWhatToShow              ,




    ) 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.WebKit2WebExtension.Interfaces.DOMNodeFilter as WebKit2WebExtension.DOMNodeFilter
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMNode as WebKit2WebExtension.DOMNode
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMObject as WebKit2WebExtension.DOMObject

newtype DOMTreeWalker = DOMTreeWalker (ManagedPtr DOMTreeWalker)
foreign import ccall "webkit_dom_tree_walker_get_type"
    c_webkit_dom_tree_walker_get_type :: IO GType

instance GObject DOMTreeWalker where
    gobjectType _ = c_webkit_dom_tree_walker_get_type
    

class GObject o => IsDOMTreeWalker o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DOMTreeWalker a) =>
    IsDOMTreeWalker a
#endif
instance IsDOMTreeWalker DOMTreeWalker
instance WebKit2WebExtension.DOMObject.IsDOMObject DOMTreeWalker
instance GObject.Object.IsObject DOMTreeWalker

toDOMTreeWalker :: (MonadIO m, IsDOMTreeWalker o) => o -> m DOMTreeWalker
toDOMTreeWalker = liftIO . unsafeCastTo DOMTreeWalker

noDOMTreeWalker :: Maybe DOMTreeWalker
noDOMTreeWalker = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDOMTreeWalkerMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMTreeWalkerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMTreeWalkerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMTreeWalkerMethod "firstChild" o = DOMTreeWalkerFirstChildMethodInfo
    ResolveDOMTreeWalkerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMTreeWalkerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMTreeWalkerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMTreeWalkerMethod "lastChild" o = DOMTreeWalkerLastChildMethodInfo
    ResolveDOMTreeWalkerMethod "nextNode" o = DOMTreeWalkerNextNodeMethodInfo
    ResolveDOMTreeWalkerMethod "nextSibling" o = DOMTreeWalkerNextSiblingMethodInfo
    ResolveDOMTreeWalkerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMTreeWalkerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMTreeWalkerMethod "parentNode" o = DOMTreeWalkerParentNodeMethodInfo
    ResolveDOMTreeWalkerMethod "previousNode" o = DOMTreeWalkerPreviousNodeMethodInfo
    ResolveDOMTreeWalkerMethod "previousSibling" o = DOMTreeWalkerPreviousSiblingMethodInfo
    ResolveDOMTreeWalkerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMTreeWalkerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMTreeWalkerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMTreeWalkerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMTreeWalkerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMTreeWalkerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMTreeWalkerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMTreeWalkerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMTreeWalkerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMTreeWalkerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMTreeWalkerMethod "getCurrentNode" o = DOMTreeWalkerGetCurrentNodeMethodInfo
    ResolveDOMTreeWalkerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMTreeWalkerMethod "getExpandEntityReferences" o = DOMTreeWalkerGetExpandEntityReferencesMethodInfo
    ResolveDOMTreeWalkerMethod "getFilter" o = DOMTreeWalkerGetFilterMethodInfo
    ResolveDOMTreeWalkerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMTreeWalkerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMTreeWalkerMethod "getRoot" o = DOMTreeWalkerGetRootMethodInfo
    ResolveDOMTreeWalkerMethod "getWhatToShow" o = DOMTreeWalkerGetWhatToShowMethodInfo
    ResolveDOMTreeWalkerMethod "setCurrentNode" o = DOMTreeWalkerSetCurrentNodeMethodInfo
    ResolveDOMTreeWalkerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMTreeWalkerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMTreeWalkerMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

getDOMTreeWalkerCurrentNode :: (MonadIO m, IsDOMTreeWalker o) => o -> m WebKit2WebExtension.DOMNode.DOMNode
getDOMTreeWalkerCurrentNode obj = liftIO $ checkUnexpectedNothing "getDOMTreeWalkerCurrentNode" $ getObjectPropertyObject obj "current-node" WebKit2WebExtension.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerCurrentNodePropertyInfo
instance AttrInfo DOMTreeWalkerCurrentNodePropertyInfo where
    type AttrAllowedOps DOMTreeWalkerCurrentNodePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = IsDOMTreeWalker
    type AttrGetType DOMTreeWalkerCurrentNodePropertyInfo = WebKit2WebExtension.DOMNode.DOMNode
    type AttrLabel DOMTreeWalkerCurrentNodePropertyInfo = "current-node"
    type AttrOrigin DOMTreeWalkerCurrentNodePropertyInfo = DOMTreeWalker
    attrGet _ = getDOMTreeWalkerCurrentNode
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "filter"
   -- Type: TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMNodeFilter"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTreeWalkerFilter :: (MonadIO m, IsDOMTreeWalker o) => o -> m (Maybe WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)
getDOMTreeWalkerFilter obj = liftIO $ getObjectPropertyObject obj "filter" WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerFilterPropertyInfo
instance AttrInfo DOMTreeWalkerFilterPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerFilterPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTreeWalkerFilterPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTreeWalkerFilterPropertyInfo = IsDOMTreeWalker
    type AttrGetType DOMTreeWalkerFilterPropertyInfo = (Maybe WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)
    type AttrLabel DOMTreeWalkerFilterPropertyInfo = "filter"
    type AttrOrigin DOMTreeWalkerFilterPropertyInfo = DOMTreeWalker
    attrGet _ = getDOMTreeWalkerFilter
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

getDOMTreeWalkerRoot :: (MonadIO m, IsDOMTreeWalker o) => o -> m WebKit2WebExtension.DOMNode.DOMNode
getDOMTreeWalkerRoot obj = liftIO $ checkUnexpectedNothing "getDOMTreeWalkerRoot" $ getObjectPropertyObject obj "root" WebKit2WebExtension.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerRootPropertyInfo
instance AttrInfo DOMTreeWalkerRootPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerRootPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTreeWalkerRootPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTreeWalkerRootPropertyInfo = IsDOMTreeWalker
    type AttrGetType DOMTreeWalkerRootPropertyInfo = WebKit2WebExtension.DOMNode.DOMNode
    type AttrLabel DOMTreeWalkerRootPropertyInfo = "root"
    type AttrOrigin DOMTreeWalkerRootPropertyInfo = DOMTreeWalker
    attrGet _ = getDOMTreeWalkerRoot
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "what-to-show"
   -- Type: TBasicType TULong
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMTreeWalkerWhatToShow :: (MonadIO m, IsDOMTreeWalker o) => o -> m CULong
getDOMTreeWalkerWhatToShow obj = liftIO $ getObjectPropertyULong obj "what-to-show"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerWhatToShowPropertyInfo
instance AttrInfo DOMTreeWalkerWhatToShowPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerWhatToShowPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = IsDOMTreeWalker
    type AttrGetType DOMTreeWalkerWhatToShowPropertyInfo = CULong
    type AttrLabel DOMTreeWalkerWhatToShowPropertyInfo = "what-to-show"
    type AttrOrigin DOMTreeWalkerWhatToShowPropertyInfo = DOMTreeWalker
    attrGet _ = getDOMTreeWalkerWhatToShow
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList DOMTreeWalker
type instance O.AttributeList DOMTreeWalker = DOMTreeWalkerAttributeList
type DOMTreeWalkerAttributeList = ('[ '("coreObject", WebKit2WebExtension.DOMObject.DOMObjectCoreObjectPropertyInfo), '("currentNode", DOMTreeWalkerCurrentNodePropertyInfo), '("filter", DOMTreeWalkerFilterPropertyInfo), '("root", DOMTreeWalkerRootPropertyInfo), '("whatToShow", DOMTreeWalkerWhatToShowPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
dOMTreeWalkerCurrentNode :: AttrLabelProxy "currentNode"
dOMTreeWalkerCurrentNode = AttrLabelProxy

dOMTreeWalkerFilter :: AttrLabelProxy "filter"
dOMTreeWalkerFilter = AttrLabelProxy

dOMTreeWalkerRoot :: AttrLabelProxy "root"
dOMTreeWalkerRoot = AttrLabelProxy

dOMTreeWalkerWhatToShow :: AttrLabelProxy "whatToShow"
dOMTreeWalkerWhatToShow = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList DOMTreeWalker = DOMTreeWalkerSignalList
type DOMTreeWalkerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "webkit_dom_tree_walker_first_child" webkit_dom_tree_walker_first_child :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerFirstChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerFirstChild self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_first_child self'
    checkUnexpectedReturnNULL "dOMTreeWalkerFirstChild" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerFirstChildMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerFirstChildMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerFirstChild

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_current_node" webkit_dom_tree_walker_get_current_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerGetCurrentNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerGetCurrentNode self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_get_current_node self'
    checkUnexpectedReturnNULL "dOMTreeWalkerGetCurrentNode" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerGetCurrentNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetCurrentNodeMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerGetCurrentNode

#endif

-- method DOMTreeWalker::get_expand_entity_references
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTreeWalker", 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_tree_walker_get_expand_entity_references" webkit_dom_tree_walker_get_expand_entity_references :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO CInt

{-# DEPRECATED dOMTreeWalkerGetExpandEntityReferences ["(Since version 2.12)"] #-}
{- |
This function has been removed from the DOM spec and it just returns 'False'.
-}
dOMTreeWalkerGetExpandEntityReferences ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMTreeWalkerGetExpandEntityReferences self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_get_expand_entity_references self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerGetExpandEntityReferencesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetExpandEntityReferencesMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerGetExpandEntityReferences

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_filter" webkit_dom_tree_walker_get_filter :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerGetFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Interfaces.DOMNodeFilter.DOMNodeFilter' -}
dOMTreeWalkerGetFilter self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_get_filter self'
    checkUnexpectedReturnNULL "dOMTreeWalkerGetFilter" result
    result' <- (wrapObject WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerGetFilterMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetFilterMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerGetFilter

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_root" webkit_dom_tree_walker_get_root :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerGetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerGetRoot self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_get_root self'
    checkUnexpectedReturnNULL "dOMTreeWalkerGetRoot" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerGetRootMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetRootMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerGetRoot

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_what_to_show" webkit_dom_tree_walker_get_what_to_show :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO CULong

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerGetWhatToShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m CULong
    {- ^ __Returns:__ A @/gulong/@ -}
dOMTreeWalkerGetWhatToShow self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_get_what_to_show self'
    touchManagedPtr self
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerGetWhatToShowMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetWhatToShowMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerGetWhatToShow

#endif

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

foreign import ccall "webkit_dom_tree_walker_last_child" webkit_dom_tree_walker_last_child :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerLastChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerLastChild self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_last_child self'
    checkUnexpectedReturnNULL "dOMTreeWalkerLastChild" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerLastChildMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerLastChildMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerLastChild

#endif

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

foreign import ccall "webkit_dom_tree_walker_next_node" webkit_dom_tree_walker_next_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerNextNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerNextNode self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_next_node self'
    checkUnexpectedReturnNULL "dOMTreeWalkerNextNode" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerNextNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerNextNodeMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerNextNode

#endif

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

foreign import ccall "webkit_dom_tree_walker_next_sibling" webkit_dom_tree_walker_next_sibling :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerNextSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerNextSibling self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_next_sibling self'
    checkUnexpectedReturnNULL "dOMTreeWalkerNextSibling" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerNextSiblingMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerNextSiblingMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerNextSibling

#endif

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

foreign import ccall "webkit_dom_tree_walker_parent_node" webkit_dom_tree_walker_parent_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerParentNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerParentNode self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_parent_node self'
    checkUnexpectedReturnNULL "dOMTreeWalkerParentNode" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerParentNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerParentNodeMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerParentNode

#endif

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

foreign import ccall "webkit_dom_tree_walker_previous_node" webkit_dom_tree_walker_previous_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerPreviousNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerPreviousNode self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_previous_node self'
    checkUnexpectedReturnNULL "dOMTreeWalkerPreviousNode" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerPreviousNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerPreviousNodeMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerPreviousNode

#endif

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

foreign import ccall "webkit_dom_tree_walker_previous_sibling" webkit_dom_tree_walker_previous_sibling :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerPreviousSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
dOMTreeWalkerPreviousSibling self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_tree_walker_previous_sibling self'
    checkUnexpectedReturnNULL "dOMTreeWalkerPreviousSibling" result
    result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerPreviousSiblingMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerPreviousSiblingMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerPreviousSibling

#endif

-- method DOMTreeWalker::set_current_node
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTreeWalker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "WebKit2WebExtension", 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 : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_tree_walker_set_current_node" webkit_dom_tree_walker_set_current_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    Ptr WebKit2WebExtension.DOMNode.DOMNode -> -- value : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMNode"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMTreeWalkerSetCurrentNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a, WebKit2WebExtension.DOMNode.IsDOMNode b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker' -}
    -> b
    {- ^ /@value@/: A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMTreeWalkerSetCurrentNode self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- unsafeManagedPtrCastPtr value
    onException (do
        propagateGError $ webkit_dom_tree_walker_set_current_node self' value'
        touchManagedPtr self
        touchManagedPtr value
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTreeWalkerSetCurrentNodeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMTreeWalker a, WebKit2WebExtension.DOMNode.IsDOMNode b) => O.MethodInfo DOMTreeWalkerSetCurrentNodeMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerSetCurrentNode

#endif