{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.WebKit2WebExtension.Objects.DOMTreeWalker
    ( 

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


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [firstChild]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:firstChild"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [lastChild]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:lastChild"), [nextNode]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:nextNode"), [nextSibling]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:nextSibling"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [parentNode]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:parentNode"), [previousNode]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:previousNode"), [previousSibling]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:previousSibling"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getCurrentNode]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:getCurrentNode"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getExpandEntityReferences]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:getExpandEntityReferences"), [getFilter]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:getFilter"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRoot]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:getRoot"), [getWhatToShow]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:getWhatToShow").
-- 
-- ==== Setters
-- [setCurrentNode]("GI.WebKit2WebExtension.Objects.DOMTreeWalker#g:method:setCurrentNode"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveDOMTreeWalkerMethod              ,
#endif

-- ** firstChild #method:firstChild#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerFirstChildMethodInfo       ,
#endif
    dOMTreeWalkerFirstChild                 ,


-- ** getCurrentNode #method:getCurrentNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerGetCurrentNode             ,


-- ** getExpandEntityReferences #method:getExpandEntityReferences#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetExpandEntityReferencesMethodInfo,
#endif
    dOMTreeWalkerGetExpandEntityReferences  ,


-- ** getFilter #method:getFilter#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetFilterMethodInfo        ,
#endif
    dOMTreeWalkerGetFilter                  ,


-- ** getRoot #method:getRoot#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetRootMethodInfo          ,
#endif
    dOMTreeWalkerGetRoot                    ,


-- ** getWhatToShow #method:getWhatToShow#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetWhatToShowMethodInfo    ,
#endif
    dOMTreeWalkerGetWhatToShow              ,


-- ** lastChild #method:lastChild#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerLastChildMethodInfo        ,
#endif
    dOMTreeWalkerLastChild                  ,


-- ** nextNode #method:nextNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerNextNodeMethodInfo         ,
#endif
    dOMTreeWalkerNextNode                   ,


-- ** nextSibling #method:nextSibling#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerNextSiblingMethodInfo      ,
#endif
    dOMTreeWalkerNextSibling                ,


-- ** parentNode #method:parentNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerParentNodeMethodInfo       ,
#endif
    dOMTreeWalkerParentNode                 ,


-- ** previousNode #method:previousNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerPreviousNodeMethodInfo     ,
#endif
    dOMTreeWalkerPreviousNode               ,


-- ** previousSibling #method:previousSibling#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerPreviousSiblingMethodInfo  ,
#endif
    dOMTreeWalkerPreviousSibling            ,


-- ** setCurrentNode #method:setCurrentNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerSetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerSetCurrentNode             ,




 -- * Properties


-- ** currentNode #attr:currentNode#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerCurrentNodePropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerCurrentNode                ,
#endif
    getDOMTreeWalkerCurrentNode             ,


-- ** filter #attr:filter#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerFilterPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerFilter                     ,
#endif
    getDOMTreeWalkerFilter                  ,


-- ** root #attr:root#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerRootPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerRoot                       ,
#endif
    getDOMTreeWalkerRoot                    ,


-- ** whatToShow #attr:whatToShow#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerWhatToShowPropertyInfo     ,
#endif
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R

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 (SP.ManagedPtr DOMTreeWalker)
    deriving (DOMTreeWalker -> DOMTreeWalker -> Bool
(DOMTreeWalker -> DOMTreeWalker -> Bool)
-> (DOMTreeWalker -> DOMTreeWalker -> Bool) -> Eq DOMTreeWalker
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DOMTreeWalker -> DOMTreeWalker -> Bool
== :: DOMTreeWalker -> DOMTreeWalker -> Bool
$c/= :: DOMTreeWalker -> DOMTreeWalker -> Bool
/= :: DOMTreeWalker -> DOMTreeWalker -> Bool
Eq)

instance SP.ManagedPtrNewtype DOMTreeWalker where
    toManagedPtr :: DOMTreeWalker -> ManagedPtr DOMTreeWalker
toManagedPtr (DOMTreeWalker ManagedPtr DOMTreeWalker
p) = ManagedPtr DOMTreeWalker
p

foreign import ccall "webkit_dom_tree_walker_get_type"
    c_webkit_dom_tree_walker_get_type :: IO B.Types.GType

instance B.Types.TypedObject DOMTreeWalker where
    glibType :: IO GType
glibType = IO GType
c_webkit_dom_tree_walker_get_type

instance B.Types.GObject DOMTreeWalker

-- | Type class for types which can be safely cast to `DOMTreeWalker`, for instance with `toDOMTreeWalker`.
class (SP.GObject o, O.IsDescendantOf DOMTreeWalker o) => IsDOMTreeWalker o
instance (SP.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 :: (MIO.MonadIO m, IsDOMTreeWalker o) => o -> m DOMTreeWalker
toDOMTreeWalker :: forall (m :: * -> *) o.
(MonadIO m, IsDOMTreeWalker o) =>
o -> m DOMTreeWalker
toDOMTreeWalker = IO DOMTreeWalker -> m DOMTreeWalker
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DOMTreeWalker -> m DOMTreeWalker)
-> (o -> IO DOMTreeWalker) -> o -> m DOMTreeWalker
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DOMTreeWalker -> DOMTreeWalker)
-> o -> IO DOMTreeWalker
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DOMTreeWalker -> DOMTreeWalker
DOMTreeWalker

-- | Convert 'DOMTreeWalker' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe DOMTreeWalker) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_dom_tree_walker_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DOMTreeWalker -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DOMTreeWalker
P.Nothing = Ptr GValue -> Ptr DOMTreeWalker -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DOMTreeWalker
forall a. Ptr a
FP.nullPtr :: FP.Ptr DOMTreeWalker)
    gvalueSet_ Ptr GValue
gv (P.Just DOMTreeWalker
obj) = DOMTreeWalker -> (Ptr DOMTreeWalker -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DOMTreeWalker
obj (Ptr GValue -> Ptr DOMTreeWalker -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DOMTreeWalker)
gvalueGet_ Ptr GValue
gv = do
        Ptr DOMTreeWalker
ptr <- Ptr GValue -> IO (Ptr DOMTreeWalker)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DOMTreeWalker)
        if Ptr DOMTreeWalker
ptr Ptr DOMTreeWalker -> Ptr DOMTreeWalker -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DOMTreeWalker
forall a. Ptr a
FP.nullPtr
        then DOMTreeWalker -> Maybe DOMTreeWalker
forall a. a -> Maybe a
P.Just (DOMTreeWalker -> Maybe DOMTreeWalker)
-> IO DOMTreeWalker -> IO (Maybe DOMTreeWalker)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DOMTreeWalker -> DOMTreeWalker)
-> Ptr DOMTreeWalker -> IO DOMTreeWalker
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DOMTreeWalker -> DOMTreeWalker
DOMTreeWalker Ptr DOMTreeWalker
ptr
        else Maybe DOMTreeWalker -> IO (Maybe DOMTreeWalker)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DOMTreeWalker
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveDOMTreeWalkerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDOMTreeWalkerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMTreeWalkerMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDOMTreeWalkerMethod t DOMTreeWalker, O.OverloadedMethod info DOMTreeWalker p, R.HasField t DOMTreeWalker p) => R.HasField t DOMTreeWalker p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveDOMTreeWalkerMethod t DOMTreeWalker, O.OverloadedMethodInfo info DOMTreeWalker) => OL.IsLabel t (O.MethodProxy info DOMTreeWalker) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsDOMTreeWalker o) =>
o -> m DOMNode
getDOMTreeWalkerCurrentNode o
obj = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe DOMNode) -> IO DOMNode
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getDOMTreeWalkerCurrentNode" (IO (Maybe DOMNode) -> IO DOMNode)
-> IO (Maybe DOMNode) -> IO DOMNode
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr DOMNode -> DOMNode) -> IO (Maybe DOMNode)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"current-node" ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerCurrentNodePropertyInfo
instance AttrInfo DOMTreeWalkerCurrentNodePropertyInfo where
    type AttrAllowedOps DOMTreeWalkerCurrentNodePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerCurrentNodePropertyInfo = ()
    type AttrGetType DOMTreeWalkerCurrentNodePropertyInfo = WebKit2WebExtension.DOMNode.DOMNode
    type AttrLabel DOMTreeWalkerCurrentNodePropertyInfo = "current-node"
    type AttrOrigin DOMTreeWalkerCurrentNodePropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerCurrentNode
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.currentNode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#g:attr:currentNode"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsDOMTreeWalker o) =>
o -> m (Maybe DOMNodeFilter)
getDOMTreeWalkerFilter o
obj = IO (Maybe DOMNodeFilter) -> m (Maybe DOMNodeFilter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe DOMNodeFilter) -> m (Maybe DOMNodeFilter))
-> IO (Maybe DOMNodeFilter) -> m (Maybe DOMNodeFilter)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr DOMNodeFilter -> DOMNodeFilter)
-> IO (Maybe DOMNodeFilter)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"filter" ManagedPtr DOMNodeFilter -> DOMNodeFilter
WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerFilterPropertyInfo
instance AttrInfo DOMTreeWalkerFilterPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerFilterPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DOMTreeWalkerFilterPropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerFilterPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerFilterPropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerFilterPropertyInfo = ()
    type AttrGetType DOMTreeWalkerFilterPropertyInfo = (Maybe WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)
    type AttrLabel DOMTreeWalkerFilterPropertyInfo = "filter"
    type AttrOrigin DOMTreeWalkerFilterPropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerFilter
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.filter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#g:attr:filter"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsDOMTreeWalker o) =>
o -> m DOMNode
getDOMTreeWalkerRoot o
obj = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe DOMNode) -> IO DOMNode
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getDOMTreeWalkerRoot" (IO (Maybe DOMNode) -> IO DOMNode)
-> IO (Maybe DOMNode) -> IO DOMNode
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr DOMNode -> DOMNode) -> IO (Maybe DOMNode)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"root" ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerRootPropertyInfo
instance AttrInfo DOMTreeWalkerRootPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerRootPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DOMTreeWalkerRootPropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerRootPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerRootPropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerRootPropertyInfo = ()
    type AttrGetType DOMTreeWalkerRootPropertyInfo = WebKit2WebExtension.DOMNode.DOMNode
    type AttrLabel DOMTreeWalkerRootPropertyInfo = "root"
    type AttrOrigin DOMTreeWalkerRootPropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerRoot
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.root"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#g:attr:root"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsDOMTreeWalker o) =>
o -> m CULong
getDOMTreeWalkerWhatToShow o
obj = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ o -> String -> IO CULong
forall a. GObject a => a -> String -> IO CULong
B.Properties.getObjectPropertyULong o
obj String
"what-to-show"

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerWhatToShowPropertyInfo
instance AttrInfo DOMTreeWalkerWhatToShowPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerWhatToShowPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerWhatToShowPropertyInfo = ()
    type AttrGetType DOMTreeWalkerWhatToShowPropertyInfo = CULong
    type AttrLabel DOMTreeWalkerWhatToShowPropertyInfo = "what-to-show"
    type AttrOrigin DOMTreeWalkerWhatToShowPropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerWhatToShow
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.whatToShow"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#g:attr:whatToShow"
        })
#endif

#if defined(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, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
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)
type instance O.SignalList DOMTreeWalker = DOMTreeWalkerSignalList
type DOMTreeWalkerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerFirstChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerFirstChild a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_first_child Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerFirstChild" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerFirstChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerFirstChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerGetCurrentNode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerGetCurrentNode a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_get_current_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerGetCurrentNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerGetCurrentNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerGetCurrentNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 'P.False'.
dOMTreeWalkerGetExpandEntityReferences ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m Bool
    -- ^ __Returns:__ A t'P.Bool'
dOMTreeWalkerGetExpandEntityReferences :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m Bool
dOMTreeWalkerGetExpandEntityReferences a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DOMTreeWalker -> IO CInt
webkit_dom_tree_walker_get_expand_entity_references Ptr DOMTreeWalker
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerGetExpandEntityReferencesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerGetExpandEntityReferences",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Interfaces.DOMNodeFilter.DOMNodeFilter'
dOMTreeWalkerGetFilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNodeFilter
dOMTreeWalkerGetFilter a
self = IO DOMNodeFilter -> m DOMNodeFilter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNodeFilter -> m DOMNodeFilter)
-> IO DOMNodeFilter -> m DOMNodeFilter
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNodeFilter
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNodeFilter)
webkit_dom_tree_walker_get_filter Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNodeFilter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerGetFilter" Ptr DOMNodeFilter
result
    DOMNodeFilter
result' <- ((ManagedPtr DOMNodeFilter -> DOMNodeFilter)
-> Ptr DOMNodeFilter -> IO DOMNodeFilter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DOMNodeFilter -> DOMNodeFilter
WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter) Ptr DOMNodeFilter
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNodeFilter -> IO DOMNodeFilter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNodeFilter
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerGetFilterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerGetFilter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerGetRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerGetRoot a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_get_root Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerGetRoot" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerGetRootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerGetRoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m CULong
    -- ^ __Returns:__ A @/gulong/@
dOMTreeWalkerGetWhatToShow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m CULong
dOMTreeWalkerGetWhatToShow a
self = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CULong
result <- Ptr DOMTreeWalker -> IO CULong
webkit_dom_tree_walker_get_what_to_show Ptr DOMTreeWalker
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CULong -> IO CULong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
result

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

instance O.OverloadedMethodInfo DOMTreeWalkerGetWhatToShowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerGetWhatToShow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerLastChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerLastChild a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_last_child Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerLastChild" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerLastChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerLastChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerNextNode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerNextNode a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_next_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerNextNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerNextNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerNextNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerNextSibling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerNextSibling a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_next_sibling Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerNextSibling" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerNextSiblingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerNextSibling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerParentNode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerParentNode a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_parent_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerParentNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerParentNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerParentNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerPreviousNode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerPreviousNode a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_previous_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerPreviousNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerPreviousNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerPreviousNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerPreviousSibling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
a -> m DOMNode
dOMTreeWalkerPreviousSibling a
self = IO DOMNode -> m DOMNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_previous_sibling Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMTreeWalkerPreviousSibling" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

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

instance O.OverloadedMethodInfo DOMTreeWalkerPreviousSiblingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerPreviousSibling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v: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 t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> b
    -- ^ /@value@/: A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dOMTreeWalkerSetCurrentNode :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDOMTreeWalker a, IsDOMNode b) =>
a -> b -> m ()
dOMTreeWalkerSetCurrentNode a
self b
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
value' <- b -> IO (Ptr DOMNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
value
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr DOMTreeWalker -> Ptr DOMNode -> Ptr (Ptr GError) -> IO ()
webkit_dom_tree_walker_set_current_node Ptr DOMTreeWalker
self' Ptr DOMNode
value'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
value
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

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

instance O.OverloadedMethodInfo DOMTreeWalkerSetCurrentNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.DOMTreeWalker.dOMTreeWalkerSetCurrentNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-DOMTreeWalker.html#v:dOMTreeWalkerSetCurrentNode"
        })


#endif