DOMTreeWalker.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.WebKit2WebExtension.Objects.DOMTreeWalker
    ( 

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


 -- * Methods
-- ** firstChild #method:firstChild#

#if ENABLE_OVERLOADING
    DOMTreeWalkerFirstChildMethodInfo       ,
#endif
    dOMTreeWalkerFirstChild                 ,


-- ** getCurrentNode #method:getCurrentNode#

#if ENABLE_OVERLOADING
    DOMTreeWalkerGetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerGetCurrentNode             ,


-- ** getExpandEntityReferences #method:getExpandEntityReferences#

#if ENABLE_OVERLOADING
    DOMTreeWalkerGetExpandEntityReferencesMethodInfo,
#endif
    dOMTreeWalkerGetExpandEntityReferences  ,


-- ** getFilter #method:getFilter#

#if ENABLE_OVERLOADING
    DOMTreeWalkerGetFilterMethodInfo        ,
#endif
    dOMTreeWalkerGetFilter                  ,


-- ** getRoot #method:getRoot#

#if ENABLE_OVERLOADING
    DOMTreeWalkerGetRootMethodInfo          ,
#endif
    dOMTreeWalkerGetRoot                    ,


-- ** getWhatToShow #method:getWhatToShow#

#if ENABLE_OVERLOADING
    DOMTreeWalkerGetWhatToShowMethodInfo    ,
#endif
    dOMTreeWalkerGetWhatToShow              ,


-- ** lastChild #method:lastChild#

#if ENABLE_OVERLOADING
    DOMTreeWalkerLastChildMethodInfo        ,
#endif
    dOMTreeWalkerLastChild                  ,


-- ** nextNode #method:nextNode#

#if ENABLE_OVERLOADING
    DOMTreeWalkerNextNodeMethodInfo         ,
#endif
    dOMTreeWalkerNextNode                   ,


-- ** nextSibling #method:nextSibling#

#if ENABLE_OVERLOADING
    DOMTreeWalkerNextSiblingMethodInfo      ,
#endif
    dOMTreeWalkerNextSibling                ,


-- ** parentNode #method:parentNode#

#if ENABLE_OVERLOADING
    DOMTreeWalkerParentNodeMethodInfo       ,
#endif
    dOMTreeWalkerParentNode                 ,


-- ** previousNode #method:previousNode#

#if ENABLE_OVERLOADING
    DOMTreeWalkerPreviousNodeMethodInfo     ,
#endif
    dOMTreeWalkerPreviousNode               ,


-- ** previousSibling #method:previousSibling#

#if ENABLE_OVERLOADING
    DOMTreeWalkerPreviousSiblingMethodInfo  ,
#endif
    dOMTreeWalkerPreviousSibling            ,


-- ** setCurrentNode #method:setCurrentNode#

#if ENABLE_OVERLOADING
    DOMTreeWalkerSetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerSetCurrentNode             ,




 -- * Properties
-- ** currentNode #attr:currentNode#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMTreeWalkerCurrentNodePropertyInfo    ,
#endif
#if ENABLE_OVERLOADING
    dOMTreeWalkerCurrentNode                ,
#endif
    getDOMTreeWalkerCurrentNode             ,


-- ** filter #attr:filter#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMTreeWalkerFilterPropertyInfo         ,
#endif
#if ENABLE_OVERLOADING
    dOMTreeWalkerFilter                     ,
#endif
    getDOMTreeWalkerFilter                  ,


-- ** root #attr:root#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMTreeWalkerRootPropertyInfo           ,
#endif
#if ENABLE_OVERLOADING
    dOMTreeWalkerRoot                       ,
#endif
    getDOMTreeWalkerRoot                    ,


-- ** whatToShow #attr:whatToShow#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMTreeWalkerWhatToShowPropertyInfo     ,
#endif
#if ENABLE_OVERLOADING
    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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
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 GHC.OverloadedLabels as OL

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

-- | Memory-managed wrapper type.
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
    

-- | Type class for types which can be safely cast to `DOMTreeWalker`, for instance with `toDOMTreeWalker`.
class (GObject o, O.IsDescendantOf DOMTreeWalker o) => IsDOMTreeWalker o
instance (GObject o, O.IsDescendantOf DOMTreeWalker o) => IsDOMTreeWalker o

instance O.HasParentTypes DOMTreeWalker
type instance O.ParentTypes DOMTreeWalker = '[WebKit2WebExtension.DOMObject.DOMObject, GObject.Object.Object]

-- | Cast to `DOMTreeWalker`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDOMTreeWalker :: (MonadIO m, IsDOMTreeWalker o) => o -> m DOMTreeWalker
toDOMTreeWalker = liftIO . unsafeCastTo DOMTreeWalker

-- | A convenience alias for `Nothing` :: `Maybe` `DOMTreeWalker`.
noDOMTreeWalker :: Maybe DOMTreeWalker
noDOMTreeWalker = Nothing

#if ENABLE_OVERLOADING
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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) => OL.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

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

{- |
Get the value of the “@current-node@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' dOMTreeWalker #currentNode
@
-}
getDOMTreeWalkerCurrentNode :: (MonadIO m, IsDOMTreeWalker o) => o -> m WebKit2WebExtension.DOMNode.DOMNode
getDOMTreeWalkerCurrentNode obj = liftIO $ checkUnexpectedNothing "getDOMTreeWalkerCurrentNode" $ B.Properties.getObjectPropertyObject obj "current-node" WebKit2WebExtension.DOMNode.DOMNode

#if ENABLE_OVERLOADING
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)

{- |
Get the value of the “@filter@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' dOMTreeWalker #filter
@
-}
getDOMTreeWalkerFilter :: (MonadIO m, IsDOMTreeWalker o) => o -> m (Maybe WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)
getDOMTreeWalkerFilter obj = liftIO $ B.Properties.getObjectPropertyObject obj "filter" WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter

#if ENABLE_OVERLOADING
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)

{- |
Get the value of the “@root@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' dOMTreeWalker #root
@
-}
getDOMTreeWalkerRoot :: (MonadIO m, IsDOMTreeWalker o) => o -> m WebKit2WebExtension.DOMNode.DOMNode
getDOMTreeWalkerRoot obj = liftIO $ checkUnexpectedNothing "getDOMTreeWalkerRoot" $ B.Properties.getObjectPropertyObject obj "root" WebKit2WebExtension.DOMNode.DOMNode

#if ENABLE_OVERLOADING
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)

{- |
Get the value of the “@what-to-show@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' dOMTreeWalker #whatToShow
@
-}
getDOMTreeWalkerWhatToShow :: (MonadIO m, IsDOMTreeWalker o) => o -> m CULong
getDOMTreeWalkerWhatToShow obj = liftIO $ B.Properties.getObjectPropertyULong obj "what-to-show"

#if ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
dOMTreeWalkerCurrentNode :: AttrLabelProxy "currentNode"
dOMTreeWalkerCurrentNode = AttrLabelProxy

dOMTreeWalkerFilter :: AttrLabelProxy "filter"
dOMTreeWalkerFilter = AttrLabelProxy

dOMTreeWalkerRoot :: AttrLabelProxy "root"
dOMTreeWalkerRoot = AttrLabelProxy

dOMTreeWalkerWhatToShow :: AttrLabelProxy "whatToShow"
dOMTreeWalkerWhatToShow = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerFirstChild ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerGetCurrentNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerGetFilter ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerGetRoot ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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

{-# DEPRECATED dOMTreeWalkerGetWhatToShow ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerLastChild ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerNextNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerNextSibling ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerParentNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerPreviousNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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)

{-# DEPRECATED dOMTreeWalkerPreviousSibling ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
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 ()

{-# DEPRECATED dOMTreeWalkerSetCurrentNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/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 ENABLE_OVERLOADING
data DOMTreeWalkerSetCurrentNodeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMTreeWalker a, WebKit2WebExtension.DOMNode.IsDOMNode b) => O.MethodInfo DOMTreeWalkerSetCurrentNodeMethodInfo a signature where
    overloadedMethod _ = dOMTreeWalkerSetCurrentNode

#endif