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

    This class is the primary class for accessibility support via the
    Accessibility ToolKit (ATK).  Objects which are instances of
    'GI.Atk.Objects.Object.Object' (or instances of AtkObject-derived types) are queried
    for properties which relate basic (and generic) properties of a UI
    component such as name and description.  Instances of 'GI.Atk.Objects.Object.Object'
    may also be queried as to whether they implement other ATK
    interfaces (e.g. 'GI.Atk.Interfaces.Action.Action', 'GI.Atk.Interfaces.Component.Component', etc.), as appropriate
    to the role which a given UI component plays in a user interface.

    All UI components in an application which provide useful
    information or services to the user must provide corresponding
    'GI.Atk.Objects.Object.Object' instances on request (in GTK+, for instance, usually on
    a call to @/gtk_widget_get_accessible/@ ()), either via ATK support
    built into the toolkit for the widget class or ancestor class, or
    in the case of custom widgets, if the inherited 'GI.Atk.Objects.Object.Object'
    implementation is insufficient, via instances of a new 'GI.Atk.Objects.Object.Object'
    subclass.

    See also: 'GI.Atk.Objects.ObjectFactory.ObjectFactory', 'GI.Atk.Objects.Registry.Registry'.  (GTK+ users see also
    @/GtkAccessible/@).
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Atk.Objects.Object
        (

    -- * Exported types
        Object(..)                              ,
        IsObject                                ,
        toObject                                ,
        noObject                                ,

     -- * Methods
    -- ** addRelationship #method:addRelationship#

    #if ENABLE_OVERLOADING
        ObjectAddRelationshipMethodInfo         ,
    #endif
        objectAddRelationship                   ,

    -- ** getAccessibleId #method:getAccessibleId#

    #if ENABLE_OVERLOADING
        ObjectGetAccessibleIdMethodInfo         ,
    #endif
        objectGetAccessibleId                   ,

    -- ** getAttributes #method:getAttributes#

    #if ENABLE_OVERLOADING
        ObjectGetAttributesMethodInfo           ,
    #endif
        objectGetAttributes                     ,

    -- ** getDescription #method:getDescription#

    #if ENABLE_OVERLOADING
        ObjectGetDescriptionMethodInfo          ,
    #endif
        objectGetDescription                    ,

    -- ** getIndexInParent #method:getIndexInParent#

    #if ENABLE_OVERLOADING
        ObjectGetIndexInParentMethodInfo        ,
    #endif
        objectGetIndexInParent                  ,

    -- ** getLayer #method:getLayer#

    #if ENABLE_OVERLOADING
        ObjectGetLayerMethodInfo                ,
    #endif
        objectGetLayer                          ,

    -- ** getMdiZorder #method:getMdiZorder#

    #if ENABLE_OVERLOADING
        ObjectGetMdiZorderMethodInfo            ,
    #endif
        objectGetMdiZorder                      ,

    -- ** getNAccessibleChildren #method:getNAccessibleChildren#

    #if ENABLE_OVERLOADING
        ObjectGetNAccessibleChildrenMethodInfo  ,
    #endif
        objectGetNAccessibleChildren            ,

    -- ** getName #method:getName#

    #if ENABLE_OVERLOADING
        ObjectGetNameMethodInfo                 ,
    #endif
        objectGetName                           ,

    -- ** getObjectLocale #method:getObjectLocale#

    #if ENABLE_OVERLOADING
        ObjectGetObjectLocaleMethodInfo         ,
    #endif
        objectGetObjectLocale                   ,

    -- ** getParent #method:getParent#

    #if ENABLE_OVERLOADING
        ObjectGetParentMethodInfo               ,
    #endif
        objectGetParent                         ,

    -- ** getRole #method:getRole#

    #if ENABLE_OVERLOADING
        ObjectGetRoleMethodInfo                 ,
    #endif
        objectGetRole                           ,

    -- ** initialize #method:initialize#

    #if ENABLE_OVERLOADING
        ObjectInitializeMethodInfo              ,
    #endif
        objectInitialize                        ,

    -- ** notifyStateChange #method:notifyStateChange#

    #if ENABLE_OVERLOADING
        ObjectNotifyStateChangeMethodInfo       ,
    #endif
        objectNotifyStateChange                 ,

    -- ** peekParent #method:peekParent#

    #if ENABLE_OVERLOADING
        ObjectPeekParentMethodInfo              ,
    #endif
        objectPeekParent                        ,

    -- ** refAccessibleChild #method:refAccessibleChild#

    #if ENABLE_OVERLOADING
        ObjectRefAccessibleChildMethodInfo      ,
    #endif
        objectRefAccessibleChild                ,

    -- ** refRelationSet #method:refRelationSet#

    #if ENABLE_OVERLOADING
        ObjectRefRelationSetMethodInfo          ,
    #endif
        objectRefRelationSet                    ,

    -- ** refStateSet #method:refStateSet#

    #if ENABLE_OVERLOADING
        ObjectRefStateSetMethodInfo             ,
    #endif
        objectRefStateSet                       ,

    -- ** removePropertyChangeHandler #method:removePropertyChangeHandler#

    #if ENABLE_OVERLOADING
        ObjectRemovePropertyChangeHandlerMethodInfo,
    #endif
        objectRemovePropertyChangeHandler       ,

    -- ** removeRelationship #method:removeRelationship#

    #if ENABLE_OVERLOADING
        ObjectRemoveRelationshipMethodInfo      ,
    #endif
        objectRemoveRelationship                ,

    -- ** setAccessibleId #method:setAccessibleId#

    #if ENABLE_OVERLOADING
        ObjectSetAccessibleIdMethodInfo         ,
    #endif
        objectSetAccessibleId                   ,

    -- ** setDescription #method:setDescription#

    #if ENABLE_OVERLOADING
        ObjectSetDescriptionMethodInfo          ,
    #endif
        objectSetDescription                    ,

    -- ** setName #method:setName#

    #if ENABLE_OVERLOADING
        ObjectSetNameMethodInfo                 ,
    #endif
        objectSetName                           ,

    -- ** setParent #method:setParent#

    #if ENABLE_OVERLOADING
        ObjectSetParentMethodInfo               ,
    #endif
        objectSetParent                         ,

    -- ** setRole #method:setRole#

    #if ENABLE_OVERLOADING
        ObjectSetRoleMethodInfo                 ,
    #endif
        objectSetRole                           ,

     -- * Properties
    -- ** accessibleComponentLayer #attr:accessibleComponentLayer#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleComponentLayerPropertyInfo,
    #endif
        getObjectAccessibleComponentLayer       ,
    #if ENABLE_OVERLOADING
        objectAccessibleComponentLayer          ,
    #endif

    -- ** accessibleComponentMdiZorder #attr:accessibleComponentMdiZorder#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleComponentMdiZorderPropertyInfo,
    #endif
        getObjectAccessibleComponentMdiZorder   ,
    #if ENABLE_OVERLOADING
        objectAccessibleComponentMdiZorder      ,
    #endif

    -- ** accessibleDescription #attr:accessibleDescription#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleDescriptionPropertyInfo ,
    #endif
        clearObjectAccessibleDescription        ,
        constructObjectAccessibleDescription    ,
        getObjectAccessibleDescription          ,
    #if ENABLE_OVERLOADING
        objectAccessibleDescription             ,
    #endif
        setObjectAccessibleDescription          ,

    -- ** accessibleHypertextNlinks #attr:accessibleHypertextNlinks#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleHypertextNlinksPropertyInfo,
    #endif
        getObjectAccessibleHypertextNlinks      ,
    #if ENABLE_OVERLOADING
        objectAccessibleHypertextNlinks         ,
    #endif

    -- ** accessibleName #attr:accessibleName#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleNamePropertyInfo        ,
    #endif
        clearObjectAccessibleName               ,
        constructObjectAccessibleName           ,
        getObjectAccessibleName                 ,
    #if ENABLE_OVERLOADING
        objectAccessibleName                    ,
    #endif
        setObjectAccessibleName                 ,

    -- ** accessibleParent #attr:accessibleParent#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleParentPropertyInfo      ,
    #endif
        clearObjectAccessibleParent             ,
        constructObjectAccessibleParent         ,
        getObjectAccessibleParent               ,
    #if ENABLE_OVERLOADING
        objectAccessibleParent                  ,
    #endif
        setObjectAccessibleParent               ,

    -- ** accessibleRole #attr:accessibleRole#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleRolePropertyInfo        ,
    #endif
        constructObjectAccessibleRole           ,
        getObjectAccessibleRole                 ,
    #if ENABLE_OVERLOADING
        objectAccessibleRole                    ,
    #endif
        setObjectAccessibleRole                 ,

    -- ** accessibleTableCaption #attr:accessibleTableCaption#
    {- | Table caption.
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableCaptionPropertyInfo,
    #endif
        clearObjectAccessibleTableCaption       ,
        constructObjectAccessibleTableCaption   ,
        getObjectAccessibleTableCaption         ,
    #if ENABLE_OVERLOADING
        objectAccessibleTableCaption            ,
    #endif
        setObjectAccessibleTableCaption         ,

    -- ** accessibleTableCaptionObject #attr:accessibleTableCaptionObject#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableCaptionObjectPropertyInfo,
    #endif
        clearObjectAccessibleTableCaptionObject ,
        constructObjectAccessibleTableCaptionObject,
        getObjectAccessibleTableCaptionObject   ,
    #if ENABLE_OVERLOADING
        objectAccessibleTableCaptionObject      ,
    #endif
        setObjectAccessibleTableCaptionObject   ,

    -- ** accessibleTableColumnDescription #attr:accessibleTableColumnDescription#
    {- | Accessible table column description.
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableColumnDescriptionPropertyInfo,
    #endif
        clearObjectAccessibleTableColumnDescription,
        constructObjectAccessibleTableColumnDescription,
        getObjectAccessibleTableColumnDescription,
    #if ENABLE_OVERLOADING
        objectAccessibleTableColumnDescription  ,
    #endif
        setObjectAccessibleTableColumnDescription,

    -- ** accessibleTableColumnHeader #attr:accessibleTableColumnHeader#
    {- | Accessible table column header.
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableColumnHeaderPropertyInfo,
    #endif
        clearObjectAccessibleTableColumnHeader  ,
        constructObjectAccessibleTableColumnHeader,
        getObjectAccessibleTableColumnHeader    ,
    #if ENABLE_OVERLOADING
        objectAccessibleTableColumnHeader       ,
    #endif
        setObjectAccessibleTableColumnHeader    ,

    -- ** accessibleTableRowDescription #attr:accessibleTableRowDescription#
    {- | Accessible table row description.
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableRowDescriptionPropertyInfo,
    #endif
        clearObjectAccessibleTableRowDescription,
        constructObjectAccessibleTableRowDescription,
        getObjectAccessibleTableRowDescription  ,
    #if ENABLE_OVERLOADING
        objectAccessibleTableRowDescription     ,
    #endif
        setObjectAccessibleTableRowDescription  ,

    -- ** accessibleTableRowHeader #attr:accessibleTableRowHeader#
    {- | Accessible table row header.
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableRowHeaderPropertyInfo,
    #endif
        clearObjectAccessibleTableRowHeader     ,
        constructObjectAccessibleTableRowHeader ,
        getObjectAccessibleTableRowHeader       ,
    #if ENABLE_OVERLOADING
        objectAccessibleTableRowHeader          ,
    #endif
        setObjectAccessibleTableRowHeader       ,

    -- ** accessibleTableSummary #attr:accessibleTableSummary#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleTableSummaryPropertyInfo,
    #endif
        clearObjectAccessibleTableSummary       ,
        constructObjectAccessibleTableSummary   ,
        getObjectAccessibleTableSummary         ,
    #if ENABLE_OVERLOADING
        objectAccessibleTableSummary            ,
    #endif
        setObjectAccessibleTableSummary         ,

    -- ** accessibleValue #attr:accessibleValue#
    {- | Numeric value of this object, in case being and AtkValue.
    -}
    #if ENABLE_OVERLOADING
        ObjectAccessibleValuePropertyInfo       ,
    #endif
        constructObjectAccessibleValue          ,
        getObjectAccessibleValue                ,
    #if ENABLE_OVERLOADING
        objectAccessibleValue                   ,
    #endif
        setObjectAccessibleValue                ,

     -- * Signals
    -- ** activeDescendantChanged #signal:activeDescendantChanged#

        C_ObjectActiveDescendantChangedCallback ,
        ObjectActiveDescendantChangedCallback   ,
    #if ENABLE_OVERLOADING
        ObjectActiveDescendantChangedSignalInfo ,
    #endif
        afterObjectActiveDescendantChanged      ,
        genClosure_ObjectActiveDescendantChanged,
        mk_ObjectActiveDescendantChangedCallback,
        noObjectActiveDescendantChangedCallback ,
        onObjectActiveDescendantChanged         ,
        wrap_ObjectActiveDescendantChangedCallback,

    -- ** childrenChanged #signal:childrenChanged#

        C_ObjectChildrenChangedCallback         ,
        ObjectChildrenChangedCallback           ,
    #if ENABLE_OVERLOADING
        ObjectChildrenChangedSignalInfo         ,
    #endif
        afterObjectChildrenChanged              ,
        genClosure_ObjectChildrenChanged        ,
        mk_ObjectChildrenChangedCallback        ,
        noObjectChildrenChangedCallback         ,
        onObjectChildrenChanged                 ,
        wrap_ObjectChildrenChangedCallback      ,

    -- ** focusEvent #signal:focusEvent#

        C_ObjectFocusEventCallback              ,
        ObjectFocusEventCallback                ,
    #if ENABLE_OVERLOADING
        ObjectFocusEventSignalInfo              ,
    #endif
        afterObjectFocusEvent                   ,
        genClosure_ObjectFocusEvent             ,
        mk_ObjectFocusEventCallback             ,
        noObjectFocusEventCallback              ,
        onObjectFocusEvent                      ,
        wrap_ObjectFocusEventCallback           ,

    -- ** propertyChange #signal:propertyChange#

        C_ObjectPropertyChangeCallback          ,
        ObjectPropertyChangeCallback            ,
    #if ENABLE_OVERLOADING
        ObjectPropertyChangeSignalInfo          ,
    #endif
        afterObjectPropertyChange               ,
        genClosure_ObjectPropertyChange         ,
        mk_ObjectPropertyChangeCallback         ,
        noObjectPropertyChangeCallback          ,
        onObjectPropertyChange                  ,
        wrap_ObjectPropertyChangeCallback       ,

    -- ** stateChange #signal:stateChange#

        C_ObjectStateChangeCallback             ,
        ObjectStateChangeCallback               ,
    #if ENABLE_OVERLOADING
        ObjectStateChangeSignalInfo             ,
    #endif
        afterObjectStateChange                  ,
        genClosure_ObjectStateChange            ,
        mk_ObjectStateChangeCallback            ,
        noObjectStateChangeCallback             ,
        onObjectStateChange                     ,
        wrap_ObjectStateChangeCallback          ,

    -- ** visibleDataChanged #signal:visibleDataChanged#

        C_ObjectVisibleDataChangedCallback      ,
        ObjectVisibleDataChangedCallback        ,
    #if ENABLE_OVERLOADING
        ObjectVisibleDataChangedSignalInfo      ,
    #endif
        afterObjectVisibleDataChanged           ,
        genClosure_ObjectVisibleDataChanged     ,
        mk_ObjectVisibleDataChangedCallback     ,
        noObjectVisibleDataChangedCallback      ,
        onObjectVisibleDataChanged              ,
        wrap_ObjectVisibleDataChangedCallback   ,

        ) 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 {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
    import {-# SOURCE #-} qualified GI.Atk.Objects.RelationSet as Atk.RelationSet
    import {-# SOURCE #-} qualified GI.Atk.Objects.StateSet as Atk.StateSet
    import {-# SOURCE #-} qualified GI.Atk.Structs.PropertyValues as Atk.PropertyValues
    import qualified GI.GObject.Objects.Object as GObject.Object

    -- | Memory-managed wrapper type.
    newtype Object = Object (ManagedPtr Object)
    foreign import ccall "atk_object_get_type"
        c_atk_object_get_type :: IO GType

    instance GObject Object where
        gobjectType _ = c_atk_object_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `Object`.
    noObject :: Maybe Object
    noObject = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * where
        ResolveObjectMethod "addRelationship" o = ObjectAddRelationshipMethodInfo
        ResolveObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveObjectMethod "initialize" o = ObjectInitializeMethodInfo
        ResolveObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveObjectMethod "notifyStateChange" o = ObjectNotifyStateChangeMethodInfo
        ResolveObjectMethod "peekParent" o = ObjectPeekParentMethodInfo
        ResolveObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveObjectMethod "refAccessibleChild" o = ObjectRefAccessibleChildMethodInfo
        ResolveObjectMethod "refRelationSet" o = ObjectRefRelationSetMethodInfo
        ResolveObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveObjectMethod "refStateSet" o = ObjectRefStateSetMethodInfo
        ResolveObjectMethod "removePropertyChangeHandler" o = ObjectRemovePropertyChangeHandlerMethodInfo
        ResolveObjectMethod "removeRelationship" o = ObjectRemoveRelationshipMethodInfo
        ResolveObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveObjectMethod "getAccessibleId" o = ObjectGetAccessibleIdMethodInfo
        ResolveObjectMethod "getAttributes" o = ObjectGetAttributesMethodInfo
        ResolveObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveObjectMethod "getDescription" o = ObjectGetDescriptionMethodInfo
        ResolveObjectMethod "getIndexInParent" o = ObjectGetIndexInParentMethodInfo
        ResolveObjectMethod "getLayer" o = ObjectGetLayerMethodInfo
        ResolveObjectMethod "getMdiZorder" o = ObjectGetMdiZorderMethodInfo
        ResolveObjectMethod "getNAccessibleChildren" o = ObjectGetNAccessibleChildrenMethodInfo
        ResolveObjectMethod "getName" o = ObjectGetNameMethodInfo
        ResolveObjectMethod "getObjectLocale" o = ObjectGetObjectLocaleMethodInfo
        ResolveObjectMethod "getParent" o = ObjectGetParentMethodInfo
        ResolveObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveObjectMethod "getRole" o = ObjectGetRoleMethodInfo
        ResolveObjectMethod "setAccessibleId" o = ObjectSetAccessibleIdMethodInfo
        ResolveObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveObjectMethod "setDescription" o = ObjectSetDescriptionMethodInfo
        ResolveObjectMethod "setName" o = ObjectSetNameMethodInfo
        ResolveObjectMethod "setParent" o = ObjectSetParentMethodInfo
        ResolveObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveObjectMethod "setRole" o = ObjectSetRoleMethodInfo
        ResolveObjectMethod l o = O.MethodResolutionFailed l o

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

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

    -- signal Object::active-descendant-changed
    {- |
    The \"active-descendant-changed\" signal is emitted by an object
    which has the state ATK_STATE_MANAGES_DESCENDANTS when the focus
    object in the object changes. For instance, a table will emit the
    signal when the cell in the table which has focus changes.
    -}
    type ObjectActiveDescendantChangedCallback =
        Maybe Object
        {- ^ /@arg1@/: the newly focused object. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectActiveDescendantChangedCallback`@.
    noObjectActiveDescendantChangedCallback :: Maybe ObjectActiveDescendantChangedCallback
    noObjectActiveDescendantChangedCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ObjectActiveDescendantChanged :: ObjectActiveDescendantChangedCallback -> IO Closure
    genClosure_ObjectActiveDescendantChanged cb = do
        let cb' = wrap_ObjectActiveDescendantChangedCallback cb
        mk_ObjectActiveDescendantChangedCallback cb' >>= newCClosure

    -- | Wrap a `ObjectActiveDescendantChangedCallback` into a `C_ObjectActiveDescendantChangedCallback`.
    wrap_ObjectActiveDescendantChangedCallback ::
        ObjectActiveDescendantChangedCallback ->
        C_ObjectActiveDescendantChangedCallback
    wrap_ObjectActiveDescendantChangedCallback _cb _ arg1 _ = do
        maybeArg1 <-
            if arg1 == nullPtr
            then return Nothing
            else do
                arg1' <- (newObject Object) arg1
                return $ Just arg1'
        _cb  maybeArg1

    {- |
    Connect a signal handler for the “@active-descendant-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' object #activeDescendantChanged callback
    @
    -}
    onObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> ObjectActiveDescendantChangedCallback -> m SignalHandlerId
    onObjectActiveDescendantChanged obj cb = liftIO $ do
        let cb' = wrap_ObjectActiveDescendantChangedCallback cb
        cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
        connectSignalFunPtr obj "active-descendant-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@active-descendant-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' object #activeDescendantChanged callback
    @
    -}
    afterObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> ObjectActiveDescendantChangedCallback -> m SignalHandlerId
    afterObjectActiveDescendantChanged obj cb = liftIO $ do
        let cb' = wrap_ObjectActiveDescendantChangedCallback cb
        cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
        connectSignalFunPtr obj "active-descendant-changed" cb'' SignalConnectAfter

    -- signal Object::children-changed
    {- |
    The signal \"children-changed\" is emitted when a child is added or
    removed form an object. It supports two details: \"add\" and
    \"remove\"
    -}
    type ObjectChildrenChangedCallback =
        Word32
        {- ^ /@arg1@/: The index of the added or removed child. The value can be
    -1. This is used if the value is not known by the implementor
    when the child is added\/removed or irrelevant. -}
        -> Maybe Object
        {- ^ /@arg2@/: A gpointer to the child AtkObject which was added or
    removed. If the child was removed, it is possible that it is not
    available for the implementor. In that case this pointer can be
    NULL. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectChildrenChangedCallback`@.
    noObjectChildrenChangedCallback :: Maybe ObjectChildrenChangedCallback
    noObjectChildrenChangedCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ObjectChildrenChanged :: ObjectChildrenChangedCallback -> IO Closure
    genClosure_ObjectChildrenChanged cb = do
        let cb' = wrap_ObjectChildrenChangedCallback cb
        mk_ObjectChildrenChangedCallback cb' >>= newCClosure

    -- | Wrap a `ObjectChildrenChangedCallback` into a `C_ObjectChildrenChangedCallback`.
    wrap_ObjectChildrenChangedCallback ::
        ObjectChildrenChangedCallback ->
        C_ObjectChildrenChangedCallback
    wrap_ObjectChildrenChangedCallback _cb _ arg1 arg2 _ = do
        maybeArg2 <-
            if arg2 == nullPtr
            then return Nothing
            else do
                arg2' <- (newObject Object) arg2
                return $ Just arg2'
        _cb  arg1 maybeArg2

    {- |
    Connect a signal handler for the “@children-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' object #childrenChanged callback
    @
    -}
    onObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> ObjectChildrenChangedCallback -> m SignalHandlerId
    onObjectChildrenChanged obj cb = liftIO $ do
        let cb' = wrap_ObjectChildrenChangedCallback cb
        cb'' <- mk_ObjectChildrenChangedCallback cb'
        connectSignalFunPtr obj "children-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@children-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' object #childrenChanged callback
    @
    -}
    afterObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> ObjectChildrenChangedCallback -> m SignalHandlerId
    afterObjectChildrenChanged obj cb = liftIO $ do
        let cb' = wrap_ObjectChildrenChangedCallback cb
        cb'' <- mk_ObjectChildrenChangedCallback cb'
        connectSignalFunPtr obj "children-changed" cb'' SignalConnectAfter

    -- signal Object::focus-event
    {-# DEPRECATED ObjectFocusEventCallback ["(Since version 2.9.4)","Use the 'GI.Atk.Objects.Object.Object'::@/state-change/@ signal instead."] #-}
    {- |
    The signal \"focus-event\" is emitted when an object gained or lost
    focus.
    -}
    type ObjectFocusEventCallback =
        Bool
        {- ^ /@arg1@/: a boolean value which indicates whether the object gained
    or lost focus. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectFocusEventCallback`@.
    noObjectFocusEventCallback :: Maybe ObjectFocusEventCallback
    noObjectFocusEventCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ObjectFocusEvent :: ObjectFocusEventCallback -> IO Closure
    genClosure_ObjectFocusEvent cb = do
        let cb' = wrap_ObjectFocusEventCallback cb
        mk_ObjectFocusEventCallback cb' >>= newCClosure

    -- | Wrap a `ObjectFocusEventCallback` into a `C_ObjectFocusEventCallback`.
    wrap_ObjectFocusEventCallback ::
        ObjectFocusEventCallback ->
        C_ObjectFocusEventCallback
    wrap_ObjectFocusEventCallback _cb _ arg1 _ = do
        let arg1' = (/= 0) arg1
        _cb  arg1'

    {- |
    Connect a signal handler for the “@focus-event@” 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' object #focusEvent callback
    @
    -}
    onObjectFocusEvent :: (IsObject a, MonadIO m) => a -> ObjectFocusEventCallback -> m SignalHandlerId
    onObjectFocusEvent obj cb = liftIO $ do
        let cb' = wrap_ObjectFocusEventCallback cb
        cb'' <- mk_ObjectFocusEventCallback cb'
        connectSignalFunPtr obj "focus-event" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@focus-event@” 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' object #focusEvent callback
    @
    -}
    afterObjectFocusEvent :: (IsObject a, MonadIO m) => a -> ObjectFocusEventCallback -> m SignalHandlerId
    afterObjectFocusEvent obj cb = liftIO $ do
        let cb' = wrap_ObjectFocusEventCallback cb
        cb'' <- mk_ObjectFocusEventCallback cb'
        connectSignalFunPtr obj "focus-event" cb'' SignalConnectAfter

    -- signal Object::property-change
    {- |
    The signal \"property-change\" is emitted when an object\'s property
    value changes. /@arg1@/ contains an 'GI.Atk.Structs.PropertyValues.PropertyValues' with the name
    and the new value of the property whose value has changed. Note
    that, as with GObject notify, getting this signal does not
    guarantee that the value of the property has actually changed; it
    may also be emitted when the setter of the property is called to
    reinstate the previous value.

    Toolkit implementor note: ATK implementors should use
    'GI.GObject.Objects.Object.objectNotify' to emit property-changed
    notifications. 'GI.Atk.Objects.Object.Object'::@/property-changed/@ is needed by the
    implementation of @/atk_add_global_event_listener()/@ because GObject
    notify doesn\'t support emission hooks.
    -}
    type ObjectPropertyChangeCallback =
        Maybe Atk.PropertyValues.PropertyValues
        {- ^ /@arg1@/: an 'GI.Atk.Structs.PropertyValues.PropertyValues' containing the new
    value of the property which changed. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectPropertyChangeCallback`@.
    noObjectPropertyChangeCallback :: Maybe ObjectPropertyChangeCallback
    noObjectPropertyChangeCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ObjectPropertyChange :: ObjectPropertyChangeCallback -> IO Closure
    genClosure_ObjectPropertyChange cb = do
        let cb' = wrap_ObjectPropertyChangeCallback cb
        mk_ObjectPropertyChangeCallback cb' >>= newCClosure

    -- | Wrap a `ObjectPropertyChangeCallback` into a `C_ObjectPropertyChangeCallback`.
    wrap_ObjectPropertyChangeCallback ::
        ObjectPropertyChangeCallback ->
        C_ObjectPropertyChangeCallback
    wrap_ObjectPropertyChangeCallback _cb _ arg1 _ = do
        maybeArg1 <-
            if arg1 == nullPtr
            then return Nothing
            else do
                arg1' <- (newPtr Atk.PropertyValues.PropertyValues) arg1
                return $ Just arg1'
        _cb  maybeArg1

    {- |
    Connect a signal handler for the “@property-change@” 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' object #propertyChange callback
    @
    -}
    onObjectPropertyChange :: (IsObject a, MonadIO m) => a -> ObjectPropertyChangeCallback -> m SignalHandlerId
    onObjectPropertyChange obj cb = liftIO $ do
        let cb' = wrap_ObjectPropertyChangeCallback cb
        cb'' <- mk_ObjectPropertyChangeCallback cb'
        connectSignalFunPtr obj "property-change" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@property-change@” 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' object #propertyChange callback
    @
    -}
    afterObjectPropertyChange :: (IsObject a, MonadIO m) => a -> ObjectPropertyChangeCallback -> m SignalHandlerId
    afterObjectPropertyChange obj cb = liftIO $ do
        let cb' = wrap_ObjectPropertyChangeCallback cb
        cb'' <- mk_ObjectPropertyChangeCallback cb'
        connectSignalFunPtr obj "property-change" cb'' SignalConnectAfter

    -- signal Object::state-change
    {- |
    The \"state-change\" signal is emitted when an object\'s state
    changes.  The detail value identifies the state type which has
    changed.
    -}
    type ObjectStateChangeCallback =
        T.Text
        {- ^ /@arg1@/: The name of the state which has changed -}
        -> Bool
        {- ^ /@arg2@/: A boolean which indicates whether the state has been set or unset. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectStateChangeCallback`@.
    noObjectStateChangeCallback :: Maybe ObjectStateChangeCallback
    noObjectStateChangeCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ObjectStateChange :: ObjectStateChangeCallback -> IO Closure
    genClosure_ObjectStateChange cb = do
        let cb' = wrap_ObjectStateChangeCallback cb
        mk_ObjectStateChangeCallback cb' >>= newCClosure

    -- | Wrap a `ObjectStateChangeCallback` into a `C_ObjectStateChangeCallback`.
    wrap_ObjectStateChangeCallback ::
        ObjectStateChangeCallback ->
        C_ObjectStateChangeCallback
    wrap_ObjectStateChangeCallback _cb _ arg1 arg2 _ = do
        arg1' <- cstringToText arg1
        let arg2' = (/= 0) arg2
        _cb  arg1' arg2'

    {- |
    Connect a signal handler for the “@state-change@” 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' object #stateChange callback
    @
    -}
    onObjectStateChange :: (IsObject a, MonadIO m) => a -> ObjectStateChangeCallback -> m SignalHandlerId
    onObjectStateChange obj cb = liftIO $ do
        let cb' = wrap_ObjectStateChangeCallback cb
        cb'' <- mk_ObjectStateChangeCallback cb'
        connectSignalFunPtr obj "state-change" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@state-change@” 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' object #stateChange callback
    @
    -}
    afterObjectStateChange :: (IsObject a, MonadIO m) => a -> ObjectStateChangeCallback -> m SignalHandlerId
    afterObjectStateChange obj cb = liftIO $ do
        let cb' = wrap_ObjectStateChangeCallback cb
        cb'' <- mk_ObjectStateChangeCallback cb'
        connectSignalFunPtr obj "state-change" cb'' SignalConnectAfter

    -- signal Object::visible-data-changed
    {- |
    The \"visible-data-changed\" signal is emitted when the visual
    appearance of the object changed.
    -}
    type ObjectVisibleDataChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectVisibleDataChangedCallback`@.
    noObjectVisibleDataChangedCallback :: Maybe ObjectVisibleDataChangedCallback
    noObjectVisibleDataChangedCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ObjectVisibleDataChanged :: ObjectVisibleDataChangedCallback -> IO Closure
    genClosure_ObjectVisibleDataChanged cb = do
        let cb' = wrap_ObjectVisibleDataChangedCallback cb
        mk_ObjectVisibleDataChangedCallback cb' >>= newCClosure

    -- | Wrap a `ObjectVisibleDataChangedCallback` into a `C_ObjectVisibleDataChangedCallback`.
    wrap_ObjectVisibleDataChangedCallback ::
        ObjectVisibleDataChangedCallback ->
        C_ObjectVisibleDataChangedCallback
    wrap_ObjectVisibleDataChangedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@visible-data-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' object #visibleDataChanged callback
    @
    -}
    onObjectVisibleDataChanged :: (IsObject a, MonadIO m) => a -> ObjectVisibleDataChangedCallback -> m SignalHandlerId
    onObjectVisibleDataChanged obj cb = liftIO $ do
        let cb' = wrap_ObjectVisibleDataChangedCallback cb
        cb'' <- mk_ObjectVisibleDataChangedCallback cb'
        connectSignalFunPtr obj "visible-data-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@visible-data-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' object #visibleDataChanged callback
    @
    -}
    afterObjectVisibleDataChanged :: (IsObject a, MonadIO m) => a -> ObjectVisibleDataChangedCallback -> m SignalHandlerId
    afterObjectVisibleDataChanged obj cb = liftIO $ do
        let cb' = wrap_ObjectVisibleDataChangedCallback cb
        cb'' <- mk_ObjectVisibleDataChangedCallback cb'
        connectSignalFunPtr obj "visible-data-changed" cb'' SignalConnectAfter

    -- VVV Prop "accessible-component-layer"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleComponentLayer
    @
    -}
    getObjectAccessibleComponentLayer :: (MonadIO m, IsObject o) => o -> m Int32
    getObjectAccessibleComponentLayer obj = liftIO $ getObjectPropertyInt32 obj "accessible-component-layer"

    #if ENABLE_OVERLOADING
    data ObjectAccessibleComponentLayerPropertyInfo
    instance AttrInfo ObjectAccessibleComponentLayerPropertyInfo where
        type AttrAllowedOps ObjectAccessibleComponentLayerPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = (~) ()
        type AttrBaseTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleComponentLayerPropertyInfo = Int32
        type AttrLabel ObjectAccessibleComponentLayerPropertyInfo = "accessible-component-layer"
        type AttrOrigin ObjectAccessibleComponentLayerPropertyInfo = Object
        attrGet _ = getObjectAccessibleComponentLayer
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "accessible-component-mdi-zorder"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleComponentMdiZorder
    @
    -}
    getObjectAccessibleComponentMdiZorder :: (MonadIO m, IsObject o) => o -> m Int32
    getObjectAccessibleComponentMdiZorder obj = liftIO $ getObjectPropertyInt32 obj "accessible-component-mdi-zorder"

    #if ENABLE_OVERLOADING
    data ObjectAccessibleComponentMdiZorderPropertyInfo
    instance AttrInfo ObjectAccessibleComponentMdiZorderPropertyInfo where
        type AttrAllowedOps ObjectAccessibleComponentMdiZorderPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = (~) ()
        type AttrBaseTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo = Int32
        type AttrLabel ObjectAccessibleComponentMdiZorderPropertyInfo = "accessible-component-mdi-zorder"
        type AttrOrigin ObjectAccessibleComponentMdiZorderPropertyInfo = Object
        attrGet _ = getObjectAccessibleComponentMdiZorder
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "accessible-description"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleDescription
    @
    -}
    getObjectAccessibleDescription :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
    getObjectAccessibleDescription obj = liftIO $ getObjectPropertyString obj "accessible-description"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleDescription 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleDescription :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleDescription obj val = liftIO $ setObjectPropertyString obj "accessible-description" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleDescription :: (IsObject o) => T.Text -> IO (GValueConstruct o)
    constructObjectAccessibleDescription val = constructObjectPropertyString "accessible-description" (Just val)

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

    @
    'Data.GI.Base.Attributes.clear' #accessibleDescription
    @
    -}
    clearObjectAccessibleDescription :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleDescription obj = liftIO $ setObjectPropertyString obj "accessible-description" (Nothing :: Maybe T.Text)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleDescriptionPropertyInfo
    instance AttrInfo ObjectAccessibleDescriptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleDescriptionPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleDescriptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleDescriptionPropertyInfo = "accessible-description"
        type AttrOrigin ObjectAccessibleDescriptionPropertyInfo = Object
        attrGet _ = getObjectAccessibleDescription
        attrSet _ = setObjectAccessibleDescription
        attrConstruct _ = constructObjectAccessibleDescription
        attrClear _ = clearObjectAccessibleDescription
    #endif

    -- VVV Prop "accessible-hypertext-nlinks"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleHypertextNlinks
    @
    -}
    getObjectAccessibleHypertextNlinks :: (MonadIO m, IsObject o) => o -> m Int32
    getObjectAccessibleHypertextNlinks obj = liftIO $ getObjectPropertyInt32 obj "accessible-hypertext-nlinks"

    #if ENABLE_OVERLOADING
    data ObjectAccessibleHypertextNlinksPropertyInfo
    instance AttrInfo ObjectAccessibleHypertextNlinksPropertyInfo where
        type AttrAllowedOps ObjectAccessibleHypertextNlinksPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = (~) ()
        type AttrBaseTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo = Int32
        type AttrLabel ObjectAccessibleHypertextNlinksPropertyInfo = "accessible-hypertext-nlinks"
        type AttrOrigin ObjectAccessibleHypertextNlinksPropertyInfo = Object
        attrGet _ = getObjectAccessibleHypertextNlinks
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "accessible-name"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleName
    @
    -}
    getObjectAccessibleName :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
    getObjectAccessibleName obj = liftIO $ getObjectPropertyString obj "accessible-name"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleName 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleName :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleName obj val = liftIO $ setObjectPropertyString obj "accessible-name" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleName :: (IsObject o) => T.Text -> IO (GValueConstruct o)
    constructObjectAccessibleName val = constructObjectPropertyString "accessible-name" (Just val)

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

    @
    'Data.GI.Base.Attributes.clear' #accessibleName
    @
    -}
    clearObjectAccessibleName :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleName obj = liftIO $ setObjectPropertyString obj "accessible-name" (Nothing :: Maybe T.Text)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleNamePropertyInfo
    instance AttrInfo ObjectAccessibleNamePropertyInfo where
        type AttrAllowedOps ObjectAccessibleNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleNamePropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo = IsObject
        type AttrGetType ObjectAccessibleNamePropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleNamePropertyInfo = "accessible-name"
        type AttrOrigin ObjectAccessibleNamePropertyInfo = Object
        attrGet _ = getObjectAccessibleName
        attrSet _ = setObjectAccessibleName
        attrConstruct _ = constructObjectAccessibleName
        attrClear _ = clearObjectAccessibleName
    #endif

    -- VVV Prop "accessible-parent"
       -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleParent
    @
    -}
    getObjectAccessibleParent :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
    getObjectAccessibleParent obj = liftIO $ getObjectPropertyObject obj "accessible-parent" Object

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleParent 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleParent :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
    setObjectAccessibleParent obj val = liftIO $ setObjectPropertyObject obj "accessible-parent" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-parent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleParent :: (IsObject o, IsObject a) => a -> IO (GValueConstruct o)
    constructObjectAccessibleParent val = constructObjectPropertyObject "accessible-parent" (Just val)

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

    @
    'Data.GI.Base.Attributes.clear' #accessibleParent
    @
    -}
    clearObjectAccessibleParent :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleParent obj = liftIO $ setObjectPropertyObject obj "accessible-parent" (Nothing :: Maybe Object)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleParentPropertyInfo
    instance AttrInfo ObjectAccessibleParentPropertyInfo where
        type AttrAllowedOps ObjectAccessibleParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
        type AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleParentPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleParentPropertyInfo = "accessible-parent"
        type AttrOrigin ObjectAccessibleParentPropertyInfo = Object
        attrGet _ = getObjectAccessibleParent
        attrSet _ = setObjectAccessibleParent
        attrConstruct _ = constructObjectAccessibleParent
        attrClear _ = clearObjectAccessibleParent
    #endif

    -- VVV Prop "accessible-role"
       -- Type: TInterface (Name {namespace = "Atk", name = "Role"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleRole
    @
    -}
    getObjectAccessibleRole :: (MonadIO m, IsObject o) => o -> m Atk.Enums.Role
    getObjectAccessibleRole obj = liftIO $ getObjectPropertyEnum obj "accessible-role"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleRole 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleRole :: (MonadIO m, IsObject o) => o -> Atk.Enums.Role -> m ()
    setObjectAccessibleRole obj val = liftIO $ setObjectPropertyEnum obj "accessible-role" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-role@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleRole :: (IsObject o) => Atk.Enums.Role -> IO (GValueConstruct o)
    constructObjectAccessibleRole val = constructObjectPropertyEnum "accessible-role" val

    #if ENABLE_OVERLOADING
    data ObjectAccessibleRolePropertyInfo
    instance AttrInfo ObjectAccessibleRolePropertyInfo where
        type AttrAllowedOps ObjectAccessibleRolePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint ObjectAccessibleRolePropertyInfo = (~) Atk.Enums.Role
        type AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo = IsObject
        type AttrGetType ObjectAccessibleRolePropertyInfo = Atk.Enums.Role
        type AttrLabel ObjectAccessibleRolePropertyInfo = "accessible-role"
        type AttrOrigin ObjectAccessibleRolePropertyInfo = Object
        attrGet _ = getObjectAccessibleRole
        attrSet _ = setObjectAccessibleRole
        attrConstruct _ = constructObjectAccessibleRole
        attrClear _ = undefined
    #endif

    -- VVV Prop "accessible-table-caption"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableCaption
    @
    -}
    getObjectAccessibleTableCaption :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
    getObjectAccessibleTableCaption obj = liftIO $ getObjectPropertyString obj "accessible-table-caption"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableCaption 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableCaption :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleTableCaption obj val = liftIO $ setObjectPropertyString obj "accessible-table-caption" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-caption@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableCaption :: (IsObject o) => T.Text -> IO (GValueConstruct o)
    constructObjectAccessibleTableCaption val = constructObjectPropertyString "accessible-table-caption" (Just val)

    {- |
    Set the value of the “@accessible-table-caption@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableCaption
    @
    -}
    clearObjectAccessibleTableCaption :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableCaption obj = liftIO $ setObjectPropertyString obj "accessible-table-caption" (Nothing :: Maybe T.Text)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableCaptionPropertyInfo
    instance AttrInfo ObjectAccessibleTableCaptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableCaptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableCaptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleTableCaptionPropertyInfo = "accessible-table-caption"
        type AttrOrigin ObjectAccessibleTableCaptionPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableCaption
        attrSet _ = setObjectAccessibleTableCaption
        attrConstruct _ = constructObjectAccessibleTableCaption
        attrClear _ = clearObjectAccessibleTableCaption
    #endif

    -- VVV Prop "accessible-table-caption-object"
       -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableCaptionObject
    @
    -}
    getObjectAccessibleTableCaptionObject :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
    getObjectAccessibleTableCaptionObject obj = liftIO $ getObjectPropertyObject obj "accessible-table-caption-object" Object

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableCaptionObject 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableCaptionObject :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
    setObjectAccessibleTableCaptionObject obj val = liftIO $ setObjectPropertyObject obj "accessible-table-caption-object" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-caption-object@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableCaptionObject :: (IsObject o, IsObject a) => a -> IO (GValueConstruct o)
    constructObjectAccessibleTableCaptionObject val = constructObjectPropertyObject "accessible-table-caption-object" (Just val)

    {- |
    Set the value of the “@accessible-table-caption-object@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableCaptionObject
    @
    -}
    clearObjectAccessibleTableCaptionObject :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableCaptionObject obj = liftIO $ setObjectPropertyObject obj "accessible-table-caption-object" (Nothing :: Maybe Object)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableCaptionObjectPropertyInfo
    instance AttrInfo ObjectAccessibleTableCaptionObjectPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableCaptionObjectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
        type AttrBaseTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableCaptionObjectPropertyInfo = "accessible-table-caption-object"
        type AttrOrigin ObjectAccessibleTableCaptionObjectPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableCaptionObject
        attrSet _ = setObjectAccessibleTableCaptionObject
        attrConstruct _ = constructObjectAccessibleTableCaptionObject
        attrClear _ = clearObjectAccessibleTableCaptionObject
    #endif

    -- VVV Prop "accessible-table-column-description"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableColumnDescription
    @
    -}
    getObjectAccessibleTableColumnDescription :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
    getObjectAccessibleTableColumnDescription obj = liftIO $ getObjectPropertyString obj "accessible-table-column-description"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableColumnDescription 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableColumnDescription :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleTableColumnDescription obj val = liftIO $ setObjectPropertyString obj "accessible-table-column-description" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-column-description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableColumnDescription :: (IsObject o) => T.Text -> IO (GValueConstruct o)
    constructObjectAccessibleTableColumnDescription val = constructObjectPropertyString "accessible-table-column-description" (Just val)

    {- |
    Set the value of the “@accessible-table-column-description@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableColumnDescription
    @
    -}
    clearObjectAccessibleTableColumnDescription :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableColumnDescription obj = liftIO $ setObjectPropertyString obj "accessible-table-column-description" (Nothing :: Maybe T.Text)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableColumnDescriptionPropertyInfo
    instance AttrInfo ObjectAccessibleTableColumnDescriptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableColumnDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleTableColumnDescriptionPropertyInfo = "accessible-table-column-description"
        type AttrOrigin ObjectAccessibleTableColumnDescriptionPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableColumnDescription
        attrSet _ = setObjectAccessibleTableColumnDescription
        attrConstruct _ = constructObjectAccessibleTableColumnDescription
        attrClear _ = clearObjectAccessibleTableColumnDescription
    #endif

    -- VVV Prop "accessible-table-column-header"
       -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableColumnHeader
    @
    -}
    getObjectAccessibleTableColumnHeader :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
    getObjectAccessibleTableColumnHeader obj = liftIO $ getObjectPropertyObject obj "accessible-table-column-header" Object

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableColumnHeader 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableColumnHeader :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
    setObjectAccessibleTableColumnHeader obj val = liftIO $ setObjectPropertyObject obj "accessible-table-column-header" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-column-header@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableColumnHeader :: (IsObject o, IsObject a) => a -> IO (GValueConstruct o)
    constructObjectAccessibleTableColumnHeader val = constructObjectPropertyObject "accessible-table-column-header" (Just val)

    {- |
    Set the value of the “@accessible-table-column-header@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableColumnHeader
    @
    -}
    clearObjectAccessibleTableColumnHeader :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableColumnHeader obj = liftIO $ setObjectPropertyObject obj "accessible-table-column-header" (Nothing :: Maybe Object)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableColumnHeaderPropertyInfo
    instance AttrInfo ObjectAccessibleTableColumnHeaderPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableColumnHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
        type AttrBaseTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableColumnHeaderPropertyInfo = "accessible-table-column-header"
        type AttrOrigin ObjectAccessibleTableColumnHeaderPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableColumnHeader
        attrSet _ = setObjectAccessibleTableColumnHeader
        attrConstruct _ = constructObjectAccessibleTableColumnHeader
        attrClear _ = clearObjectAccessibleTableColumnHeader
    #endif

    -- VVV Prop "accessible-table-row-description"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableRowDescription
    @
    -}
    getObjectAccessibleTableRowDescription :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
    getObjectAccessibleTableRowDescription obj = liftIO $ getObjectPropertyString obj "accessible-table-row-description"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableRowDescription 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableRowDescription :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleTableRowDescription obj val = liftIO $ setObjectPropertyString obj "accessible-table-row-description" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-row-description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableRowDescription :: (IsObject o) => T.Text -> IO (GValueConstruct o)
    constructObjectAccessibleTableRowDescription val = constructObjectPropertyString "accessible-table-row-description" (Just val)

    {- |
    Set the value of the “@accessible-table-row-description@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableRowDescription
    @
    -}
    clearObjectAccessibleTableRowDescription :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableRowDescription obj = liftIO $ setObjectPropertyString obj "accessible-table-row-description" (Nothing :: Maybe T.Text)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableRowDescriptionPropertyInfo
    instance AttrInfo ObjectAccessibleTableRowDescriptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableRowDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleTableRowDescriptionPropertyInfo = "accessible-table-row-description"
        type AttrOrigin ObjectAccessibleTableRowDescriptionPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableRowDescription
        attrSet _ = setObjectAccessibleTableRowDescription
        attrConstruct _ = constructObjectAccessibleTableRowDescription
        attrClear _ = clearObjectAccessibleTableRowDescription
    #endif

    -- VVV Prop "accessible-table-row-header"
       -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableRowHeader
    @
    -}
    getObjectAccessibleTableRowHeader :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
    getObjectAccessibleTableRowHeader obj = liftIO $ getObjectPropertyObject obj "accessible-table-row-header" Object

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableRowHeader 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableRowHeader :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
    setObjectAccessibleTableRowHeader obj val = liftIO $ setObjectPropertyObject obj "accessible-table-row-header" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-row-header@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableRowHeader :: (IsObject o, IsObject a) => a -> IO (GValueConstruct o)
    constructObjectAccessibleTableRowHeader val = constructObjectPropertyObject "accessible-table-row-header" (Just val)

    {- |
    Set the value of the “@accessible-table-row-header@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableRowHeader
    @
    -}
    clearObjectAccessibleTableRowHeader :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableRowHeader obj = liftIO $ setObjectPropertyObject obj "accessible-table-row-header" (Nothing :: Maybe Object)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableRowHeaderPropertyInfo
    instance AttrInfo ObjectAccessibleTableRowHeaderPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableRowHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
        type AttrBaseTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableRowHeaderPropertyInfo = "accessible-table-row-header"
        type AttrOrigin ObjectAccessibleTableRowHeaderPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableRowHeader
        attrSet _ = setObjectAccessibleTableRowHeader
        attrConstruct _ = constructObjectAccessibleTableRowHeader
        attrClear _ = clearObjectAccessibleTableRowHeader
    #endif

    -- VVV Prop "accessible-table-summary"
       -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleTableSummary
    @
    -}
    getObjectAccessibleTableSummary :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
    getObjectAccessibleTableSummary obj = liftIO $ getObjectPropertyObject obj "accessible-table-summary" Object

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleTableSummary 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleTableSummary :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
    setObjectAccessibleTableSummary obj val = liftIO $ setObjectPropertyObject obj "accessible-table-summary" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-table-summary@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleTableSummary :: (IsObject o, IsObject a) => a -> IO (GValueConstruct o)
    constructObjectAccessibleTableSummary val = constructObjectPropertyObject "accessible-table-summary" (Just val)

    {- |
    Set the value of the “@accessible-table-summary@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #accessibleTableSummary
    @
    -}
    clearObjectAccessibleTableSummary :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableSummary obj = liftIO $ setObjectPropertyObject obj "accessible-table-summary" (Nothing :: Maybe Object)

    #if ENABLE_OVERLOADING
    data ObjectAccessibleTableSummaryPropertyInfo
    instance AttrInfo ObjectAccessibleTableSummaryPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableSummaryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
        type AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
        type AttrGetType ObjectAccessibleTableSummaryPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableSummaryPropertyInfo = "accessible-table-summary"
        type AttrOrigin ObjectAccessibleTableSummaryPropertyInfo = Object
        attrGet _ = getObjectAccessibleTableSummary
        attrSet _ = setObjectAccessibleTableSummary
        attrConstruct _ = constructObjectAccessibleTableSummary
        attrClear _ = clearObjectAccessibleTableSummary
    #endif

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

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

    @
    'Data.GI.Base.Attributes.get' object #accessibleValue
    @
    -}
    getObjectAccessibleValue :: (MonadIO m, IsObject o) => o -> m Double
    getObjectAccessibleValue obj = liftIO $ getObjectPropertyDouble obj "accessible-value"

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

    @
    'Data.GI.Base.Attributes.set' object [ #accessibleValue 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setObjectAccessibleValue :: (MonadIO m, IsObject o) => o -> Double -> m ()
    setObjectAccessibleValue obj val = liftIO $ setObjectPropertyDouble obj "accessible-value" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@accessible-value@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructObjectAccessibleValue :: (IsObject o) => Double -> IO (GValueConstruct o)
    constructObjectAccessibleValue val = constructObjectPropertyDouble "accessible-value" val

    #if ENABLE_OVERLOADING
    data ObjectAccessibleValuePropertyInfo
    instance AttrInfo ObjectAccessibleValuePropertyInfo where
        type AttrAllowedOps ObjectAccessibleValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint ObjectAccessibleValuePropertyInfo = (~) Double
        type AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo = IsObject
        type AttrGetType ObjectAccessibleValuePropertyInfo = Double
        type AttrLabel ObjectAccessibleValuePropertyInfo = "accessible-value"
        type AttrOrigin ObjectAccessibleValuePropertyInfo = Object
        attrGet _ = getObjectAccessibleValue
        attrSet _ = setObjectAccessibleValue
        attrConstruct _ = constructObjectAccessibleValue
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Object
    type instance O.AttributeList Object = ObjectAttributeList
    type ObjectAttributeList = ('[ '("accessibleComponentLayer", ObjectAccessibleComponentLayerPropertyInfo), '("accessibleComponentMdiZorder", ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessibleDescription", ObjectAccessibleDescriptionPropertyInfo), '("accessibleHypertextNlinks", ObjectAccessibleHypertextNlinksPropertyInfo), '("accessibleName", ObjectAccessibleNamePropertyInfo), '("accessibleParent", ObjectAccessibleParentPropertyInfo), '("accessibleRole", ObjectAccessibleRolePropertyInfo), '("accessibleTableCaption", ObjectAccessibleTableCaptionPropertyInfo), '("accessibleTableCaptionObject", ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessibleTableColumnDescription", ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessibleTableColumnHeader", ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessibleTableRowDescription", ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessibleTableRowHeader", ObjectAccessibleTableRowHeaderPropertyInfo), '("accessibleTableSummary", ObjectAccessibleTableSummaryPropertyInfo), '("accessibleValue", ObjectAccessibleValuePropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    objectAccessibleComponentLayer :: AttrLabelProxy "accessibleComponentLayer"
    objectAccessibleComponentLayer = AttrLabelProxy

    objectAccessibleComponentMdiZorder :: AttrLabelProxy "accessibleComponentMdiZorder"
    objectAccessibleComponentMdiZorder = AttrLabelProxy

    objectAccessibleDescription :: AttrLabelProxy "accessibleDescription"
    objectAccessibleDescription = AttrLabelProxy

    objectAccessibleHypertextNlinks :: AttrLabelProxy "accessibleHypertextNlinks"
    objectAccessibleHypertextNlinks = AttrLabelProxy

    objectAccessibleName :: AttrLabelProxy "accessibleName"
    objectAccessibleName = AttrLabelProxy

    objectAccessibleParent :: AttrLabelProxy "accessibleParent"
    objectAccessibleParent = AttrLabelProxy

    objectAccessibleRole :: AttrLabelProxy "accessibleRole"
    objectAccessibleRole = AttrLabelProxy

    objectAccessibleTableCaption :: AttrLabelProxy "accessibleTableCaption"
    objectAccessibleTableCaption = AttrLabelProxy

    objectAccessibleTableCaptionObject :: AttrLabelProxy "accessibleTableCaptionObject"
    objectAccessibleTableCaptionObject = AttrLabelProxy

    objectAccessibleTableColumnDescription :: AttrLabelProxy "accessibleTableColumnDescription"
    objectAccessibleTableColumnDescription = AttrLabelProxy

    objectAccessibleTableColumnHeader :: AttrLabelProxy "accessibleTableColumnHeader"
    objectAccessibleTableColumnHeader = AttrLabelProxy

    objectAccessibleTableRowDescription :: AttrLabelProxy "accessibleTableRowDescription"
    objectAccessibleTableRowDescription = AttrLabelProxy

    objectAccessibleTableRowHeader :: AttrLabelProxy "accessibleTableRowHeader"
    objectAccessibleTableRowHeader = AttrLabelProxy

    objectAccessibleTableSummary :: AttrLabelProxy "accessibleTableSummary"
    objectAccessibleTableSummary = AttrLabelProxy

    objectAccessibleValue :: AttrLabelProxy "accessibleValue"
    objectAccessibleValue = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    data ObjectActiveDescendantChangedSignalInfo
    instance SignalInfo ObjectActiveDescendantChangedSignalInfo where
        type HaskellCallbackType ObjectActiveDescendantChangedSignalInfo = ObjectActiveDescendantChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ObjectActiveDescendantChangedCallback cb
            cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
            connectSignalFunPtr obj "active-descendant-changed" cb'' connectMode

    data ObjectChildrenChangedSignalInfo
    instance SignalInfo ObjectChildrenChangedSignalInfo where
        type HaskellCallbackType ObjectChildrenChangedSignalInfo = ObjectChildrenChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ObjectChildrenChangedCallback cb
            cb'' <- mk_ObjectChildrenChangedCallback cb'
            connectSignalFunPtr obj "children-changed" cb'' connectMode

    data ObjectFocusEventSignalInfo
    instance SignalInfo ObjectFocusEventSignalInfo where
        type HaskellCallbackType ObjectFocusEventSignalInfo = ObjectFocusEventCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ObjectFocusEventCallback cb
            cb'' <- mk_ObjectFocusEventCallback cb'
            connectSignalFunPtr obj "focus-event" cb'' connectMode

    data ObjectPropertyChangeSignalInfo
    instance SignalInfo ObjectPropertyChangeSignalInfo where
        type HaskellCallbackType ObjectPropertyChangeSignalInfo = ObjectPropertyChangeCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ObjectPropertyChangeCallback cb
            cb'' <- mk_ObjectPropertyChangeCallback cb'
            connectSignalFunPtr obj "property-change" cb'' connectMode

    data ObjectStateChangeSignalInfo
    instance SignalInfo ObjectStateChangeSignalInfo where
        type HaskellCallbackType ObjectStateChangeSignalInfo = ObjectStateChangeCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ObjectStateChangeCallback cb
            cb'' <- mk_ObjectStateChangeCallback cb'
            connectSignalFunPtr obj "state-change" cb'' connectMode

    data ObjectVisibleDataChangedSignalInfo
    instance SignalInfo ObjectVisibleDataChangedSignalInfo where
        type HaskellCallbackType ObjectVisibleDataChangedSignalInfo = ObjectVisibleDataChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ObjectVisibleDataChangedCallback cb
            cb'' <- mk_ObjectVisibleDataChangedCallback cb'
            connectSignalFunPtr obj "visible-data-changed" cb'' connectMode

    type instance O.SignalList Object = ObjectSignalList
    type ObjectSignalList = ('[ '("activeDescendantChanged", ObjectActiveDescendantChangedSignalInfo), '("childrenChanged", ObjectChildrenChangedSignalInfo), '("focusEvent", ObjectFocusEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", ObjectPropertyChangeSignalInfo), '("stateChange", ObjectStateChangeSignalInfo), '("visibleDataChanged", ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, *)])

    #endif

    -- method Object::add_relationship
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkObject to which an AtkRelation is to be added.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relationship", argType = TInterface (Name {namespace = "Atk", name = "RelationType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkRelationType of the relation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkObject which is to be the target of the relation.", 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_object_add_relationship" atk_object_add_relationship ::
        Ptr Object ->                           -- object : TInterface (Name {namespace = "Atk", name = "Object"})
        CUInt ->                                -- relationship : TInterface (Name {namespace = "Atk", name = "RelationType"})
        Ptr Object ->                           -- target : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CInt

    {- |
    Adds a relationship of the specified type with the specified target.
    -}
    objectAddRelationship ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
        a
        {- ^ /@object@/: The 'GI.Atk.Objects.Object.Object' to which an AtkRelation is to be added. -}
        -> Atk.Enums.RelationType
        {- ^ /@relationship@/: The 'GI.Atk.Enums.RelationType' of the relation -}
        -> b
        {- ^ /@target@/: The 'GI.Atk.Objects.Object.Object' which is to be the target of the relation. -}
        -> m Bool
        {- ^ __Returns:__ TRUE if the relationship is added. -}
    objectAddRelationship object relationship target = liftIO $ do
        object' <- unsafeManagedPtrCastPtr object
        let relationship' = (fromIntegral . fromEnum) relationship
        target' <- unsafeManagedPtrCastPtr target
        result <- atk_object_add_relationship object' relationship' target'
        let result' = (/= 0) result
        touchManagedPtr object
        touchManagedPtr target
        return result'

    #if ENABLE_OVERLOADING
    data ObjectAddRelationshipMethodInfo
    instance (signature ~ (Atk.Enums.RelationType -> b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectAddRelationshipMethodInfo a signature where
        overloadedMethod _ = objectAddRelationship

    #endif

    -- method Object::get_accessible_id
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_accessible_id" atk_object_get_accessible_id ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CString

    {- |
    Gets the accessible id of the accessible.

    /Since: 2.34/
    -}
    objectGetAccessibleId ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m T.Text
        {- ^ __Returns:__ a character string representing the accessible id of the object, or
    NULL if no such string was set. -}
    objectGetAccessibleId accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_accessible_id accessible'
        checkUnexpectedReturnNULL "objectGetAccessibleId" result
        result' <- cstringToText result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetAccessibleIdMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetAccessibleIdMethodInfo a signature where
        overloadedMethod _ = objectGetAccessibleId

    #endif

    -- method Object::get_attributes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #AtkObject.", 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_object_get_attributes" atk_object_get_attributes ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO (Ptr (GSList (Ptr ())))

    {- |
    Get a list of properties applied to this object as a whole, as an @/AtkAttributeSet/@ consisting of
    name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
    as distinct from strongly-typed object data available via other get\/set methods.
    Not all objects have explicit \"name-value pair\" @/AtkAttributeSet/@ properties.

    /Since: 1.12/
    -}
    objectGetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: An 'GI.Atk.Objects.Object.Object'. -}
        -> m ([Ptr ()])
        {- ^ __Returns:__ an @/AtkAttributeSet/@ consisting of all
    explicit properties\/annotations applied to the object, or an empty
    set if the object has no name-value pair attributes assigned to
    it. This @/atkattributeset/@ should be freed by a call to
    'GI.Atk.Functions.attributeSetFree'. -}
    objectGetAttributes accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_attributes accessible'
        result' <- unpackGSList result
        g_slist_free result
        touchManagedPtr accessible
        return result'

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

    #endif

    -- method Object::get_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_description" atk_object_get_description ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CString

    {- |
    Gets the accessible description of the accessible.
    -}
    objectGetDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m T.Text
        {- ^ __Returns:__ a character string representing the accessible description
    of the accessible. -}
    objectGetDescription accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_description accessible'
        checkUnexpectedReturnNULL "objectGetDescription" result
        result' <- cstringToText result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetDescriptionMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetDescriptionMethodInfo a signature where
        overloadedMethod _ = objectGetDescription

    #endif

    -- method Object::get_index_in_parent
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_index_in_parent" atk_object_get_index_in_parent ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO Int32

    {- |
    Gets the 0-based index of this accessible in its parent; returns -1 if the
    accessible does not have an accessible parent.
    -}
    objectGetIndexInParent ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Int32
        {- ^ __Returns:__ an integer which is the index of the accessible in its parent -}
    objectGetIndexInParent accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_index_in_parent accessible'
        touchManagedPtr accessible
        return result

    #if ENABLE_OVERLOADING
    data ObjectGetIndexInParentMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.MethodInfo ObjectGetIndexInParentMethodInfo a signature where
        overloadedMethod _ = objectGetIndexInParent

    #endif

    -- method Object::get_layer
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Layer"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_get_layer" atk_object_get_layer ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CUInt

    {-# DEPRECATED objectGetLayer ["Use atk_component_get_layer instead."] #-}
    {- |
    Gets the layer of the accessible.
    -}
    objectGetLayer ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Atk.Enums.Layer
        {- ^ __Returns:__ an 'GI.Atk.Enums.Layer' which is the layer of the accessible -}
    objectGetLayer accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_layer accessible'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetLayerMethodInfo
    instance (signature ~ (m Atk.Enums.Layer), MonadIO m, IsObject a) => O.MethodInfo ObjectGetLayerMethodInfo a signature where
        overloadedMethod _ = objectGetLayer

    #endif

    -- method Object::get_mdi_zorder
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_mdi_zorder" atk_object_get_mdi_zorder ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO Int32

    {-# DEPRECATED objectGetMdiZorder ["Use atk_component_get_mdi_zorder instead."] #-}
    {- |
    Gets the zorder of the accessible. The value G_MININT will be returned
    if the layer of the accessible is not ATK_LAYER_MDI.
    -}
    objectGetMdiZorder ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Int32
        {- ^ __Returns:__ a gint which is the zorder of the accessible, i.e. the depth at
    which the component is shown in relation to other components in the same
    container. -}
    objectGetMdiZorder accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_mdi_zorder accessible'
        touchManagedPtr accessible
        return result

    #if ENABLE_OVERLOADING
    data ObjectGetMdiZorderMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.MethodInfo ObjectGetMdiZorderMethodInfo a signature where
        overloadedMethod _ = objectGetMdiZorder

    #endif

    -- method Object::get_n_accessible_children
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_n_accessible_children" atk_object_get_n_accessible_children ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO Int32

    {- |
    Gets the number of accessible children of the accessible.
    -}
    objectGetNAccessibleChildren ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Int32
        {- ^ __Returns:__ an integer representing the number of accessible children
    of the accessible. -}
    objectGetNAccessibleChildren accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_n_accessible_children accessible'
        touchManagedPtr accessible
        return result

    #if ENABLE_OVERLOADING
    data ObjectGetNAccessibleChildrenMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.MethodInfo ObjectGetNAccessibleChildrenMethodInfo a signature where
        overloadedMethod _ = objectGetNAccessibleChildren

    #endif

    -- method Object::get_name
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_name" atk_object_get_name ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CString

    {- |
    Gets the accessible name of the accessible.
    -}
    objectGetName ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m T.Text
        {- ^ __Returns:__ a character string representing the accessible name of the object. -}
    objectGetName accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_name accessible'
        checkUnexpectedReturnNULL "objectGetName" result
        result' <- cstringToText result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetNameMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetNameMethodInfo a signature where
        overloadedMethod _ = objectGetName

    #endif

    -- method Object::get_object_locale
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", 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_object_get_object_locale" atk_object_get_object_locale ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CString

    {- |
    Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
    of /@accessible@/.

    /Since: 2.8/
    -}
    objectGetObjectLocale ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m T.Text
        {- ^ __Returns:__ a UTF-8 string indicating the POSIX-style LC_MESSAGES
             locale of /@accessible@/. -}
    objectGetObjectLocale accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_object_locale accessible'
        checkUnexpectedReturnNULL "objectGetObjectLocale" result
        result' <- cstringToText result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetObjectLocaleMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetObjectLocaleMethodInfo a signature where
        overloadedMethod _ = objectGetObjectLocale

    #endif

    -- method Object::get_parent
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_get_parent" atk_object_get_parent ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO (Ptr Object)

    {- |
    Gets the accessible parent of the accessible. By default this is
    the one assigned with 'GI.Atk.Objects.Object.objectSetParent', but it is assumed
    that ATK implementors have ways to get the parent of the object
    without the need of assigning it manually with
    'GI.Atk.Objects.Object.objectSetParent', and will return it with this method.

    If you are only interested on the parent assigned with
    'GI.Atk.Objects.Object.objectSetParent', use 'GI.Atk.Objects.Object.objectPeekParent'.
    -}
    objectGetParent ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Object
        {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the accessible
    parent of the accessible -}
    objectGetParent accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_parent accessible'
        checkUnexpectedReturnNULL "objectGetParent" result
        result' <- (newObject Object) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetParentMethodInfo
    instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectGetParentMethodInfo a signature where
        overloadedMethod _ = objectGetParent

    #endif

    -- method Object::get_role
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Role"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_get_role" atk_object_get_role ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CUInt

    {- |
    Gets the role of the accessible.
    -}
    objectGetRole ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Atk.Enums.Role
        {- ^ __Returns:__ an 'GI.Atk.Enums.Role' which is the role of the accessible -}
    objectGetRole accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_get_role accessible'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectGetRoleMethodInfo
    instance (signature ~ (m Atk.Enums.Role), MonadIO m, IsObject a) => O.MethodInfo ObjectGetRoleMethodInfo a signature where
        overloadedMethod _ = objectGetRole

    #endif

    -- method Object::initialize
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #gpointer which identifies the object for which the AtkObject was created.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_initialize" atk_object_initialize ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO ()

    {- |
    This function is called when implementing subclasses of 'GI.Atk.Objects.Object.Object'.
    It does initialization required for the new object. It is intended
    that this function should called only in the ...@/_new()/@ functions used
    to create an instance of a subclass of 'GI.Atk.Objects.Object.Object'
    -}
    objectInitialize ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: a 'GI.Atk.Objects.Object.Object' -}
        -> Ptr ()
        {- ^ /@data@/: a @/gpointer/@ which identifies the object for which the AtkObject was created. -}
        -> m ()
    objectInitialize accessible data_ = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        atk_object_initialize accessible' data_
        touchManagedPtr accessible
        return ()

    #if ENABLE_OVERLOADING
    data ObjectInitializeMethodInfo
    instance (signature ~ (Ptr () -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectInitializeMethodInfo a signature where
        overloadedMethod _ = objectInitialize

    #endif

    -- method Object::notify_state_change
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkState whose state is changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a gboolean which indicates whether the state is being set on or off", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_notify_state_change" atk_object_notify_state_change ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        Word64 ->                               -- state : TBasicType TUInt64
        CInt ->                                 -- value : TBasicType TBoolean
        IO ()

    {- |
    Emits a state-change signal for the specified state.

    Note that as a general rule when the state of an existing object changes,
    emitting a notification is expected.
    -}
    objectNotifyStateChange ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> Word64
        {- ^ /@state@/: an @/AtkState/@ whose state is changed -}
        -> Bool
        {- ^ /@value@/: a gboolean which indicates whether the state is being set on or off -}
        -> m ()
    objectNotifyStateChange accessible state value = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        let value' = (fromIntegral . fromEnum) value
        atk_object_notify_state_change accessible' state value'
        touchManagedPtr accessible
        return ()

    #if ENABLE_OVERLOADING
    data ObjectNotifyStateChangeMethodInfo
    instance (signature ~ (Word64 -> Bool -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectNotifyStateChangeMethodInfo a signature where
        overloadedMethod _ = objectNotifyStateChange

    #endif

    -- method Object::peek_parent
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_peek_parent" atk_object_peek_parent ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO (Ptr Object)

    {- |
    Gets the accessible parent of the accessible, if it has been
    manually assigned with atk_object_set_parent. Otherwise, this
    function returns 'Nothing'.

    This method is intended as an utility for ATK implementors, and not
    to be exposed to accessible tools. See 'GI.Atk.Objects.Object.objectGetParent' for
    further reference.
    -}
    objectPeekParent ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Object
        {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the accessible
    parent of the accessible if assigned -}
    objectPeekParent accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_peek_parent accessible'
        checkUnexpectedReturnNULL "objectPeekParent" result
        result' <- (newObject Object) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectPeekParentMethodInfo
    instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectPeekParentMethodInfo a signature where
        overloadedMethod _ = objectPeekParent

    #endif

    -- method Object::ref_accessible_child
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a gint representing the position of the child, starting from 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_ref_accessible_child" atk_object_ref_accessible_child ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        Int32 ->                                -- i : TBasicType TInt
        IO (Ptr Object)

    {- |
    Gets a reference to the specified accessible child of the object.
    The accessible children are 0-based so the first accessible child is
    at index 0, the second at index 1 and so on.
    -}
    objectRefAccessibleChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> Int32
        {- ^ /@i@/: a gint representing the position of the child, starting from 0 -}
        -> m Object
        {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the specified
    accessible child of the accessible. -}
    objectRefAccessibleChild accessible i = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_ref_accessible_child accessible' i
        checkUnexpectedReturnNULL "objectRefAccessibleChild" result
        result' <- (wrapObject Object) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectRefAccessibleChildMethodInfo
    instance (signature ~ (Int32 -> m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectRefAccessibleChildMethodInfo a signature where
        overloadedMethod _ = objectRefAccessibleChild

    #endif

    -- method Object::ref_relation_set
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "RelationSet"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_ref_relation_set" atk_object_ref_relation_set ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO (Ptr Atk.RelationSet.RelationSet)

    {- |
    Gets the 'GI.Atk.Objects.RelationSet.RelationSet' associated with the object.
    -}
    objectRefRelationSet ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Atk.RelationSet.RelationSet
        {- ^ __Returns:__ an 'GI.Atk.Objects.RelationSet.RelationSet' representing the relation set
    of the object. -}
    objectRefRelationSet accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_ref_relation_set accessible'
        checkUnexpectedReturnNULL "objectRefRelationSet" result
        result' <- (wrapObject Atk.RelationSet.RelationSet) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectRefRelationSetMethodInfo
    instance (signature ~ (m Atk.RelationSet.RelationSet), MonadIO m, IsObject a) => O.MethodInfo ObjectRefRelationSetMethodInfo a signature where
        overloadedMethod _ = objectRefRelationSet

    #endif

    -- method Object::ref_state_set
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Atk", name = "StateSet"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_ref_state_set" atk_object_ref_state_set ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        IO (Ptr Atk.StateSet.StateSet)

    {- |
    Gets a reference to the state set of the accessible; the caller must
    unreference it when it is no longer needed.
    -}
    objectRefStateSet ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> m Atk.StateSet.StateSet
        {- ^ __Returns:__ a reference to an 'GI.Atk.Objects.StateSet.StateSet' which is the state
    set of the accessible -}
    objectRefStateSet accessible = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        result <- atk_object_ref_state_set accessible'
        checkUnexpectedReturnNULL "objectRefStateSet" result
        result' <- (wrapObject Atk.StateSet.StateSet) result
        touchManagedPtr accessible
        return result'

    #if ENABLE_OVERLOADING
    data ObjectRefStateSetMethodInfo
    instance (signature ~ (m Atk.StateSet.StateSet), MonadIO m, IsObject a) => O.MethodInfo ObjectRefStateSetMethodInfo a signature where
        overloadedMethod _ = objectRefStateSet

    #endif

    -- method Object::remove_property_change_handler
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a guint which identifies the handler to be removed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_remove_property_change_handler" atk_object_remove_property_change_handler ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        Word32 ->                               -- handler_id : TBasicType TUInt
        IO ()

    {-# DEPRECATED objectRemovePropertyChangeHandler ["(Since version 2.12)","See @/atk_object_connect_property_change_handler()/@"] #-}
    {- |
    Removes a property change handler.
    -}
    objectRemovePropertyChangeHandler ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> Word32
        {- ^ /@handlerId@/: a guint which identifies the handler to be removed. -}
        -> m ()
    objectRemovePropertyChangeHandler accessible handlerId = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        atk_object_remove_property_change_handler accessible' handlerId
        touchManagedPtr accessible
        return ()

    #if ENABLE_OVERLOADING
    data ObjectRemovePropertyChangeHandlerMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectRemovePropertyChangeHandlerMethodInfo a signature where
        overloadedMethod _ = objectRemovePropertyChangeHandler

    #endif

    -- method Object::remove_relationship
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkObject from which an AtkRelation is to be removed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relationship", argType = TInterface (Name {namespace = "Atk", name = "RelationType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkRelationType of the relation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkObject which is the target of the relation to be removed.", 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_object_remove_relationship" atk_object_remove_relationship ::
        Ptr Object ->                           -- object : TInterface (Name {namespace = "Atk", name = "Object"})
        CUInt ->                                -- relationship : TInterface (Name {namespace = "Atk", name = "RelationType"})
        Ptr Object ->                           -- target : TInterface (Name {namespace = "Atk", name = "Object"})
        IO CInt

    {- |
    Removes a relationship of the specified type with the specified target.
    -}
    objectRemoveRelationship ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
        a
        {- ^ /@object@/: The 'GI.Atk.Objects.Object.Object' from which an AtkRelation is to be removed. -}
        -> Atk.Enums.RelationType
        {- ^ /@relationship@/: The 'GI.Atk.Enums.RelationType' of the relation -}
        -> b
        {- ^ /@target@/: The 'GI.Atk.Objects.Object.Object' which is the target of the relation to be removed. -}
        -> m Bool
        {- ^ __Returns:__ TRUE if the relationship is removed. -}
    objectRemoveRelationship object relationship target = liftIO $ do
        object' <- unsafeManagedPtrCastPtr object
        let relationship' = (fromIntegral . fromEnum) relationship
        target' <- unsafeManagedPtrCastPtr target
        result <- atk_object_remove_relationship object' relationship' target'
        let result' = (/= 0) result
        touchManagedPtr object
        touchManagedPtr target
        return result'

    #if ENABLE_OVERLOADING
    data ObjectRemoveRelationshipMethodInfo
    instance (signature ~ (Atk.Enums.RelationType -> b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectRemoveRelationshipMethodInfo a signature where
        overloadedMethod _ = objectRemoveRelationship

    #endif

    -- method Object::set_accessible_id
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string to be set as the accessible id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_set_accessible_id" atk_object_set_accessible_id ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        CString ->                              -- name : TBasicType TUTF8
        IO ()

    {- |
    Sets the accessible ID of the accessible.  This is not meant to be presented
    to the user, but to be an ID which is stable over application development.
    Typically, this is the gtkbuilder ID. Such an ID will be available for
    instance to identify a given well-known accessible object for tailored screen
    reading, or for automatic regression testing.

    /Since: 2.34/
    -}
    objectSetAccessibleId ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> T.Text
        {- ^ /@name@/: a character string to be set as the accessible id -}
        -> m ()
    objectSetAccessibleId accessible name = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        name' <- textToCString name
        atk_object_set_accessible_id accessible' name'
        touchManagedPtr accessible
        freeMem name'
        return ()

    #if ENABLE_OVERLOADING
    data ObjectSetAccessibleIdMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetAccessibleIdMethodInfo a signature where
        overloadedMethod _ = objectSetAccessibleId

    #endif

    -- method Object::set_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string to be set as the accessible description", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_set_description" atk_object_set_description ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        CString ->                              -- description : TBasicType TUTF8
        IO ()

    {- |
    Sets the accessible description of the accessible. You can\'t set
    the description to NULL. This is reserved for the initial value. In
    this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
    the name to a empty value you can use \"\".
    -}
    objectSetDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> T.Text
        {- ^ /@description@/: a character string to be set as the accessible description -}
        -> m ()
    objectSetDescription accessible description = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        description' <- textToCString description
        atk_object_set_description accessible' description'
        touchManagedPtr accessible
        freeMem description'
        return ()

    #if ENABLE_OVERLOADING
    data ObjectSetDescriptionMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetDescriptionMethodInfo a signature where
        overloadedMethod _ = objectSetDescription

    #endif

    -- method Object::set_name
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string to be set as the accessible name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_set_name" atk_object_set_name ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        CString ->                              -- name : TBasicType TUTF8
        IO ()

    {- |
    Sets the accessible name of the accessible. You can\'t set the name
    to NULL. This is reserved for the initial value. In this aspect
    NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
    a empty value you can use \"\".
    -}
    objectSetName ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> T.Text
        {- ^ /@name@/: a character string to be set as the accessible name -}
        -> m ()
    objectSetName accessible name = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        name' <- textToCString name
        atk_object_set_name accessible' name'
        touchManagedPtr accessible
        freeMem name'
        return ()

    #if ENABLE_OVERLOADING
    data ObjectSetNameMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetNameMethodInfo a signature where
        overloadedMethod _ = objectSetName

    #endif

    -- method Object::set_parent
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject to be set as the accessible parent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_set_parent" atk_object_set_parent ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        Ptr Object ->                           -- parent : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    {- |
    Sets the accessible parent of the accessible. /@parent@/ can be NULL.
    -}
    objectSetParent ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> b
        {- ^ /@parent@/: an 'GI.Atk.Objects.Object.Object' to be set as the accessible parent -}
        -> m ()
    objectSetParent accessible parent = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        parent' <- unsafeManagedPtrCastPtr parent
        atk_object_set_parent accessible' parent'
        touchManagedPtr accessible
        touchManagedPtr parent
        return ()

    #if ENABLE_OVERLOADING
    data ObjectSetParentMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectSetParentMethodInfo a signature where
        overloadedMethod _ = objectSetParent

    #endif

    -- method Object::set_role
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "role", argType = TInterface (Name {namespace = "Atk", name = "Role"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkRole to be set as the role", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_object_set_role" atk_object_set_role ::
        Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
        CUInt ->                                -- role : TInterface (Name {namespace = "Atk", name = "Role"})
        IO ()

    {- |
    Sets the role of the accessible.
    -}
    objectSetRole ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
        -> Atk.Enums.Role
        {- ^ /@role@/: an 'GI.Atk.Enums.Role' to be set as the role -}
        -> m ()
    objectSetRole accessible role = liftIO $ do
        accessible' <- unsafeManagedPtrCastPtr accessible
        let role' = (fromIntegral . fromEnum) role
        atk_object_set_role accessible' role'
        touchManagedPtr accessible
        return ()

    #if ENABLE_OVERLOADING
    data ObjectSetRoleMethodInfo
    instance (signature ~ (Atk.Enums.Role -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetRoleMethodInfo a signature where
        overloadedMethod _ = objectSetRole

    #endif