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

    The AtkDocument interface should be supported by any object whose
    content is a representation or view of a document.  The AtkDocument
    interface should appear on the toplevel container for the document
    content; however AtkDocument instances may be nested (i.e. an
    AtkDocument may be a descendant of another AtkDocument) in those
    cases where one document contains \"embedded content\" which can
    reasonably be considered a document in its own right.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Atk.Interfaces.Document
        (

    -- * Exported types
        Document(..)                            ,
        noDocument                              ,
        IsDocument                              ,
        toDocument                              ,

     -- * Methods
    -- ** getAttributeValue #method:getAttributeValue#

    #if ENABLE_OVERLOADING
        DocumentGetAttributeValueMethodInfo     ,
    #endif
        documentGetAttributeValue               ,

    -- ** getAttributes #method:getAttributes#

    #if ENABLE_OVERLOADING
        DocumentGetAttributesMethodInfo         ,
    #endif
        documentGetAttributes                   ,

    -- ** getCurrentPageNumber #method:getCurrentPageNumber#

    #if ENABLE_OVERLOADING
        DocumentGetCurrentPageNumberMethodInfo  ,
    #endif
        documentGetCurrentPageNumber            ,

    -- ** getDocument #method:getDocument#

    #if ENABLE_OVERLOADING
        DocumentGetDocumentMethodInfo           ,
    #endif
        documentGetDocument                     ,

    -- ** getDocumentType #method:getDocumentType#

    #if ENABLE_OVERLOADING
        DocumentGetDocumentTypeMethodInfo       ,
    #endif
        documentGetDocumentType                 ,

    -- ** getLocale #method:getLocale#

    #if ENABLE_OVERLOADING
        DocumentGetLocaleMethodInfo             ,
    #endif
        documentGetLocale                       ,

    -- ** getPageCount #method:getPageCount#

    #if ENABLE_OVERLOADING
        DocumentGetPageCountMethodInfo          ,
    #endif
        documentGetPageCount                    ,

    -- ** setAttributeValue #method:setAttributeValue#

    #if ENABLE_OVERLOADING
        DocumentSetAttributeValueMethodInfo     ,
    #endif
        documentSetAttributeValue               ,

     -- * Signals
    -- ** loadComplete #signal:loadComplete#

        C_DocumentLoadCompleteCallback          ,
        DocumentLoadCompleteCallback            ,
    #if ENABLE_OVERLOADING
        DocumentLoadCompleteSignalInfo          ,
    #endif
        afterDocumentLoadComplete               ,
        genClosure_DocumentLoadComplete         ,
        mk_DocumentLoadCompleteCallback         ,
        noDocumentLoadCompleteCallback          ,
        onDocumentLoadComplete                  ,
        wrap_DocumentLoadCompleteCallback       ,

    -- ** loadStopped #signal:loadStopped#

        C_DocumentLoadStoppedCallback           ,
        DocumentLoadStoppedCallback             ,
    #if ENABLE_OVERLOADING
        DocumentLoadStoppedSignalInfo           ,
    #endif
        afterDocumentLoadStopped                ,
        genClosure_DocumentLoadStopped          ,
        mk_DocumentLoadStoppedCallback          ,
        noDocumentLoadStoppedCallback           ,
        onDocumentLoadStopped                   ,
        wrap_DocumentLoadStoppedCallback        ,

    -- ** pageChanged #signal:pageChanged#

        C_DocumentPageChangedCallback           ,
        DocumentPageChangedCallback             ,
    #if ENABLE_OVERLOADING
        DocumentPageChangedSignalInfo           ,
    #endif
        afterDocumentPageChanged                ,
        genClosure_DocumentPageChanged          ,
        mk_DocumentPageChangedCallback          ,
        noDocumentPageChangedCallback           ,
        onDocumentPageChanged                   ,
        wrap_DocumentPageChangedCallback        ,

    -- ** reload #signal:reload#

        C_DocumentReloadCallback                ,
        DocumentReloadCallback                  ,
    #if ENABLE_OVERLOADING
        DocumentReloadSignalInfo                ,
    #endif
        afterDocumentReload                     ,
        genClosure_DocumentReload               ,
        mk_DocumentReloadCallback               ,
        noDocumentReloadCallback                ,
        onDocumentReload                        ,
        wrap_DocumentReloadCallback             ,

        ) 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.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.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

    -- interface Document
    -- | Memory-managed wrapper type.
    newtype Document = Document (ManagedPtr Document)
    -- | A convenience alias for `Nothing` :: `Maybe` `Document`.
    noDocument :: Maybe Document
    noDocument = Nothing

    -- signal Document::load-complete
    {- |
    The \'load-complete\' signal is emitted when a pending load of
    a static document has completed.  This signal is to be
    expected by ATK clients if and when AtkDocument implementors
    expose ATK_STATE_BUSY.  If the state of an AtkObject which
    implements AtkDocument does not include ATK_STATE_BUSY, it
    should be safe for clients to assume that the AtkDocument\'s
    static contents are fully loaded into the container.
    (Dynamic document contents should be exposed via other
    signals.)
    -}
    type DocumentLoadCompleteCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentLoadCompleteCallback`@.
    noDocumentLoadCompleteCallback :: Maybe DocumentLoadCompleteCallback
    noDocumentLoadCompleteCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DocumentLoadCompleteCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_DocumentLoadCompleteCallback`.
    foreign import ccall "wrapper"
        mk_DocumentLoadCompleteCallback :: C_DocumentLoadCompleteCallback -> IO (FunPtr C_DocumentLoadCompleteCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DocumentLoadComplete :: DocumentLoadCompleteCallback -> IO Closure
    genClosure_DocumentLoadComplete cb = do
        let cb' = wrap_DocumentLoadCompleteCallback cb
        mk_DocumentLoadCompleteCallback cb' >>= newCClosure

    -- | Wrap a `DocumentLoadCompleteCallback` into a `C_DocumentLoadCompleteCallback`.
    wrap_DocumentLoadCompleteCallback ::
        DocumentLoadCompleteCallback ->
        C_DocumentLoadCompleteCallback
    wrap_DocumentLoadCompleteCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@load-complete@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' document #loadComplete callback
    @
    -}
    onDocumentLoadComplete :: (IsDocument a, MonadIO m) => a -> DocumentLoadCompleteCallback -> m SignalHandlerId
    onDocumentLoadComplete obj cb = liftIO $ do
        let cb' = wrap_DocumentLoadCompleteCallback cb
        cb'' <- mk_DocumentLoadCompleteCallback cb'
        connectSignalFunPtr obj "load-complete" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@load-complete@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' document #loadComplete callback
    @
    -}
    afterDocumentLoadComplete :: (IsDocument a, MonadIO m) => a -> DocumentLoadCompleteCallback -> m SignalHandlerId
    afterDocumentLoadComplete obj cb = liftIO $ do
        let cb' = wrap_DocumentLoadCompleteCallback cb
        cb'' <- mk_DocumentLoadCompleteCallback cb'
        connectSignalFunPtr obj "load-complete" cb'' SignalConnectAfter

    -- signal Document::load-stopped
    {- |
    The \'load-stopped\' signal is emitted when a pending load of
    document contents is cancelled, paused, or otherwise
    interrupted by the user or application logic.  It should not
    however be emitted while waiting for a resource (for instance
    while blocking on a file or network read) unless a
    user-significant timeout has occurred.
    -}
    type DocumentLoadStoppedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentLoadStoppedCallback`@.
    noDocumentLoadStoppedCallback :: Maybe DocumentLoadStoppedCallback
    noDocumentLoadStoppedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DocumentLoadStoppedCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_DocumentLoadStoppedCallback`.
    foreign import ccall "wrapper"
        mk_DocumentLoadStoppedCallback :: C_DocumentLoadStoppedCallback -> IO (FunPtr C_DocumentLoadStoppedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DocumentLoadStopped :: DocumentLoadStoppedCallback -> IO Closure
    genClosure_DocumentLoadStopped cb = do
        let cb' = wrap_DocumentLoadStoppedCallback cb
        mk_DocumentLoadStoppedCallback cb' >>= newCClosure

    -- | Wrap a `DocumentLoadStoppedCallback` into a `C_DocumentLoadStoppedCallback`.
    wrap_DocumentLoadStoppedCallback ::
        DocumentLoadStoppedCallback ->
        C_DocumentLoadStoppedCallback
    wrap_DocumentLoadStoppedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@load-stopped@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' document #loadStopped callback
    @
    -}
    onDocumentLoadStopped :: (IsDocument a, MonadIO m) => a -> DocumentLoadStoppedCallback -> m SignalHandlerId
    onDocumentLoadStopped obj cb = liftIO $ do
        let cb' = wrap_DocumentLoadStoppedCallback cb
        cb'' <- mk_DocumentLoadStoppedCallback cb'
        connectSignalFunPtr obj "load-stopped" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@load-stopped@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' document #loadStopped callback
    @
    -}
    afterDocumentLoadStopped :: (IsDocument a, MonadIO m) => a -> DocumentLoadStoppedCallback -> m SignalHandlerId
    afterDocumentLoadStopped obj cb = liftIO $ do
        let cb' = wrap_DocumentLoadStoppedCallback cb
        cb'' <- mk_DocumentLoadStoppedCallback cb'
        connectSignalFunPtr obj "load-stopped" cb'' SignalConnectAfter

    -- signal Document::page-changed
    {- |
    The \'page-changed\' signal is emitted when the current page of
    a document changes, e.g. pressing page up\/down in a document
    viewer.

    /Since: 2.12/
    -}
    type DocumentPageChangedCallback =
        Int32
        {- ^ /@pageNumber@/: the new page number. If this value is unknown
    or not applicable, -1 should be provided. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentPageChangedCallback`@.
    noDocumentPageChangedCallback :: Maybe DocumentPageChangedCallback
    noDocumentPageChangedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DocumentPageChangedCallback =
        Ptr () ->                               -- object
        Int32 ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_DocumentPageChangedCallback`.
    foreign import ccall "wrapper"
        mk_DocumentPageChangedCallback :: C_DocumentPageChangedCallback -> IO (FunPtr C_DocumentPageChangedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DocumentPageChanged :: DocumentPageChangedCallback -> IO Closure
    genClosure_DocumentPageChanged cb = do
        let cb' = wrap_DocumentPageChangedCallback cb
        mk_DocumentPageChangedCallback cb' >>= newCClosure

    -- | Wrap a `DocumentPageChangedCallback` into a `C_DocumentPageChangedCallback`.
    wrap_DocumentPageChangedCallback ::
        DocumentPageChangedCallback ->
        C_DocumentPageChangedCallback
    wrap_DocumentPageChangedCallback _cb _ pageNumber _ = do
        _cb  pageNumber

    {- |
    Connect a signal handler for the “@page-changed@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' document #pageChanged callback
    @
    -}
    onDocumentPageChanged :: (IsDocument a, MonadIO m) => a -> DocumentPageChangedCallback -> m SignalHandlerId
    onDocumentPageChanged obj cb = liftIO $ do
        let cb' = wrap_DocumentPageChangedCallback cb
        cb'' <- mk_DocumentPageChangedCallback cb'
        connectSignalFunPtr obj "page-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@page-changed@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' document #pageChanged callback
    @
    -}
    afterDocumentPageChanged :: (IsDocument a, MonadIO m) => a -> DocumentPageChangedCallback -> m SignalHandlerId
    afterDocumentPageChanged obj cb = liftIO $ do
        let cb' = wrap_DocumentPageChangedCallback cb
        cb'' <- mk_DocumentPageChangedCallback cb'
        connectSignalFunPtr obj "page-changed" cb'' SignalConnectAfter

    -- signal Document::reload
    {- |
    The \'reload\' signal is emitted when the contents of a
    document is refreshed from its source.  Once \'reload\' has
    been emitted, a matching \'load-complete\' or \'load-stopped\'
    signal should follow, which clients may await before
    interrogating ATK for the latest document content.
    -}
    type DocumentReloadCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentReloadCallback`@.
    noDocumentReloadCallback :: Maybe DocumentReloadCallback
    noDocumentReloadCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DocumentReloadCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_DocumentReloadCallback`.
    foreign import ccall "wrapper"
        mk_DocumentReloadCallback :: C_DocumentReloadCallback -> IO (FunPtr C_DocumentReloadCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DocumentReload :: DocumentReloadCallback -> IO Closure
    genClosure_DocumentReload cb = do
        let cb' = wrap_DocumentReloadCallback cb
        mk_DocumentReloadCallback cb' >>= newCClosure

    -- | Wrap a `DocumentReloadCallback` into a `C_DocumentReloadCallback`.
    wrap_DocumentReloadCallback ::
        DocumentReloadCallback ->
        C_DocumentReloadCallback
    wrap_DocumentReloadCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@reload@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' document #reload callback
    @
    -}
    onDocumentReload :: (IsDocument a, MonadIO m) => a -> DocumentReloadCallback -> m SignalHandlerId
    onDocumentReload obj cb = liftIO $ do
        let cb' = wrap_DocumentReloadCallback cb
        cb'' <- mk_DocumentReloadCallback cb'
        connectSignalFunPtr obj "reload" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@reload@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' document #reload callback
    @
    -}
    afterDocumentReload :: (IsDocument a, MonadIO m) => a -> DocumentReloadCallback -> m SignalHandlerId
    afterDocumentReload obj cb = liftIO $ do
        let cb' = wrap_DocumentReloadCallback cb
        cb'' <- mk_DocumentReloadCallback cb'
        connectSignalFunPtr obj "reload" cb'' SignalConnectAfter

    #if ENABLE_OVERLOADING
    data DocumentLoadCompleteSignalInfo
    instance SignalInfo DocumentLoadCompleteSignalInfo where
        type HaskellCallbackType DocumentLoadCompleteSignalInfo = DocumentLoadCompleteCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DocumentLoadCompleteCallback cb
            cb'' <- mk_DocumentLoadCompleteCallback cb'
            connectSignalFunPtr obj "load-complete" cb'' connectMode

    data DocumentLoadStoppedSignalInfo
    instance SignalInfo DocumentLoadStoppedSignalInfo where
        type HaskellCallbackType DocumentLoadStoppedSignalInfo = DocumentLoadStoppedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DocumentLoadStoppedCallback cb
            cb'' <- mk_DocumentLoadStoppedCallback cb'
            connectSignalFunPtr obj "load-stopped" cb'' connectMode

    data DocumentPageChangedSignalInfo
    instance SignalInfo DocumentPageChangedSignalInfo where
        type HaskellCallbackType DocumentPageChangedSignalInfo = DocumentPageChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DocumentPageChangedCallback cb
            cb'' <- mk_DocumentPageChangedCallback cb'
            connectSignalFunPtr obj "page-changed" cb'' connectMode

    data DocumentReloadSignalInfo
    instance SignalInfo DocumentReloadSignalInfo where
        type HaskellCallbackType DocumentReloadSignalInfo = DocumentReloadCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DocumentReloadCallback cb
            cb'' <- mk_DocumentReloadCallback cb'
            connectSignalFunPtr obj "reload" cb'' connectMode

    type instance O.SignalList Document = DocumentSignalList
    type DocumentSignalList = ('[ '("loadComplete", DocumentLoadCompleteSignalInfo), '("loadStopped", DocumentLoadStoppedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageChanged", DocumentPageChangedSignalInfo), '("reload", DocumentReloadSignalInfo)] :: [(Symbol, *)])

    #endif

    foreign import ccall "atk_document_get_type"
        c_atk_document_get_type :: IO GType

    instance GObject Document where
        gobjectType _ = c_atk_document_get_type

    -- | Type class for types which can be safely cast to `Document`, for instance with `toDocument`.
    class GObject o => IsDocument o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Document a) =>
        IsDocument a
    #endif
    instance IsDocument Document
    instance GObject.Object.IsObject Document

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

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Document
    type instance O.AttributeList Document = DocumentAttributeList
    type DocumentAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveDocumentMethod (t :: Symbol) (o :: *) :: * where
        ResolveDocumentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveDocumentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveDocumentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveDocumentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveDocumentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveDocumentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveDocumentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveDocumentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveDocumentMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveDocumentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveDocumentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveDocumentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveDocumentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveDocumentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveDocumentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveDocumentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveDocumentMethod "getAttributeValue" o = DocumentGetAttributeValueMethodInfo
        ResolveDocumentMethod "getAttributes" o = DocumentGetAttributesMethodInfo
        ResolveDocumentMethod "getCurrentPageNumber" o = DocumentGetCurrentPageNumberMethodInfo
        ResolveDocumentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveDocumentMethod "getDocument" o = DocumentGetDocumentMethodInfo
        ResolveDocumentMethod "getDocumentType" o = DocumentGetDocumentTypeMethodInfo
        ResolveDocumentMethod "getLocale" o = DocumentGetLocaleMethodInfo
        ResolveDocumentMethod "getPageCount" o = DocumentGetPageCountMethodInfo
        ResolveDocumentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveDocumentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveDocumentMethod "setAttributeValue" o = DocumentSetAttributeValueMethodInfo
        ResolveDocumentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveDocumentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveDocumentMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveDocumentMethod t Document, O.MethodInfo info Document p) => O.IsLabel t (Document -> 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

    -- method Document::get_attribute_value
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string representing the name of the attribute\n  whose value is being queried.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_attribute_value" atk_document_get_attribute_value ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        CString ->                              -- attribute_name : TBasicType TUTF8
        IO CString

    {- |
    Retrieves the value of the given /@attributeName@/ inside /@document@/.

    /Since: 1.12/
    -}
    documentGetAttributeValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}
        -> T.Text
        {- ^ /@attributeName@/: a character string representing the name of the attribute
      whose value is being queried. -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ a string value associated with the named
       attribute for this document, or 'Nothing' if a value for
       /@attributeName@/ has not been specified for this document. -}
    documentGetAttributeValue document attributeName = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        attributeName' <- textToCString attributeName
        result <- atk_document_get_attribute_value document' attributeName'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr document
        freeMem attributeName'
        return maybeResult

    #if ENABLE_OVERLOADING
    data DocumentGetAttributeValueMethodInfo
    instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetAttributeValueMethodInfo a signature where
        overloadedMethod _ = documentGetAttributeValue

    #endif

    -- method Document::get_attributes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGSList (TBasicType TPtr))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_attributes" atk_document_get_attributes ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        IO (Ptr (GSList (Ptr ())))

    {- |
    Gets an AtkAttributeSet which describes document-wide
             attributes as name-value pairs.

    /Since: 1.12/
    -}
    documentGetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}
        -> m ([Ptr ()])
        {- ^ __Returns:__ An AtkAttributeSet containing the explicitly
             set name-value-pair attributes associated with this document
             as a whole. -}
    documentGetAttributes document = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        result <- atk_document_get_attributes document'
        result' <- unpackGSList result
        touchManagedPtr document
        return result'

    #if ENABLE_OVERLOADING
    data DocumentGetAttributesMethodInfo
    instance (signature ~ (m ([Ptr ()])), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetAttributesMethodInfo a signature where
        overloadedMethod _ = documentGetAttributes

    #endif

    -- method Document::get_current_page_number
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_current_page_number" atk_document_get_current_page_number ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        IO Int32

    {- |
    Retrieves the current page number inside /@document@/.

    /Since: 2.12/
    -}
    documentGetCurrentPageNumber ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: the 'GI.Atk.Interfaces.Document.Document' -}
        -> m Int32
        {- ^ __Returns:__ the current page number inside /@document@/, or -1 if
      not implemented, not know by the implementor, or irrelevant. -}
    documentGetCurrentPageNumber document = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        result <- atk_document_get_current_page_number document'
        touchManagedPtr document
        return result

    #if ENABLE_OVERLOADING
    data DocumentGetCurrentPageNumberMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetCurrentPageNumberMethodInfo a signature where
        overloadedMethod _ = documentGetCurrentPageNumber

    #endif

    -- method Document::get_document
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_document" atk_document_get_document ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        IO (Ptr ())

    {-# DEPRECATED documentGetDocument ["Since 2.12. /@document@/ is already a representation of","the document. Use it directly, or one of its children, as an","instance of the DOM."] #-}
    {- |
    Gets a @/gpointer/@ that points to an instance of the DOM.  It is
    up to the caller to check atk_document_get_type to determine
    how to cast this pointer.
    -}
    documentGetDocument ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}
        -> m (Ptr ())
        {- ^ __Returns:__ a @/gpointer/@ that points to an instance of the DOM. -}
    documentGetDocument document = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        result <- atk_document_get_document document'
        touchManagedPtr document
        return result

    #if ENABLE_OVERLOADING
    data DocumentGetDocumentMethodInfo
    instance (signature ~ (m (Ptr ())), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetDocumentMethodInfo a signature where
        overloadedMethod _ = documentGetDocument

    #endif

    -- method Document::get_document_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_document_type" atk_document_get_document_type ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        IO CString

    {-# DEPRECATED documentGetDocumentType ["Since 2.12. Please use 'GI.Atk.Interfaces.Document.documentGetAttributes' to","ask for the document type if it applies."] #-}
    {- |
    Gets a string indicating the document type.
    -}
    documentGetDocumentType ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}
        -> m T.Text
        {- ^ __Returns:__ a string indicating the document type -}
    documentGetDocumentType document = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        result <- atk_document_get_document_type document'
        checkUnexpectedReturnNULL "documentGetDocumentType" result
        result' <- cstringToText result
        touchManagedPtr document
        return result'

    #if ENABLE_OVERLOADING
    data DocumentGetDocumentTypeMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetDocumentTypeMethodInfo a signature where
        overloadedMethod _ = documentGetDocumentType

    #endif

    -- method Document::get_locale
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_locale" atk_document_get_locale ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        IO CString

    {-# DEPRECATED documentGetLocale ["(Since version 2.7.90)","Please use 'GI.Atk.Objects.Object.objectGetObjectLocale' instead."] #-}
    {- |
    Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
             of the content of this document instance.  Individual
             text substrings or images within this document may have
             a different locale, see atk_text_get_attributes and
             atk_image_get_image_locale.
    -}
    documentGetLocale ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}
        -> m T.Text
        {- ^ __Returns:__ a UTF-8 string indicating the POSIX-style LC_MESSAGES
             locale of the document content as a whole, or NULL if
             the document content does not specify a locale. -}
    documentGetLocale document = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        result <- atk_document_get_locale document'
        checkUnexpectedReturnNULL "documentGetLocale" result
        result' <- cstringToText result
        touchManagedPtr document
        return result'

    #if ENABLE_OVERLOADING
    data DocumentGetLocaleMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetLocaleMethodInfo a signature where
        overloadedMethod _ = documentGetLocale

    #endif

    -- method Document::get_page_count
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_document_get_page_count" atk_document_get_page_count ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        IO Int32

    {- |
    Retrieves the total number of pages inside /@document@/.

    /Since: 2.12/
    -}
    documentGetPageCount ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: the 'GI.Atk.Interfaces.Document.Document' -}
        -> m Int32
        {- ^ __Returns:__ total page count of /@document@/, or -1 if not implemented,
      not know by the implementor or irrelevant. -}
    documentGetPageCount document = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        result <- atk_document_get_page_count document'
        touchManagedPtr document
        return result

    #if ENABLE_OVERLOADING
    data DocumentGetPageCountMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPageCountMethodInfo a signature where
        overloadedMethod _ = documentGetPageCount

    #endif

    -- method Document::set_attribute_value
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements #AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string representing the name of the attribute\n  whose value is being set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string value to be associated with @attribute_name.", 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 "atk_document_set_attribute_value" atk_document_set_attribute_value ::
        Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})
        CString ->                              -- attribute_name : TBasicType TUTF8
        CString ->                              -- attribute_value : TBasicType TUTF8
        IO CInt

    {- |
    Sets the value for the given /@attributeName@/ inside /@document@/.

    /Since: 1.12/
    -}
    documentSetAttributeValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>
        a
        {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements 'GI.Atk.Structs.DocumentIface.DocumentIface' -}
        -> T.Text
        {- ^ /@attributeName@/: a character string representing the name of the attribute
      whose value is being set. -}
        -> T.Text
        {- ^ /@attributeValue@/: a string value to be associated with /@attributeName@/. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@attributeValue@/ is successfully associated
      with /@attributeName@/ for this /@document@/, and 'False' if if the
      document does not allow the attribute to be modified -}
    documentSetAttributeValue document attributeName attributeValue = liftIO $ do
        document' <- unsafeManagedPtrCastPtr document
        attributeName' <- textToCString attributeName
        attributeValue' <- textToCString attributeValue
        result <- atk_document_set_attribute_value document' attributeName' attributeValue'
        let result' = (/= 0) result
        touchManagedPtr document
        freeMem attributeName'
        freeMem attributeValue'
        return result'

    #if ENABLE_OVERLOADING
    data DocumentSetAttributeValueMethodInfo
    instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetAttributeValueMethodInfo a signature where
        overloadedMethod _ = documentSetAttributeValue

    #endif