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

module GI.WebKit.Objects.DOMNodeIterator
    ( 

-- * Exported types
    DOMNodeIterator(..)                     ,
    IsDOMNodeIterator                       ,
    toDOMNodeIterator                       ,
    noDOMNodeIterator                       ,


 -- * Methods
-- ** detach #method:detach#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorDetachMethodInfo         ,
#endif
    dOMNodeIteratorDetach                   ,


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


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


-- ** getPointerBeforeReferenceNode #method:getPointerBeforeReferenceNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorGetPointerBeforeReferenceNodeMethodInfo,
#endif
    dOMNodeIteratorGetPointerBeforeReferenceNode,


-- ** getReferenceNode #method:getReferenceNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorGetReferenceNodeMethodInfo,
#endif
    dOMNodeIteratorGetReferenceNode         ,


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


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


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


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




 -- * Properties
-- ** expandEntityReferences #attr:expandEntityReferences#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorExpandEntityReferencesPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMNodeIteratorExpandEntityReferences   ,
#endif
    getDOMNodeIteratorExpandEntityReferences,


-- ** filter #attr:filter#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorFilterPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMNodeIteratorFilter                   ,
#endif
    getDOMNodeIteratorFilter                ,


-- ** pointerBeforeReferenceNode #attr:pointerBeforeReferenceNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMNodeIteratorPointerBeforeReferenceNode,
#endif
    getDOMNodeIteratorPointerBeforeReferenceNode,


-- ** referenceNode #attr:referenceNode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorReferenceNodePropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMNodeIteratorReferenceNode            ,
#endif
    getDOMNodeIteratorReferenceNode         ,


-- ** root #attr:root#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorRootPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMNodeIteratorRoot                     ,
#endif
    getDOMNodeIteratorRoot                  ,


-- ** whatToShow #attr:whatToShow#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMNodeIteratorWhatToShowPropertyInfo   ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMNodeIteratorWhatToShow               ,
#endif
    getDOMNodeIteratorWhatToShow            ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNode as WebKit.DOMNode
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNodeFilter as WebKit.DOMNodeFilter
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMObject as WebKit.DOMObject

newtype DOMNodeIterator = DOMNodeIterator (ManagedPtr DOMNodeIterator)
foreign import ccall "webkit_dom_node_iterator_get_type"
    c_webkit_dom_node_iterator_get_type :: IO GType

instance GObject DOMNodeIterator where
    gobjectType _ = c_webkit_dom_node_iterator_get_type
    

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

toDOMNodeIterator :: (MonadIO m, IsDOMNodeIterator o) => o -> m DOMNodeIterator
toDOMNodeIterator = liftIO . unsafeCastTo DOMNodeIterator

noDOMNodeIterator :: Maybe DOMNodeIterator
noDOMNodeIterator = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDOMNodeIteratorMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMNodeIteratorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMNodeIteratorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMNodeIteratorMethod "detach" o = DOMNodeIteratorDetachMethodInfo
    ResolveDOMNodeIteratorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMNodeIteratorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMNodeIteratorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMNodeIteratorMethod "nextNode" o = DOMNodeIteratorNextNodeMethodInfo
    ResolveDOMNodeIteratorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMNodeIteratorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMNodeIteratorMethod "previousNode" o = DOMNodeIteratorPreviousNodeMethodInfo
    ResolveDOMNodeIteratorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMNodeIteratorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMNodeIteratorMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMNodeIteratorMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMNodeIteratorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMNodeIteratorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMNodeIteratorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMNodeIteratorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMNodeIteratorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMNodeIteratorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMNodeIteratorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMNodeIteratorMethod "getExpandEntityReferences" o = DOMNodeIteratorGetExpandEntityReferencesMethodInfo
    ResolveDOMNodeIteratorMethod "getFilter" o = DOMNodeIteratorGetFilterMethodInfo
    ResolveDOMNodeIteratorMethod "getPointerBeforeReferenceNode" o = DOMNodeIteratorGetPointerBeforeReferenceNodeMethodInfo
    ResolveDOMNodeIteratorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMNodeIteratorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMNodeIteratorMethod "getReferenceNode" o = DOMNodeIteratorGetReferenceNodeMethodInfo
    ResolveDOMNodeIteratorMethod "getRoot" o = DOMNodeIteratorGetRootMethodInfo
    ResolveDOMNodeIteratorMethod "getWhatToShow" o = DOMNodeIteratorGetWhatToShowMethodInfo
    ResolveDOMNodeIteratorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMNodeIteratorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMNodeIteratorMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

getDOMNodeIteratorExpandEntityReferences :: (MonadIO m, IsDOMNodeIterator o) => o -> m Bool
getDOMNodeIteratorExpandEntityReferences obj = liftIO $ getObjectPropertyBool obj "expand-entity-references"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorExpandEntityReferencesPropertyInfo
instance AttrInfo DOMNodeIteratorExpandEntityReferencesPropertyInfo where
    type AttrAllowedOps DOMNodeIteratorExpandEntityReferencesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMNodeIteratorExpandEntityReferencesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMNodeIteratorExpandEntityReferencesPropertyInfo = IsDOMNodeIterator
    type AttrGetType DOMNodeIteratorExpandEntityReferencesPropertyInfo = Bool
    type AttrLabel DOMNodeIteratorExpandEntityReferencesPropertyInfo = "expand-entity-references"
    type AttrOrigin DOMNodeIteratorExpandEntityReferencesPropertyInfo = DOMNodeIterator
    attrGet _ = getDOMNodeIteratorExpandEntityReferences
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

getDOMNodeIteratorFilter :: (MonadIO m, IsDOMNodeIterator o) => o -> m (Maybe WebKit.DOMNodeFilter.DOMNodeFilter)
getDOMNodeIteratorFilter obj = liftIO $ getObjectPropertyObject obj "filter" WebKit.DOMNodeFilter.DOMNodeFilter

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

-- VVV Prop "pointer-before-reference-node"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMNodeIteratorPointerBeforeReferenceNode :: (MonadIO m, IsDOMNodeIterator o) => o -> m Bool
getDOMNodeIteratorPointerBeforeReferenceNode obj = liftIO $ getObjectPropertyBool obj "pointer-before-reference-node"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo
instance AttrInfo DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo where
    type AttrAllowedOps DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo = IsDOMNodeIterator
    type AttrGetType DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo = Bool
    type AttrLabel DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo = "pointer-before-reference-node"
    type AttrOrigin DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo = DOMNodeIterator
    attrGet _ = getDOMNodeIteratorPointerBeforeReferenceNode
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

getDOMNodeIteratorReferenceNode :: (MonadIO m, IsDOMNodeIterator o) => o -> m WebKit.DOMNode.DOMNode
getDOMNodeIteratorReferenceNode obj = liftIO $ checkUnexpectedNothing "getDOMNodeIteratorReferenceNode" $ getObjectPropertyObject obj "reference-node" WebKit.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorReferenceNodePropertyInfo
instance AttrInfo DOMNodeIteratorReferenceNodePropertyInfo where
    type AttrAllowedOps DOMNodeIteratorReferenceNodePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMNodeIteratorReferenceNodePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMNodeIteratorReferenceNodePropertyInfo = IsDOMNodeIterator
    type AttrGetType DOMNodeIteratorReferenceNodePropertyInfo = WebKit.DOMNode.DOMNode
    type AttrLabel DOMNodeIteratorReferenceNodePropertyInfo = "reference-node"
    type AttrOrigin DOMNodeIteratorReferenceNodePropertyInfo = DOMNodeIterator
    attrGet _ = getDOMNodeIteratorReferenceNode
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

getDOMNodeIteratorRoot :: (MonadIO m, IsDOMNodeIterator o) => o -> m WebKit.DOMNode.DOMNode
getDOMNodeIteratorRoot obj = liftIO $ checkUnexpectedNothing "getDOMNodeIteratorRoot" $ getObjectPropertyObject obj "root" WebKit.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorRootPropertyInfo
instance AttrInfo DOMNodeIteratorRootPropertyInfo where
    type AttrAllowedOps DOMNodeIteratorRootPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMNodeIteratorRootPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMNodeIteratorRootPropertyInfo = IsDOMNodeIterator
    type AttrGetType DOMNodeIteratorRootPropertyInfo = WebKit.DOMNode.DOMNode
    type AttrLabel DOMNodeIteratorRootPropertyInfo = "root"
    type AttrOrigin DOMNodeIteratorRootPropertyInfo = DOMNodeIterator
    attrGet _ = getDOMNodeIteratorRoot
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList DOMNodeIterator
type instance O.AttributeList DOMNodeIterator = DOMNodeIteratorAttributeList
type DOMNodeIteratorAttributeList = ('[ '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("expandEntityReferences", DOMNodeIteratorExpandEntityReferencesPropertyInfo), '("filter", DOMNodeIteratorFilterPropertyInfo), '("pointerBeforeReferenceNode", DOMNodeIteratorPointerBeforeReferenceNodePropertyInfo), '("referenceNode", DOMNodeIteratorReferenceNodePropertyInfo), '("root", DOMNodeIteratorRootPropertyInfo), '("whatToShow", DOMNodeIteratorWhatToShowPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
dOMNodeIteratorExpandEntityReferences :: AttrLabelProxy "expandEntityReferences"
dOMNodeIteratorExpandEntityReferences = AttrLabelProxy

dOMNodeIteratorFilter :: AttrLabelProxy "filter"
dOMNodeIteratorFilter = AttrLabelProxy

dOMNodeIteratorPointerBeforeReferenceNode :: AttrLabelProxy "pointerBeforeReferenceNode"
dOMNodeIteratorPointerBeforeReferenceNode = AttrLabelProxy

dOMNodeIteratorReferenceNode :: AttrLabelProxy "referenceNode"
dOMNodeIteratorReferenceNode = AttrLabelProxy

dOMNodeIteratorRoot :: AttrLabelProxy "root"
dOMNodeIteratorRoot = AttrLabelProxy

dOMNodeIteratorWhatToShow :: AttrLabelProxy "whatToShow"
dOMNodeIteratorWhatToShow = AttrLabelProxy

#endif

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

#endif

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

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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorDetachMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMNodeIterator a) => O.MethodInfo DOMNodeIteratorDetachMethodInfo a signature where
    overloadedMethod _ = dOMNodeIteratorDetach

#endif

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

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

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

#endif

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

foreign import ccall "webkit_dom_node_iterator_get_filter" webkit_dom_node_iterator_get_filter :: 
    Ptr DOMNodeIterator ->                  -- self : TInterface (Name {namespace = "WebKit", name = "DOMNodeIterator"})
    IO (Ptr WebKit.DOMNodeFilter.DOMNodeFilter)

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorGetFilterMethodInfo
instance (signature ~ (m WebKit.DOMNodeFilter.DOMNodeFilter), MonadIO m, IsDOMNodeIterator a) => O.MethodInfo DOMNodeIteratorGetFilterMethodInfo a signature where
    overloadedMethod _ = dOMNodeIteratorGetFilter

#endif

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

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

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

#endif

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

foreign import ccall "webkit_dom_node_iterator_get_reference_node" webkit_dom_node_iterator_get_reference_node :: 
    Ptr DOMNodeIterator ->                  -- self : TInterface (Name {namespace = "WebKit", name = "DOMNodeIterator"})
    IO (Ptr WebKit.DOMNode.DOMNode)

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorGetReferenceNodeMethodInfo
instance (signature ~ (m WebKit.DOMNode.DOMNode), MonadIO m, IsDOMNodeIterator a) => O.MethodInfo DOMNodeIteratorGetReferenceNodeMethodInfo a signature where
    overloadedMethod _ = dOMNodeIteratorGetReferenceNode

#endif

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

foreign import ccall "webkit_dom_node_iterator_get_root" webkit_dom_node_iterator_get_root :: 
    Ptr DOMNodeIterator ->                  -- self : TInterface (Name {namespace = "WebKit", name = "DOMNodeIterator"})
    IO (Ptr WebKit.DOMNode.DOMNode)

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorGetRootMethodInfo
instance (signature ~ (m WebKit.DOMNode.DOMNode), MonadIO m, IsDOMNodeIterator a) => O.MethodInfo DOMNodeIteratorGetRootMethodInfo a signature where
    overloadedMethod _ = dOMNodeIteratorGetRoot

#endif

-- method DOMNodeIterator::get_what_to_show
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMNodeIterator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMNodeIterator", 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_node_iterator_get_what_to_show" webkit_dom_node_iterator_get_what_to_show :: 
    Ptr DOMNodeIterator ->                  -- self : TInterface (Name {namespace = "WebKit", name = "DOMNodeIterator"})
    IO CULong

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

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

#endif

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

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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorNextNodeMethodInfo
instance (signature ~ (m WebKit.DOMNode.DOMNode), MonadIO m, IsDOMNodeIterator a) => O.MethodInfo DOMNodeIteratorNextNodeMethodInfo a signature where
    overloadedMethod _ = dOMNodeIteratorNextNode

#endif

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

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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMNodeIteratorPreviousNodeMethodInfo
instance (signature ~ (m WebKit.DOMNode.DOMNode), MonadIO m, IsDOMNodeIterator a) => O.MethodInfo DOMNodeIteratorPreviousNodeMethodInfo a signature where
    overloadedMethod _ = dOMNodeIteratorPreviousNode

#endif