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

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

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

module GI.WebKit2WebExtension.Objects.DOMXPathResult
    (

-- * Exported types
    DOMXPathResult(..)                      ,
    IsDOMXPathResult                        ,
    toDOMXPathResult                        ,
    noDOMXPathResult                        ,


 -- * Methods
-- ** getBooleanValue #method:getBooleanValue#

#if ENABLE_OVERLOADING
    DOMXPathResultGetBooleanValueMethodInfo ,
#endif
    dOMXPathResultGetBooleanValue           ,


-- ** getInvalidIteratorState #method:getInvalidIteratorState#

#if ENABLE_OVERLOADING
    DOMXPathResultGetInvalidIteratorStateMethodInfo,
#endif
    dOMXPathResultGetInvalidIteratorState   ,


-- ** getNumberValue #method:getNumberValue#

#if ENABLE_OVERLOADING
    DOMXPathResultGetNumberValueMethodInfo  ,
#endif
    dOMXPathResultGetNumberValue            ,


-- ** getResultType #method:getResultType#

#if ENABLE_OVERLOADING
    DOMXPathResultGetResultTypeMethodInfo   ,
#endif
    dOMXPathResultGetResultType             ,


-- ** getSingleNodeValue #method:getSingleNodeValue#

#if ENABLE_OVERLOADING
    DOMXPathResultGetSingleNodeValueMethodInfo,
#endif
    dOMXPathResultGetSingleNodeValue        ,


-- ** getSnapshotLength #method:getSnapshotLength#

#if ENABLE_OVERLOADING
    DOMXPathResultGetSnapshotLengthMethodInfo,
#endif
    dOMXPathResultGetSnapshotLength         ,


-- ** getStringValue #method:getStringValue#

#if ENABLE_OVERLOADING
    DOMXPathResultGetStringValueMethodInfo  ,
#endif
    dOMXPathResultGetStringValue            ,


-- ** iterateNext #method:iterateNext#

#if ENABLE_OVERLOADING
    DOMXPathResultIterateNextMethodInfo     ,
#endif
    dOMXPathResultIterateNext               ,


-- ** snapshotItem #method:snapshotItem#

#if ENABLE_OVERLOADING
    DOMXPathResultSnapshotItemMethodInfo    ,
#endif
    dOMXPathResultSnapshotItem              ,




 -- * Properties
-- ** booleanValue #attr:booleanValue#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultBooleanValuePropertyInfo  ,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultBooleanValue              ,
#endif
    getDOMXPathResultBooleanValue           ,


-- ** invalidIteratorState #attr:invalidIteratorState#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultInvalidIteratorStatePropertyInfo,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultInvalidIteratorState      ,
#endif
    getDOMXPathResultInvalidIteratorState   ,


-- ** numberValue #attr:numberValue#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultNumberValuePropertyInfo   ,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultNumberValue               ,
#endif
    getDOMXPathResultNumberValue            ,


-- ** resultType #attr:resultType#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultResultTypePropertyInfo    ,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultResultType                ,
#endif
    getDOMXPathResultResultType             ,


-- ** singleNodeValue #attr:singleNodeValue#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultSingleNodeValuePropertyInfo,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultSingleNodeValue           ,
#endif
    getDOMXPathResultSingleNodeValue        ,


-- ** snapshotLength #attr:snapshotLength#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultSnapshotLengthPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultSnapshotLength            ,
#endif
    getDOMXPathResultSnapshotLength         ,


-- ** stringValue #attr:stringValue#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DOMXPathResultStringValuePropertyInfo   ,
#endif
#if ENABLE_OVERLOADING
    dOMXPathResultStringValue               ,
#endif
    getDOMXPathResultStringValue            ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

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

-- | Memory-managed wrapper type.
newtype DOMXPathResult = DOMXPathResult (ManagedPtr DOMXPathResult)
foreign import ccall "webkit_dom_xpath_result_get_type"
    c_webkit_dom_xpath_result_get_type :: IO GType

instance GObject DOMXPathResult where
    gobjectType = c_webkit_dom_xpath_result_get_type


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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `DOMXPathResult`.
noDOMXPathResult :: Maybe DOMXPathResult
noDOMXPathResult = Nothing

#if ENABLE_OVERLOADING
type family ResolveDOMXPathResultMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMXPathResultMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMXPathResultMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMXPathResultMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMXPathResultMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMXPathResultMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDOMXPathResultMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMXPathResultMethod "iterateNext" o = DOMXPathResultIterateNextMethodInfo
    ResolveDOMXPathResultMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMXPathResultMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMXPathResultMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMXPathResultMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMXPathResultMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMXPathResultMethod "snapshotItem" o = DOMXPathResultSnapshotItemMethodInfo
    ResolveDOMXPathResultMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMXPathResultMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMXPathResultMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMXPathResultMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMXPathResultMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMXPathResultMethod "getBooleanValue" o = DOMXPathResultGetBooleanValueMethodInfo
    ResolveDOMXPathResultMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMXPathResultMethod "getInvalidIteratorState" o = DOMXPathResultGetInvalidIteratorStateMethodInfo
    ResolveDOMXPathResultMethod "getNumberValue" o = DOMXPathResultGetNumberValueMethodInfo
    ResolveDOMXPathResultMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMXPathResultMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMXPathResultMethod "getResultType" o = DOMXPathResultGetResultTypeMethodInfo
    ResolveDOMXPathResultMethod "getSingleNodeValue" o = DOMXPathResultGetSingleNodeValueMethodInfo
    ResolveDOMXPathResultMethod "getSnapshotLength" o = DOMXPathResultGetSnapshotLengthMethodInfo
    ResolveDOMXPathResultMethod "getStringValue" o = DOMXPathResultGetStringValueMethodInfo
    ResolveDOMXPathResultMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMXPathResultMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDOMXPathResultMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMXPathResultMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "boolean-value"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #booleanValue
@
-}
getDOMXPathResultBooleanValue :: (MonadIO m, IsDOMXPathResult o) => o -> m Bool
getDOMXPathResultBooleanValue obj = liftIO $ B.Properties.getObjectPropertyBool obj "boolean-value"

#if ENABLE_OVERLOADING
data DOMXPathResultBooleanValuePropertyInfo
instance AttrInfo DOMXPathResultBooleanValuePropertyInfo where
    type AttrAllowedOps DOMXPathResultBooleanValuePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMXPathResultBooleanValuePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultBooleanValuePropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultBooleanValuePropertyInfo = Bool
    type AttrLabel DOMXPathResultBooleanValuePropertyInfo = "boolean-value"
    type AttrOrigin DOMXPathResultBooleanValuePropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultBooleanValue
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "invalid-iterator-state"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #invalidIteratorState
@
-}
getDOMXPathResultInvalidIteratorState :: (MonadIO m, IsDOMXPathResult o) => o -> m Bool
getDOMXPathResultInvalidIteratorState obj = liftIO $ B.Properties.getObjectPropertyBool obj "invalid-iterator-state"

#if ENABLE_OVERLOADING
data DOMXPathResultInvalidIteratorStatePropertyInfo
instance AttrInfo DOMXPathResultInvalidIteratorStatePropertyInfo where
    type AttrAllowedOps DOMXPathResultInvalidIteratorStatePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMXPathResultInvalidIteratorStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultInvalidIteratorStatePropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultInvalidIteratorStatePropertyInfo = Bool
    type AttrLabel DOMXPathResultInvalidIteratorStatePropertyInfo = "invalid-iterator-state"
    type AttrOrigin DOMXPathResultInvalidIteratorStatePropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultInvalidIteratorState
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "number-value"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #numberValue
@
-}
getDOMXPathResultNumberValue :: (MonadIO m, IsDOMXPathResult o) => o -> m Double
getDOMXPathResultNumberValue obj = liftIO $ B.Properties.getObjectPropertyDouble obj "number-value"

#if ENABLE_OVERLOADING
data DOMXPathResultNumberValuePropertyInfo
instance AttrInfo DOMXPathResultNumberValuePropertyInfo where
    type AttrAllowedOps DOMXPathResultNumberValuePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMXPathResultNumberValuePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultNumberValuePropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultNumberValuePropertyInfo = Double
    type AttrLabel DOMXPathResultNumberValuePropertyInfo = "number-value"
    type AttrOrigin DOMXPathResultNumberValuePropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultNumberValue
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "result-type"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #resultType
@
-}
getDOMXPathResultResultType :: (MonadIO m, IsDOMXPathResult o) => o -> m Word32
getDOMXPathResultResultType obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "result-type"

#if ENABLE_OVERLOADING
data DOMXPathResultResultTypePropertyInfo
instance AttrInfo DOMXPathResultResultTypePropertyInfo where
    type AttrAllowedOps DOMXPathResultResultTypePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMXPathResultResultTypePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultResultTypePropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultResultTypePropertyInfo = Word32
    type AttrLabel DOMXPathResultResultTypePropertyInfo = "result-type"
    type AttrOrigin DOMXPathResultResultTypePropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultResultType
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #singleNodeValue
@
-}
getDOMXPathResultSingleNodeValue :: (MonadIO m, IsDOMXPathResult o) => o -> m (Maybe WebKit2WebExtension.DOMNode.DOMNode)
getDOMXPathResultSingleNodeValue obj = liftIO $ B.Properties.getObjectPropertyObject obj "single-node-value" WebKit2WebExtension.DOMNode.DOMNode

#if ENABLE_OVERLOADING
data DOMXPathResultSingleNodeValuePropertyInfo
instance AttrInfo DOMXPathResultSingleNodeValuePropertyInfo where
    type AttrAllowedOps DOMXPathResultSingleNodeValuePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMXPathResultSingleNodeValuePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultSingleNodeValuePropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultSingleNodeValuePropertyInfo = (Maybe WebKit2WebExtension.DOMNode.DOMNode)
    type AttrLabel DOMXPathResultSingleNodeValuePropertyInfo = "single-node-value"
    type AttrOrigin DOMXPathResultSingleNodeValuePropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultSingleNodeValue
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "snapshot-length"
   -- Type: TBasicType TULong
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #snapshotLength
@
-}
getDOMXPathResultSnapshotLength :: (MonadIO m, IsDOMXPathResult o) => o -> m CULong
getDOMXPathResultSnapshotLength obj = liftIO $ B.Properties.getObjectPropertyULong obj "snapshot-length"

#if ENABLE_OVERLOADING
data DOMXPathResultSnapshotLengthPropertyInfo
instance AttrInfo DOMXPathResultSnapshotLengthPropertyInfo where
    type AttrAllowedOps DOMXPathResultSnapshotLengthPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMXPathResultSnapshotLengthPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultSnapshotLengthPropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultSnapshotLengthPropertyInfo = CULong
    type AttrLabel DOMXPathResultSnapshotLengthPropertyInfo = "snapshot-length"
    type AttrOrigin DOMXPathResultSnapshotLengthPropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultSnapshotLength
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "string-value"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' dOMXPathResult #stringValue
@
-}
getDOMXPathResultStringValue :: (MonadIO m, IsDOMXPathResult o) => o -> m (Maybe T.Text)
getDOMXPathResultStringValue obj = liftIO $ B.Properties.getObjectPropertyString obj "string-value"

#if ENABLE_OVERLOADING
data DOMXPathResultStringValuePropertyInfo
instance AttrInfo DOMXPathResultStringValuePropertyInfo where
    type AttrAllowedOps DOMXPathResultStringValuePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMXPathResultStringValuePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMXPathResultStringValuePropertyInfo = IsDOMXPathResult
    type AttrGetType DOMXPathResultStringValuePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMXPathResultStringValuePropertyInfo = "string-value"
    type AttrOrigin DOMXPathResultStringValuePropertyInfo = DOMXPathResult
    attrGet _ = getDOMXPathResultStringValue
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList DOMXPathResult
type instance O.AttributeList DOMXPathResult = DOMXPathResultAttributeList
type DOMXPathResultAttributeList = ('[ '("booleanValue", DOMXPathResultBooleanValuePropertyInfo), '("coreObject", WebKit2WebExtension.DOMObject.DOMObjectCoreObjectPropertyInfo), '("invalidIteratorState", DOMXPathResultInvalidIteratorStatePropertyInfo), '("numberValue", DOMXPathResultNumberValuePropertyInfo), '("resultType", DOMXPathResultResultTypePropertyInfo), '("singleNodeValue", DOMXPathResultSingleNodeValuePropertyInfo), '("snapshotLength", DOMXPathResultSnapshotLengthPropertyInfo), '("stringValue", DOMXPathResultStringValuePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
dOMXPathResultBooleanValue :: AttrLabelProxy "booleanValue"
dOMXPathResultBooleanValue = AttrLabelProxy

dOMXPathResultInvalidIteratorState :: AttrLabelProxy "invalidIteratorState"
dOMXPathResultInvalidIteratorState = AttrLabelProxy

dOMXPathResultNumberValue :: AttrLabelProxy "numberValue"
dOMXPathResultNumberValue = AttrLabelProxy

dOMXPathResultResultType :: AttrLabelProxy "resultType"
dOMXPathResultResultType = AttrLabelProxy

dOMXPathResultSingleNodeValue :: AttrLabelProxy "singleNodeValue"
dOMXPathResultSingleNodeValue = AttrLabelProxy

dOMXPathResultSnapshotLength :: AttrLabelProxy "snapshotLength"
dOMXPathResultSnapshotLength = AttrLabelProxy

dOMXPathResultStringValue :: AttrLabelProxy "stringValue"
dOMXPathResultStringValue = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
type instance O.SignalList DOMXPathResult = DOMXPathResultSignalList
type DOMXPathResultSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "webkit_dom_xpath_result_get_boolean_value" webkit_dom_xpath_result_get_boolean_value ::
    Ptr DOMXPathResult ->                   -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMXPathResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED dOMXPathResultGetBooleanValue ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetBooleanValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultGetBooleanValue self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        _ <- propagateGError $ webkit_dom_xpath_result_get_boolean_value self'
        touchManagedPtr self
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultGetBooleanValueMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetBooleanValueMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetBooleanValue

#endif

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

{-# DEPRECATED dOMXPathResultGetInvalidIteratorState ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetInvalidIteratorState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMXPathResultGetInvalidIteratorState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_xpath_result_get_invalid_iterator_state self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data DOMXPathResultGetInvalidIteratorStateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetInvalidIteratorStateMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetInvalidIteratorState

#endif

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

foreign import ccall "webkit_dom_xpath_result_get_number_value" webkit_dom_xpath_result_get_number_value ::
    Ptr DOMXPathResult ->                   -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMXPathResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CDouble

{-# DEPRECATED dOMXPathResultGetNumberValue ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetNumberValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultGetNumberValue self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_xpath_result_get_number_value self'
        let result' = realToFrac result
        touchManagedPtr self
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultGetNumberValueMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetNumberValueMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetNumberValue

#endif

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

foreign import ccall "webkit_dom_xpath_result_get_result_type" webkit_dom_xpath_result_get_result_type ::
    Ptr DOMXPathResult ->                   -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMXPathResult"})
    IO Word16

{-# DEPRECATED dOMXPathResultGetResultType ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetResultType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m Word16
    {- ^ __Returns:__ A @/gushort/@ -}
dOMXPathResultGetResultType self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_xpath_result_get_result_type self'
    touchManagedPtr self
    return result

#if ENABLE_OVERLOADING
data DOMXPathResultGetResultTypeMethodInfo
instance (signature ~ (m Word16), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetResultTypeMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetResultType

#endif

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

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

{-# DEPRECATED dOMXPathResultGetSingleNodeValue ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetSingleNodeValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultGetSingleNodeValue self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_xpath_result_get_single_node_value self'
        checkUnexpectedReturnNULL "dOMXPathResultGetSingleNodeValue" result
        result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
        touchManagedPtr self
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultGetSingleNodeValueMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetSingleNodeValueMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetSingleNodeValue

#endif

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

foreign import ccall "webkit_dom_xpath_result_get_snapshot_length" webkit_dom_xpath_result_get_snapshot_length ::
    Ptr DOMXPathResult ->                   -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMXPathResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CULong

{-# DEPRECATED dOMXPathResultGetSnapshotLength ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetSnapshotLength ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m CULong
    {- ^ __Returns:__ A @/gulong/@ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultGetSnapshotLength self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_xpath_result_get_snapshot_length self'
        touchManagedPtr self
        return result
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultGetSnapshotLengthMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetSnapshotLengthMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetSnapshotLength

#endif

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

foreign import ccall "webkit_dom_xpath_result_get_string_value" webkit_dom_xpath_result_get_string_value ::
    Ptr DOMXPathResult ->                   -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMXPathResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CString

{-# DEPRECATED dOMXPathResultGetStringValue ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultGetStringValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultGetStringValue self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_xpath_result_get_string_value self'
        checkUnexpectedReturnNULL "dOMXPathResultGetStringValue" result
        result' <- cstringToText result
        freeMem result
        touchManagedPtr self
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultGetStringValueMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultGetStringValueMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultGetStringValue

#endif

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

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

{-# DEPRECATED dOMXPathResultIterateNext ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultIterateNext ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultIterateNext self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_xpath_result_iterate_next self'
        checkUnexpectedReturnNULL "dOMXPathResultIterateNext" result
        result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
        touchManagedPtr self
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultIterateNextMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultIterateNextMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultIterateNext

#endif

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

foreign import ccall "webkit_dom_xpath_result_snapshot_item" webkit_dom_xpath_result_snapshot_item ::
    Ptr DOMXPathResult ->                   -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMXPathResult"})
    CULong ->                               -- index : TBasicType TULong
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMXPathResultSnapshotItem ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
{- |
/No description available in the introspection data./
-}
dOMXPathResultSnapshotItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMXPathResult a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit2WebExtension.Objects.DOMXPathResult.DOMXPathResult' -}
    -> CULong
    {- ^ /@index@/: A @/gulong/@ -}
    -> m WebKit2WebExtension.DOMNode.DOMNode
    {- ^ __Returns:__ A 'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMXPathResultSnapshotItem self index = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        result <- propagateGError $ webkit_dom_xpath_result_snapshot_item self' index
        checkUnexpectedReturnNULL "dOMXPathResultSnapshotItem" result
        result' <- (newObject WebKit2WebExtension.DOMNode.DOMNode) result
        touchManagedPtr self
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DOMXPathResultSnapshotItemMethodInfo
instance (signature ~ (CULong -> m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMXPathResult a) => O.MethodInfo DOMXPathResultSnapshotItemMethodInfo a signature where
    overloadedMethod _ = dOMXPathResultSnapshotItem

#endif