    {-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The base object class for the Accessibility Toolkit API.
    --
    -- This class is the primary class for accessibility support via the
    -- Accessibility ToolKit (ATK).  Objects which are instances of
    -- t'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 t'GI.Atk.Objects.Object.Object'
    -- may also be queried as to whether they implement other ATK
    -- interfaces (e.g. t'GI.Atk.Interfaces.Action.Action', t'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
    -- t'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 t'GI.Atk.Objects.Object.Object'
    -- implementation is insufficient, via instances of a new t'GI.Atk.Objects.Object.Object'
    -- subclass.
    --
    -- See [class/@atkObjectFactory@/], [class/@atkRegistry@/].  (GTK+ users see also
    -- @/GtkAccessible/@).

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Atk.Objects.Object
        (

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

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [addRelationship]("GI.Atk.Objects.Object#g:method:addRelationship"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [initialize]("GI.Atk.Objects.Object#g:method:initialize"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [notifyStateChange]("GI.Atk.Objects.Object#g:method:notifyStateChange"), [peekParent]("GI.Atk.Objects.Object#g:method:peekParent"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refAccessibleChild]("GI.Atk.Objects.Object#g:method:refAccessibleChild"), [refRelationSet]("GI.Atk.Objects.Object#g:method:refRelationSet"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [refStateSet]("GI.Atk.Objects.Object#g:method:refStateSet"), [removePropertyChangeHandler]("GI.Atk.Objects.Object#g:method:removePropertyChangeHandler"), [removeRelationship]("GI.Atk.Objects.Object#g:method:removeRelationship"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAccessibleId]("GI.Atk.Objects.Object#g:method:getAccessibleId"), [getAttributes]("GI.Atk.Objects.Object#g:method:getAttributes"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDescription]("GI.Atk.Objects.Object#g:method:getDescription"), [getHelpText]("GI.Atk.Objects.Object#g:method:getHelpText"), [getIndexInParent]("GI.Atk.Objects.Object#g:method:getIndexInParent"), [getLayer]("GI.Atk.Objects.Object#g:method:getLayer"), [getMdiZorder]("GI.Atk.Objects.Object#g:method:getMdiZorder"), [getNAccessibleChildren]("GI.Atk.Objects.Object#g:method:getNAccessibleChildren"), [getName]("GI.Atk.Objects.Object#g:method:getName"), [getObjectLocale]("GI.Atk.Objects.Object#g:method:getObjectLocale"), [getParent]("GI.Atk.Objects.Object#g:method:getParent"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRole]("GI.Atk.Objects.Object#g:method:getRole").
    --
    -- ==== Setters
    -- [setAccessibleId]("GI.Atk.Objects.Object#g:method:setAccessibleId"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDescription]("GI.Atk.Objects.Object#g:method:setDescription"), [setHelpText]("GI.Atk.Objects.Object#g:method:setHelpText"), [setName]("GI.Atk.Objects.Object#g:method:setName"), [setParent]("GI.Atk.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRole]("GI.Atk.Objects.Object#g:method:setRole").

    #if defined(ENABLE_OVERLOADING)
        ResolveObjectMethod                     ,
    #endif

    -- ** addRelationship #method:addRelationship#

    #if defined(ENABLE_OVERLOADING)
        ObjectAddRelationshipMethodInfo         ,
    #endif
        objectAddRelationship                   ,

    -- ** getAccessibleId #method:getAccessibleId#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetAccessibleIdMethodInfo         ,
    #endif
        objectGetAccessibleId                   ,

    -- ** getAttributes #method:getAttributes#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetAttributesMethodInfo           ,
    #endif
        objectGetAttributes                     ,

    -- ** getDescription #method:getDescription#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetDescriptionMethodInfo          ,
    #endif
        objectGetDescription                    ,

    -- ** getHelpText #method:getHelpText#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetHelpTextMethodInfo             ,
    #endif
        objectGetHelpText                       ,

    -- ** getIndexInParent #method:getIndexInParent#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetIndexInParentMethodInfo        ,
    #endif
        objectGetIndexInParent                  ,

    -- ** getLayer #method:getLayer#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetLayerMethodInfo                ,
    #endif
        objectGetLayer                          ,

    -- ** getMdiZorder #method:getMdiZorder#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetMdiZorderMethodInfo            ,
    #endif
        objectGetMdiZorder                      ,

    -- ** getNAccessibleChildren #method:getNAccessibleChildren#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetNAccessibleChildrenMethodInfo  ,
    #endif
        objectGetNAccessibleChildren            ,

    -- ** getName #method:getName#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetNameMethodInfo                 ,
    #endif
        objectGetName                           ,

    -- ** getObjectLocale #method:getObjectLocale#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetObjectLocaleMethodInfo         ,
    #endif
        objectGetObjectLocale                   ,

    -- ** getParent #method:getParent#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetParentMethodInfo               ,
    #endif
        objectGetParent                         ,

    -- ** getRole #method:getRole#

    #if defined(ENABLE_OVERLOADING)
        ObjectGetRoleMethodInfo                 ,
    #endif
        objectGetRole                           ,

    -- ** initialize #method:initialize#

    #if defined(ENABLE_OVERLOADING)
        ObjectInitializeMethodInfo              ,
    #endif
        objectInitialize                        ,

    -- ** notifyStateChange #method:notifyStateChange#

    #if defined(ENABLE_OVERLOADING)
        ObjectNotifyStateChangeMethodInfo       ,
    #endif
        objectNotifyStateChange                 ,

    -- ** peekParent #method:peekParent#

    #if defined(ENABLE_OVERLOADING)
        ObjectPeekParentMethodInfo              ,
    #endif
        objectPeekParent                        ,

    -- ** refAccessibleChild #method:refAccessibleChild#

    #if defined(ENABLE_OVERLOADING)
        ObjectRefAccessibleChildMethodInfo      ,
    #endif
        objectRefAccessibleChild                ,

    -- ** refRelationSet #method:refRelationSet#

    #if defined(ENABLE_OVERLOADING)
        ObjectRefRelationSetMethodInfo          ,
    #endif
        objectRefRelationSet                    ,

    -- ** refStateSet #method:refStateSet#

    #if defined(ENABLE_OVERLOADING)
        ObjectRefStateSetMethodInfo             ,
    #endif
        objectRefStateSet                       ,

    -- ** removePropertyChangeHandler #method:removePropertyChangeHandler#

    #if defined(ENABLE_OVERLOADING)
        ObjectRemovePropertyChangeHandlerMethodInfo,
    #endif
        objectRemovePropertyChangeHandler       ,

    -- ** removeRelationship #method:removeRelationship#

    #if defined(ENABLE_OVERLOADING)
        ObjectRemoveRelationshipMethodInfo      ,
    #endif
        objectRemoveRelationship                ,

    -- ** setAccessibleId #method:setAccessibleId#

    #if defined(ENABLE_OVERLOADING)
        ObjectSetAccessibleIdMethodInfo         ,
    #endif
        objectSetAccessibleId                   ,

    -- ** setDescription #method:setDescription#

    #if defined(ENABLE_OVERLOADING)
        ObjectSetDescriptionMethodInfo          ,
    #endif
        objectSetDescription                    ,

    -- ** setHelpText #method:setHelpText#

    #if defined(ENABLE_OVERLOADING)
        ObjectSetHelpTextMethodInfo             ,
    #endif
        objectSetHelpText                       ,

    -- ** setName #method:setName#

    #if defined(ENABLE_OVERLOADING)
        ObjectSetNameMethodInfo                 ,
    #endif
        objectSetName                           ,

    -- ** setParent #method:setParent#

    #if defined(ENABLE_OVERLOADING)
        ObjectSetParentMethodInfo               ,
    #endif
        objectSetParent                         ,

    -- ** setRole #method:setRole#

    #if defined(ENABLE_OVERLOADING)
        ObjectSetRoleMethodInfo                 ,
    #endif
        objectSetRole                           ,

     -- * Properties

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleComponentLayerPropertyInfo,
    #endif
        getObjectAccessibleComponentLayer       ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleComponentLayer          ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleComponentMdiZorderPropertyInfo,
    #endif
        getObjectAccessibleComponentMdiZorder   ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleComponentMdiZorder      ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleDescriptionPropertyInfo ,
    #endif
        clearObjectAccessibleDescription        ,
        constructObjectAccessibleDescription    ,
        getObjectAccessibleDescription          ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleDescription             ,
    #endif
        setObjectAccessibleDescription          ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleHelpTextPropertyInfo    ,
    #endif
        clearObjectAccessibleHelpText           ,
        constructObjectAccessibleHelpText       ,
        getObjectAccessibleHelpText             ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleHelpText                ,
    #endif
        setObjectAccessibleHelpText             ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleHypertextNlinksPropertyInfo,
    #endif
        getObjectAccessibleHypertextNlinks      ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleHypertextNlinks         ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleIdPropertyInfo          ,
    #endif
        constructObjectAccessibleId             ,
        getObjectAccessibleId                   ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleId                      ,
    #endif
        setObjectAccessibleId                   ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleNamePropertyInfo        ,
    #endif
        clearObjectAccessibleName               ,
        constructObjectAccessibleName           ,
        getObjectAccessibleName                 ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleName                    ,
    #endif
        setObjectAccessibleName                 ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleParentPropertyInfo      ,
    #endif
        clearObjectAccessibleParent             ,
        constructObjectAccessibleParent         ,
        getObjectAccessibleParent               ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleParent                  ,
    #endif
        setObjectAccessibleParent               ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleRolePropertyInfo        ,
    #endif
        constructObjectAccessibleRole           ,
        getObjectAccessibleRole                 ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleRole                    ,
    #endif
        setObjectAccessibleRole                 ,

    -- ** accessibleTableCaption #attr:accessibleTableCaption#
    -- | Table caption.

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableCaptionPropertyInfo,
    #endif
        clearObjectAccessibleTableCaption       ,
        constructObjectAccessibleTableCaption   ,
        getObjectAccessibleTableCaption         ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableCaption            ,
    #endif
        setObjectAccessibleTableCaption         ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableCaptionObjectPropertyInfo,
    #endif
        clearObjectAccessibleTableCaptionObject ,
        constructObjectAccessibleTableCaptionObject,
        getObjectAccessibleTableCaptionObject   ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableCaptionObject      ,
    #endif
        setObjectAccessibleTableCaptionObject   ,

    -- ** accessibleTableColumnDescription #attr:accessibleTableColumnDescription#
    -- | Accessible table column description.

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableColumnDescriptionPropertyInfo,
    #endif
        clearObjectAccessibleTableColumnDescription,
        constructObjectAccessibleTableColumnDescription,
        getObjectAccessibleTableColumnDescription,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableColumnDescription  ,
    #endif
        setObjectAccessibleTableColumnDescription,

    -- ** accessibleTableColumnHeader #attr:accessibleTableColumnHeader#
    -- | Accessible table column header.

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableColumnHeaderPropertyInfo,
    #endif
        clearObjectAccessibleTableColumnHeader  ,
        constructObjectAccessibleTableColumnHeader,
        getObjectAccessibleTableColumnHeader    ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableColumnHeader       ,
    #endif
        setObjectAccessibleTableColumnHeader    ,

    -- ** accessibleTableRowDescription #attr:accessibleTableRowDescription#
    -- | Accessible table row description.

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableRowDescriptionPropertyInfo,
    #endif
        clearObjectAccessibleTableRowDescription,
        constructObjectAccessibleTableRowDescription,
        getObjectAccessibleTableRowDescription  ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableRowDescription     ,
    #endif
        setObjectAccessibleTableRowDescription  ,

    -- ** accessibleTableRowHeader #attr:accessibleTableRowHeader#
    -- | Accessible table row header.

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableRowHeaderPropertyInfo,
    #endif
        clearObjectAccessibleTableRowHeader     ,
        constructObjectAccessibleTableRowHeader ,
        getObjectAccessibleTableRowHeader       ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableRowHeader          ,
    #endif
        setObjectAccessibleTableRowHeader       ,

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

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleTableSummaryPropertyInfo,
    #endif
        clearObjectAccessibleTableSummary       ,
        constructObjectAccessibleTableSummary   ,
        getObjectAccessibleTableSummary         ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleTableSummary            ,
    #endif
        setObjectAccessibleTableSummary         ,

    -- ** accessibleValue #attr:accessibleValue#
    -- | Numeric value of this object, in case being and AtkValue.

    #if defined(ENABLE_OVERLOADING)
        ObjectAccessibleValuePropertyInfo       ,
    #endif
        constructObjectAccessibleValue          ,
        getObjectAccessibleValue                ,
    #if defined(ENABLE_OVERLOADING)
        objectAccessibleValue                   ,
    #endif
        setObjectAccessibleValue                ,

     -- * Signals

    -- ** activeDescendantChanged #signal:activeDescendantChanged#

        ObjectActiveDescendantChangedCallback   ,
    #if defined(ENABLE_OVERLOADING)
        ObjectActiveDescendantChangedSignalInfo ,
    #endif
        afterObjectActiveDescendantChanged      ,
        onObjectActiveDescendantChanged         ,

    -- ** announcement #signal:announcement#

        ObjectAnnouncementCallback              ,
    #if defined(ENABLE_OVERLOADING)
        ObjectAnnouncementSignalInfo            ,
    #endif
        afterObjectAnnouncement                 ,
        onObjectAnnouncement                    ,

    -- ** attributeChanged #signal:attributeChanged#

        ObjectAttributeChangedCallback          ,
    #if defined(ENABLE_OVERLOADING)
        ObjectAttributeChangedSignalInfo        ,
    #endif
        afterObjectAttributeChanged             ,
        onObjectAttributeChanged                ,

    -- ** childrenChanged #signal:childrenChanged#

        ObjectChildrenChangedCallback           ,
    #if defined(ENABLE_OVERLOADING)
        ObjectChildrenChangedSignalInfo         ,
    #endif
        afterObjectChildrenChanged              ,
        onObjectChildrenChanged                 ,

    -- ** focusEvent #signal:focusEvent#

        ObjectFocusEventCallback                ,
    #if defined(ENABLE_OVERLOADING)
        ObjectFocusEventSignalInfo              ,
    #endif
        afterObjectFocusEvent                   ,
        onObjectFocusEvent                      ,

    -- ** notification #signal:notification#

        ObjectNotificationCallback              ,
    #if defined(ENABLE_OVERLOADING)
        ObjectNotificationSignalInfo            ,
    #endif
        afterObjectNotification                 ,
        onObjectNotification                    ,

    -- ** propertyChange #signal:propertyChange#

        ObjectPropertyChangeCallback            ,
    #if defined(ENABLE_OVERLOADING)
        ObjectPropertyChangeSignalInfo          ,
    #endif
        afterObjectPropertyChange               ,
        onObjectPropertyChange                  ,

    -- ** stateChange #signal:stateChange#

        ObjectStateChangeCallback               ,
    #if defined(ENABLE_OVERLOADING)
        ObjectStateChangeSignalInfo             ,
    #endif
        afterObjectStateChange                  ,
        onObjectStateChange                     ,

    -- ** visibleDataChanged #signal:visibleDataChanged#

        ObjectVisibleDataChangedCallback        ,
    #if defined(ENABLE_OVERLOADING)
        ObjectVisibleDataChangedSignalInfo      ,
    #endif
        afterObjectVisibleDataChanged           ,
        onObjectVisibleDataChanged              ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
    import {-# SOURCE #-} qualified GI.Atk.Objects.Relation as Atk.Relation
    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
    import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray

    #else
    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

    #endif

    -- | Memory-managed wrapper type.
    newtype Object = Object (SP.ManagedPtr Object)
        deriving (Object -> Object -> Bool
    (Object -> Object -> Bool)
    -> (Object -> Object -> Bool) -> Eq Object
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Object -> Object -> Bool
    == :: Object -> Object -> Bool
    $c/= :: Object -> Object -> Bool
    /= :: Object -> Object -> Bool
    Eq)

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

    foreign import ccall "atk_object_get_type"
        c_atk_object_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Object where
        glibType :: IO GType
    glibType = IO GType
    c_atk_object_get_type

    instance B.Types.GObject Object

    -- | Type class for types which can be safely cast to `Object`, for instance with `toObject`.
    class (SP.GObject o, O.IsDescendantOf Object o) => IsObject o
    instance (SP.GObject o, O.IsDescendantOf Object o) => IsObject o

    instance O.HasParentTypes Object
    type instance O.ParentTypes Object = '[GObject.Object.Object]

    -- | Cast to `Object`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toObject :: (MIO.MonadIO m, IsObject o) => o -> m Object
    toObject :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Object
    toObject = IO Object -> m Object
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Object -> m Object) -> (o -> IO Object) -> o -> m Object
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr Object -> Object) -> o -> IO Object
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr Object -> Object
    Object

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveObjectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 "getHelpText" o = ObjectGetHelpTextMethodInfo
        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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveObjectMethod "setDescription" o = ObjectSetDescriptionMethodInfo
        ResolveObjectMethod "setHelpText" o = ObjectSetHelpTextMethodInfo
        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.OverloadedMethod info Object p) => OL.IsLabel t (Object -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

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

    #endif

    instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethodInfo info Object) => OL.IsLabel t (O.MethodProxy info Object) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #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 ()

    type C_ObjectActiveDescendantChangedCallback =
        Ptr Object ->                           -- 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_ObjectActiveDescendantChangedCallback ::
        GObject a => (a -> ObjectActiveDescendantChangedCallback) ->
        C_ObjectActiveDescendantChangedCallback
    wrap_ObjectActiveDescendantChangedCallback :: forall a.
    GObject a =>
    (a -> Maybe Object -> IO ())
    -> C_ObjectActiveDescendantChangedCallback
    wrap_ObjectActiveDescendantChangedCallback a -> Maybe Object -> IO ()
    gi'cb Ptr Object
    gi'selfPtr Ptr Object
    arg1 Ptr ()
    _ = do
        Maybe Object
    maybeArg1 <-
            if Ptr Object
    arg1 Ptr Object -> Ptr Object -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Object
    forall a. Ptr a
    FP.nullPtr
            then Maybe Object -> IO (Maybe Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Object
    forall a. Maybe a
    Nothing
            else do
                Object
    arg1' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Object -> Object
    Object) Ptr Object
    arg1
                Maybe Object -> IO (Maybe Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Object -> IO (Maybe Object))
    -> Maybe Object -> IO (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ Object -> Maybe Object
    forall a. a -> Maybe a
    Just Object
    arg1'
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> Maybe Object -> IO ()
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Maybe Object
    maybeArg1

    -- | Connect a signal handler for the [activeDescendantChanged](#signal:activeDescendantChanged) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@active-descendant-changed::detail@” instead.
    --
    onObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectActiveDescendantChangedCallback) -> m SignalHandlerId
    onObjectActiveDescendantChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => Maybe Object -> IO ())
    -> m SignalHandlerId
    onObjectActiveDescendantChanged a
    obj Maybe Text
    detail (?self::a) => Maybe Object -> IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> Maybe Object -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => Maybe Object -> IO ()
    Maybe Object -> IO ()
    cb
        let wrapped' :: C_ObjectActiveDescendantChangedCallback
    wrapped' = (a -> Maybe Object -> IO ())
    -> C_ObjectActiveDescendantChangedCallback
    forall a.
    GObject a =>
    (a -> Maybe Object -> IO ())
    -> C_ObjectActiveDescendantChangedCallback
    wrap_ObjectActiveDescendantChangedCallback a -> Maybe Object -> IO ()
    wrapped
        FunPtr C_ObjectActiveDescendantChangedCallback
    wrapped'' <- C_ObjectActiveDescendantChangedCallback
    -> IO (FunPtr C_ObjectActiveDescendantChangedCallback)
    mk_ObjectActiveDescendantChangedCallback C_ObjectActiveDescendantChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectActiveDescendantChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "active-descendant-changed" FunPtr C_ObjectActiveDescendantChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    detail

    -- | Connect a signal handler for the [activeDescendantChanged](#signal:activeDescendantChanged) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@active-descendant-changed::detail@” instead.
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectActiveDescendantChangedCallback) -> m SignalHandlerId
    afterObjectActiveDescendantChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => Maybe Object -> IO ())
    -> m SignalHandlerId
    afterObjectActiveDescendantChanged a
    obj Maybe Text
    detail (?self::a) => Maybe Object -> IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> Maybe Object -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => Maybe Object -> IO ()
    Maybe Object -> IO ()
    cb
        let wrapped' :: C_ObjectActiveDescendantChangedCallback
    wrapped' = (a -> Maybe Object -> IO ())
    -> C_ObjectActiveDescendantChangedCallback
    forall a.
    GObject a =>
    (a -> Maybe Object -> IO ())
    -> C_ObjectActiveDescendantChangedCallback
    wrap_ObjectActiveDescendantChangedCallback a -> Maybe Object -> IO ()
    wrapped
        FunPtr C_ObjectActiveDescendantChangedCallback
    wrapped'' <- C_ObjectActiveDescendantChangedCallback
    -> IO (FunPtr C_ObjectActiveDescendantChangedCallback)
    mk_ObjectActiveDescendantChangedCallback C_ObjectActiveDescendantChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectActiveDescendantChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "active-descendant-changed" FunPtr C_ObjectActiveDescendantChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    detail

    #if defined(ENABLE_OVERLOADING)
    data ObjectActiveDescendantChangedSignalInfo
    instance SignalInfo ObjectActiveDescendantChangedSignalInfo where
        type HaskellCallbackType ObjectActiveDescendantChangedSignalInfo = ObjectActiveDescendantChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectActiveDescendantChangedCallback cb
            cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
            connectSignalFunPtr obj "active-descendant-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::active-descendant-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:activeDescendantChanged"})

    #endif

    -- signal Object::announcement
    -- | The \"announcement\" signal can be emitted to pass an announcement on to
    -- be read by a screen reader.
    --
    -- Depcrecated (2.50): Use AtkObject[notification](#g:signal:notification) instead.
    --
    -- /Since: 2.46/
    type ObjectAnnouncementCallback =
        T.Text
        -- ^ /@arg1@/: the text to be announced.
        -> IO ()

    type C_ObjectAnnouncementCallback =
        Ptr Object ->                           -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_ObjectAnnouncementCallback ::
        GObject a => (a -> ObjectAnnouncementCallback) ->
        C_ObjectAnnouncementCallback
    wrap_ObjectAnnouncementCallback :: forall a.
    GObject a =>
    (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
    wrap_ObjectAnnouncementCallback a -> ObjectAnnouncementCallback
    gi'cb Ptr Object
    gi'selfPtr CString
    arg1 Ptr ()
    _ = do
        Text
    arg1' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    arg1
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectAnnouncementCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Text
    arg1'

    -- | Connect a signal handler for the [announcement](#signal:announcement) 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 #announcement callback
    -- @
    --
    --
    onObjectAnnouncement :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAnnouncementCallback) -> m SignalHandlerId
    onObjectAnnouncement :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> ((?self::a) => ObjectAnnouncementCallback) -> m SignalHandlerId
    onObjectAnnouncement a
    obj (?self::a) => ObjectAnnouncementCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectAnnouncementCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectAnnouncementCallback
    ObjectAnnouncementCallback
    cb
        let wrapped' :: C_ObjectAnnouncementCallback
    wrapped' = (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
    forall a.
    GObject a =>
    (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
    wrap_ObjectAnnouncementCallback a -> ObjectAnnouncementCallback
    wrapped
        FunPtr C_ObjectAnnouncementCallback
    wrapped'' <- C_ObjectAnnouncementCallback
    -> IO (FunPtr C_ObjectAnnouncementCallback)
    mk_ObjectAnnouncementCallback C_ObjectAnnouncementCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectAnnouncementCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "announcement" FunPtr C_ObjectAnnouncementCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [announcement](#signal:announcement) 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 #announcement callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectAnnouncement :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAnnouncementCallback) -> m SignalHandlerId
    afterObjectAnnouncement :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> ((?self::a) => ObjectAnnouncementCallback) -> m SignalHandlerId
    afterObjectAnnouncement a
    obj (?self::a) => ObjectAnnouncementCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectAnnouncementCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectAnnouncementCallback
    ObjectAnnouncementCallback
    cb
        let wrapped' :: C_ObjectAnnouncementCallback
    wrapped' = (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
    forall a.
    GObject a =>
    (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
    wrap_ObjectAnnouncementCallback a -> ObjectAnnouncementCallback
    wrapped
        FunPtr C_ObjectAnnouncementCallback
    wrapped'' <- C_ObjectAnnouncementCallback
    -> IO (FunPtr C_ObjectAnnouncementCallback)
    mk_ObjectAnnouncementCallback C_ObjectAnnouncementCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectAnnouncementCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "announcement" FunPtr C_ObjectAnnouncementCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data ObjectAnnouncementSignalInfo
    instance SignalInfo ObjectAnnouncementSignalInfo where
        type HaskellCallbackType ObjectAnnouncementSignalInfo = ObjectAnnouncementCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectAnnouncementCallback cb
            cb'' <- mk_ObjectAnnouncementCallback cb'
            connectSignalFunPtr obj "announcement" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::announcement"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:announcement"})

    #endif

    -- signal Object::attribute-changed
    -- | The \"attribute-changed\" signal should be emitted when one of an object\'s
    -- attributes changes.
    --
    -- /Since: 2.52/
    type ObjectAttributeChangedCallback =
        T.Text
        -- ^ /@arg1@/: the name of the attribute being modified, or 'P.Nothing' if not
        --          available.
        -> T.Text
        -- ^ /@arg2@/: the attribute\'s new value, or @/null/@ if not available.
        -> IO ()

    type C_ObjectAttributeChangedCallback =
        Ptr Object ->                           -- object
        CString ->
        CString ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_ObjectAttributeChangedCallback ::
        GObject a => (a -> ObjectAttributeChangedCallback) ->
        C_ObjectAttributeChangedCallback
    wrap_ObjectAttributeChangedCallback :: forall a.
    GObject a =>
    (a -> ObjectAttributeChangedCallback)
    -> C_ObjectAttributeChangedCallback
    wrap_ObjectAttributeChangedCallback a -> ObjectAttributeChangedCallback
    gi'cb Ptr Object
    gi'selfPtr CString
    arg1 CString
    arg2 Ptr ()
    _ = do
        Text
    arg1' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    arg1
        Text
    arg2' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    arg2
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectAttributeChangedCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Text
    arg1' Text
    arg2'

    -- | Connect a signal handler for the [attributeChanged](#signal:attributeChanged) 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 #attributeChanged callback
    -- @
    --
    --
    onObjectAttributeChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAttributeChangedCallback) -> m SignalHandlerId
    onObjectAttributeChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> ((?self::a) => ObjectAttributeChangedCallback)
    -> m SignalHandlerId
    onObjectAttributeChanged a
    obj (?self::a) => ObjectAttributeChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectAttributeChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectAttributeChangedCallback
    ObjectAttributeChangedCallback
    cb
        let wrapped' :: C_ObjectAttributeChangedCallback
    wrapped' = (a -> ObjectAttributeChangedCallback)
    -> C_ObjectAttributeChangedCallback
    forall a.
    GObject a =>
    (a -> ObjectAttributeChangedCallback)
    -> C_ObjectAttributeChangedCallback
    wrap_ObjectAttributeChangedCallback a -> ObjectAttributeChangedCallback
    wrapped
        FunPtr C_ObjectAttributeChangedCallback
    wrapped'' <- C_ObjectAttributeChangedCallback
    -> IO (FunPtr C_ObjectAttributeChangedCallback)
    mk_ObjectAttributeChangedCallback C_ObjectAttributeChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectAttributeChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "attribute-changed" FunPtr C_ObjectAttributeChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [attributeChanged](#signal:attributeChanged) 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 #attributeChanged callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectAttributeChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAttributeChangedCallback) -> m SignalHandlerId
    afterObjectAttributeChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> ((?self::a) => ObjectAttributeChangedCallback)
    -> m SignalHandlerId
    afterObjectAttributeChanged a
    obj (?self::a) => ObjectAttributeChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectAttributeChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectAttributeChangedCallback
    ObjectAttributeChangedCallback
    cb
        let wrapped' :: C_ObjectAttributeChangedCallback
    wrapped' = (a -> ObjectAttributeChangedCallback)
    -> C_ObjectAttributeChangedCallback
    forall a.
    GObject a =>
    (a -> ObjectAttributeChangedCallback)
    -> C_ObjectAttributeChangedCallback
    wrap_ObjectAttributeChangedCallback a -> ObjectAttributeChangedCallback
    wrapped
        FunPtr C_ObjectAttributeChangedCallback
    wrapped'' <- C_ObjectAttributeChangedCallback
    -> IO (FunPtr C_ObjectAttributeChangedCallback)
    mk_ObjectAttributeChangedCallback C_ObjectAttributeChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectAttributeChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "attribute-changed" FunPtr C_ObjectAttributeChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data ObjectAttributeChangedSignalInfo
    instance SignalInfo ObjectAttributeChangedSignalInfo where
        type HaskellCallbackType ObjectAttributeChangedSignalInfo = ObjectAttributeChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectAttributeChangedCallback cb
            cb'' <- mk_ObjectAttributeChangedCallback cb'
            connectSignalFunPtr obj "attribute-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::attribute-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:attributeChanged"})

    #endif

    -- signal Object::children-changed
    -- | The signal \"children-changed\" is emitted when a child is added or
    -- removed from 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 ()

    type C_ObjectChildrenChangedCallback =
        Ptr Object ->                           -- 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_ObjectChildrenChangedCallback ::
        GObject a => (a -> ObjectChildrenChangedCallback) ->
        C_ObjectChildrenChangedCallback
    wrap_ObjectChildrenChangedCallback :: forall a.
    GObject a =>
    (a -> ObjectChildrenChangedCallback)
    -> C_ObjectChildrenChangedCallback
    wrap_ObjectChildrenChangedCallback a -> ObjectChildrenChangedCallback
    gi'cb Ptr Object
    gi'selfPtr Word32
    arg1 Ptr Object
    arg2 Ptr ()
    _ = do
        Maybe Object
    maybeArg2 <-
            if Ptr Object
    arg2 Ptr Object -> Ptr Object -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Object
    forall a. Ptr a
    FP.nullPtr
            then Maybe Object -> IO (Maybe Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Object
    forall a. Maybe a
    Nothing
            else do
                Object
    arg2' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Object -> Object
    Object) Ptr Object
    arg2
                Maybe Object -> IO (Maybe Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Object -> IO (Maybe Object))
    -> Maybe Object -> IO (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ Object -> Maybe Object
    forall a. a -> Maybe a
    Just Object
    arg2'
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectChildrenChangedCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Word32
    arg1 Maybe Object
    maybeArg2

    -- | Connect a signal handler for the [childrenChanged](#signal:childrenChanged) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@children-changed::detail@” instead.
    --
    onObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectChildrenChangedCallback) -> m SignalHandlerId
    onObjectChildrenChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => ObjectChildrenChangedCallback)
    -> m SignalHandlerId
    onObjectChildrenChanged a
    obj Maybe Text
    detail (?self::a) => ObjectChildrenChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectChildrenChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectChildrenChangedCallback
    ObjectChildrenChangedCallback
    cb
        let wrapped' :: C_ObjectChildrenChangedCallback
    wrapped' = (a -> ObjectChildrenChangedCallback)
    -> C_ObjectChildrenChangedCallback
    forall a.
    GObject a =>
    (a -> ObjectChildrenChangedCallback)
    -> C_ObjectChildrenChangedCallback
    wrap_ObjectChildrenChangedCallback a -> ObjectChildrenChangedCallback
    wrapped
        FunPtr C_ObjectChildrenChangedCallback
    wrapped'' <- C_ObjectChildrenChangedCallback
    -> IO (FunPtr C_ObjectChildrenChangedCallback)
    mk_ObjectChildrenChangedCallback C_ObjectChildrenChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectChildrenChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "children-changed" FunPtr C_ObjectChildrenChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    detail

    -- | Connect a signal handler for the [childrenChanged](#signal:childrenChanged) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@children-changed::detail@” instead.
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectChildrenChangedCallback) -> m SignalHandlerId
    afterObjectChildrenChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => ObjectChildrenChangedCallback)
    -> m SignalHandlerId
    afterObjectChildrenChanged a
    obj Maybe Text
    detail (?self::a) => ObjectChildrenChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectChildrenChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectChildrenChangedCallback
    ObjectChildrenChangedCallback
    cb
        let wrapped' :: C_ObjectChildrenChangedCallback
    wrapped' = (a -> ObjectChildrenChangedCallback)
    -> C_ObjectChildrenChangedCallback
    forall a.
    GObject a =>
    (a -> ObjectChildrenChangedCallback)
    -> C_ObjectChildrenChangedCallback
    wrap_ObjectChildrenChangedCallback a -> ObjectChildrenChangedCallback
    wrapped
        FunPtr C_ObjectChildrenChangedCallback
    wrapped'' <- C_ObjectChildrenChangedCallback
    -> IO (FunPtr C_ObjectChildrenChangedCallback)
    mk_ObjectChildrenChangedCallback C_ObjectChildrenChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectChildrenChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "children-changed" FunPtr C_ObjectChildrenChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    detail

    #if defined(ENABLE_OVERLOADING)
    data ObjectChildrenChangedSignalInfo
    instance SignalInfo ObjectChildrenChangedSignalInfo where
        type HaskellCallbackType ObjectChildrenChangedSignalInfo = ObjectChildrenChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectChildrenChangedCallback cb
            cb'' <- mk_ObjectChildrenChangedCallback cb'
            connectSignalFunPtr obj "children-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::children-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:childrenChanged"})

    #endif

    -- signal Object::focus-event
    {-# DEPRECATED ObjectFocusEventCallback ["(Since version 2.9.4)","Use the [Object::stateChange](\"GI.Atk.Objects.Object#g:signal:stateChange\") 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 ()

    type C_ObjectFocusEventCallback =
        Ptr Object ->                           -- 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_ObjectFocusEventCallback ::
        GObject a => (a -> ObjectFocusEventCallback) ->
        C_ObjectFocusEventCallback
    wrap_ObjectFocusEventCallback :: forall a.
    GObject a =>
    (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
    wrap_ObjectFocusEventCallback a -> ObjectFocusEventCallback
    gi'cb Ptr Object
    gi'selfPtr CInt
    arg1 Ptr ()
    _ = do
        let arg1' :: Bool
    arg1' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    arg1
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectFocusEventCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Bool
    arg1'

    -- | Connect a signal handler for the [focusEvent](#signal:focusEvent) 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 -> ((?self :: a) => ObjectFocusEventCallback) -> m SignalHandlerId
    onObjectFocusEvent :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a -> ((?self::a) => ObjectFocusEventCallback) -> m SignalHandlerId
    onObjectFocusEvent a
    obj (?self::a) => ObjectFocusEventCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectFocusEventCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectFocusEventCallback
    ObjectFocusEventCallback
    cb
        let wrapped' :: C_ObjectFocusEventCallback
    wrapped' = (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
    forall a.
    GObject a =>
    (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
    wrap_ObjectFocusEventCallback a -> ObjectFocusEventCallback
    wrapped
        FunPtr C_ObjectFocusEventCallback
    wrapped'' <- C_ObjectFocusEventCallback
    -> IO (FunPtr C_ObjectFocusEventCallback)
    mk_ObjectFocusEventCallback C_ObjectFocusEventCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectFocusEventCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "focus-event" FunPtr C_ObjectFocusEventCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [focusEvent](#signal:focusEvent) 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
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectFocusEvent :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectFocusEventCallback) -> m SignalHandlerId
    afterObjectFocusEvent :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a -> ((?self::a) => ObjectFocusEventCallback) -> m SignalHandlerId
    afterObjectFocusEvent a
    obj (?self::a) => ObjectFocusEventCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectFocusEventCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectFocusEventCallback
    ObjectFocusEventCallback
    cb
        let wrapped' :: C_ObjectFocusEventCallback
    wrapped' = (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
    forall a.
    GObject a =>
    (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
    wrap_ObjectFocusEventCallback a -> ObjectFocusEventCallback
    wrapped
        FunPtr C_ObjectFocusEventCallback
    wrapped'' <- C_ObjectFocusEventCallback
    -> IO (FunPtr C_ObjectFocusEventCallback)
    mk_ObjectFocusEventCallback C_ObjectFocusEventCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectFocusEventCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "focus-event" FunPtr C_ObjectFocusEventCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data ObjectFocusEventSignalInfo
    instance SignalInfo ObjectFocusEventSignalInfo where
        type HaskellCallbackType ObjectFocusEventSignalInfo = ObjectFocusEventCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectFocusEventCallback cb
            cb'' <- mk_ObjectFocusEventCallback cb'
            connectSignalFunPtr obj "focus-event" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::focus-event"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:focusEvent"})

    #endif

    -- signal Object::notification
    -- | The \"notification\" signal can be emitted to pass an announcement on to
    -- be read by a screen reader.
    --
    -- /Since: 2.50/
    type ObjectNotificationCallback =
        T.Text
        -- ^ /@arg1@/: the text to be announced.
        -> Int32
        -- ^ /@arg2@/: an t'GI.Atk.Enums.Live' specifying the politeness of the notification.
        -- Should be either ATK_LIVE_POLITE or ATK_LIVE_ASSERTIVE.
        -> IO ()

    type C_ObjectNotificationCallback =
        Ptr Object ->                           -- object
        CString ->
        Int32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_ObjectNotificationCallback ::
        GObject a => (a -> ObjectNotificationCallback) ->
        C_ObjectNotificationCallback
    wrap_ObjectNotificationCallback :: forall a.
    GObject a =>
    (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
    wrap_ObjectNotificationCallback a -> ObjectNotificationCallback
    gi'cb Ptr Object
    gi'selfPtr CString
    arg1 Int32
    arg2 Ptr ()
    _ = do
        Text
    arg1' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    arg1
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectNotificationCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Text
    arg1' Int32
    arg2

    -- | Connect a signal handler for the [notification](#signal:notification) 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 #notification callback
    -- @
    --
    --
    onObjectNotification :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectNotificationCallback) -> m SignalHandlerId
    onObjectNotification :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> ((?self::a) => ObjectNotificationCallback) -> m SignalHandlerId
    onObjectNotification a
    obj (?self::a) => ObjectNotificationCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectNotificationCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectNotificationCallback
    ObjectNotificationCallback
    cb
        let wrapped' :: C_ObjectNotificationCallback
    wrapped' = (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
    forall a.
    GObject a =>
    (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
    wrap_ObjectNotificationCallback a -> ObjectNotificationCallback
    wrapped
        FunPtr C_ObjectNotificationCallback
    wrapped'' <- C_ObjectNotificationCallback
    -> IO (FunPtr C_ObjectNotificationCallback)
    mk_ObjectNotificationCallback C_ObjectNotificationCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectNotificationCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "notification" FunPtr C_ObjectNotificationCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [notification](#signal:notification) 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 #notification callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectNotification :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectNotificationCallback) -> m SignalHandlerId
    afterObjectNotification :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> ((?self::a) => ObjectNotificationCallback) -> m SignalHandlerId
    afterObjectNotification a
    obj (?self::a) => ObjectNotificationCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectNotificationCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectNotificationCallback
    ObjectNotificationCallback
    cb
        let wrapped' :: C_ObjectNotificationCallback
    wrapped' = (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
    forall a.
    GObject a =>
    (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
    wrap_ObjectNotificationCallback a -> ObjectNotificationCallback
    wrapped
        FunPtr C_ObjectNotificationCallback
    wrapped'' <- C_ObjectNotificationCallback
    -> IO (FunPtr C_ObjectNotificationCallback)
    mk_ObjectNotificationCallback C_ObjectNotificationCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectNotificationCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "notification" FunPtr C_ObjectNotificationCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data ObjectNotificationSignalInfo
    instance SignalInfo ObjectNotificationSignalInfo where
        type HaskellCallbackType ObjectNotificationSignalInfo = ObjectNotificationCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectNotificationCallback cb
            cb'' <- mk_ObjectNotificationCallback cb'
            connectSignalFunPtr obj "notification" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::notification"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:notification"})

    #endif

    -- signal Object::property-change
    -- | The signal \"property-change\" is emitted when an object\'s property
    -- value changes. /@arg1@/ contains an t'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. t'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 t'GI.Atk.Structs.PropertyValues.PropertyValues' containing the new
        -- value of the property which changed.
        -> IO ()

    type C_ObjectPropertyChangeCallback =
        Ptr Object ->                           -- 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_ObjectPropertyChangeCallback ::
        GObject a => (a -> ObjectPropertyChangeCallback) ->
        C_ObjectPropertyChangeCallback
    wrap_ObjectPropertyChangeCallback :: forall a.
    GObject a =>
    (a -> ObjectPropertyChangeCallback)
    -> C_ObjectPropertyChangeCallback
    wrap_ObjectPropertyChangeCallback a -> ObjectPropertyChangeCallback
    gi'cb Ptr Object
    gi'selfPtr Ptr PropertyValues
    arg1 Ptr ()
    _ = do
        Maybe PropertyValues
    maybeArg1 <-
            if Ptr PropertyValues
    arg1 Ptr PropertyValues -> Ptr PropertyValues -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr PropertyValues
    forall a. Ptr a
    FP.nullPtr
            then Maybe PropertyValues -> IO (Maybe PropertyValues)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe PropertyValues
    forall a. Maybe a
    Nothing
            else do
                PropertyValues
    arg1' <- ((ManagedPtr PropertyValues -> PropertyValues)
    -> Ptr PropertyValues -> IO PropertyValues
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr PropertyValues -> PropertyValues
    Atk.PropertyValues.PropertyValues) Ptr PropertyValues
    arg1
                Maybe PropertyValues -> IO (Maybe PropertyValues)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe PropertyValues -> IO (Maybe PropertyValues))
    -> Maybe PropertyValues -> IO (Maybe PropertyValues)
    forall a b. (a -> b) -> a -> b
    $ PropertyValues -> Maybe PropertyValues
    forall a. a -> Maybe a
    Just PropertyValues
    arg1'
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectPropertyChangeCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Maybe PropertyValues
    maybeArg1

    -- | Connect a signal handler for the [propertyChange](#signal:propertyChange) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@property-change::detail@” instead.
    --
    onObjectPropertyChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectPropertyChangeCallback) -> m SignalHandlerId
    onObjectPropertyChange :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => ObjectPropertyChangeCallback)
    -> m SignalHandlerId
    onObjectPropertyChange a
    obj Maybe Text
    detail (?self::a) => ObjectPropertyChangeCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectPropertyChangeCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectPropertyChangeCallback
    ObjectPropertyChangeCallback
    cb
        let wrapped' :: C_ObjectPropertyChangeCallback
    wrapped' = (a -> ObjectPropertyChangeCallback)
    -> C_ObjectPropertyChangeCallback
    forall a.
    GObject a =>
    (a -> ObjectPropertyChangeCallback)
    -> C_ObjectPropertyChangeCallback
    wrap_ObjectPropertyChangeCallback a -> ObjectPropertyChangeCallback
    wrapped
        FunPtr C_ObjectPropertyChangeCallback
    wrapped'' <- C_ObjectPropertyChangeCallback
    -> IO (FunPtr C_ObjectPropertyChangeCallback)
    mk_ObjectPropertyChangeCallback C_ObjectPropertyChangeCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectPropertyChangeCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "property-change" FunPtr C_ObjectPropertyChangeCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    detail

    -- | Connect a signal handler for the [propertyChange](#signal:propertyChange) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@property-change::detail@” instead.
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectPropertyChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectPropertyChangeCallback) -> m SignalHandlerId
    afterObjectPropertyChange :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => ObjectPropertyChangeCallback)
    -> m SignalHandlerId
    afterObjectPropertyChange a
    obj Maybe Text
    detail (?self::a) => ObjectPropertyChangeCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectPropertyChangeCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectPropertyChangeCallback
    ObjectPropertyChangeCallback
    cb
        let wrapped' :: C_ObjectPropertyChangeCallback
    wrapped' = (a -> ObjectPropertyChangeCallback)
    -> C_ObjectPropertyChangeCallback
    forall a.
    GObject a =>
    (a -> ObjectPropertyChangeCallback)
    -> C_ObjectPropertyChangeCallback
    wrap_ObjectPropertyChangeCallback a -> ObjectPropertyChangeCallback
    wrapped
        FunPtr C_ObjectPropertyChangeCallback
    wrapped'' <- C_ObjectPropertyChangeCallback
    -> IO (FunPtr C_ObjectPropertyChangeCallback)
    mk_ObjectPropertyChangeCallback C_ObjectPropertyChangeCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectPropertyChangeCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "property-change" FunPtr C_ObjectPropertyChangeCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    detail

    #if defined(ENABLE_OVERLOADING)
    data ObjectPropertyChangeSignalInfo
    instance SignalInfo ObjectPropertyChangeSignalInfo where
        type HaskellCallbackType ObjectPropertyChangeSignalInfo = ObjectPropertyChangeCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectPropertyChangeCallback cb
            cb'' <- mk_ObjectPropertyChangeCallback cb'
            connectSignalFunPtr obj "property-change" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::property-change"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:propertyChange"})

    #endif

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

    type C_ObjectStateChangeCallback =
        Ptr Object ->                           -- 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_ObjectStateChangeCallback ::
        GObject a => (a -> ObjectStateChangeCallback) ->
        C_ObjectStateChangeCallback
    wrap_ObjectStateChangeCallback :: forall a.
    GObject a =>
    (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
    wrap_ObjectStateChangeCallback a -> ObjectStateChangeCallback
    gi'cb Ptr Object
    gi'selfPtr CString
    arg1 CInt
    arg2 Ptr ()
    _ = do
        Text
    arg1' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    arg1
        let arg2' :: Bool
    arg2' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    arg2
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> ObjectStateChangeCallback
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)  Text
    arg1' Bool
    arg2'

    -- | Connect a signal handler for the [stateChange](#signal:stateChange) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@state-change::detail@” instead.
    --
    onObjectStateChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectStateChangeCallback) -> m SignalHandlerId
    onObjectStateChange :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => ObjectStateChangeCallback)
    -> m SignalHandlerId
    onObjectStateChange a
    obj Maybe Text
    detail (?self::a) => ObjectStateChangeCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectStateChangeCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectStateChangeCallback
    ObjectStateChangeCallback
    cb
        let wrapped' :: C_ObjectStateChangeCallback
    wrapped' = (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
    forall a.
    GObject a =>
    (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
    wrap_ObjectStateChangeCallback a -> ObjectStateChangeCallback
    wrapped
        FunPtr C_ObjectStateChangeCallback
    wrapped'' <- C_ObjectStateChangeCallback
    -> IO (FunPtr C_ObjectStateChangeCallback)
    mk_ObjectStateChangeCallback C_ObjectStateChangeCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectStateChangeCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "state-change" FunPtr C_ObjectStateChangeCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    detail

    -- | Connect a signal handler for the [stateChange](#signal:stateChange) 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
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@state-change::detail@” instead.
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectStateChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectStateChangeCallback) -> m SignalHandlerId
    afterObjectStateChange :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => ObjectStateChangeCallback)
    -> m SignalHandlerId
    afterObjectStateChange a
    obj Maybe Text
    detail (?self::a) => ObjectStateChangeCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ObjectStateChangeCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ObjectStateChangeCallback
    ObjectStateChangeCallback
    cb
        let wrapped' :: C_ObjectStateChangeCallback
    wrapped' = (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
    forall a.
    GObject a =>
    (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
    wrap_ObjectStateChangeCallback a -> ObjectStateChangeCallback
    wrapped
        FunPtr C_ObjectStateChangeCallback
    wrapped'' <- C_ObjectStateChangeCallback
    -> IO (FunPtr C_ObjectStateChangeCallback)
    mk_ObjectStateChangeCallback C_ObjectStateChangeCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectStateChangeCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "state-change" FunPtr C_ObjectStateChangeCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    detail

    #if defined(ENABLE_OVERLOADING)
    data ObjectStateChangeSignalInfo
    instance SignalInfo ObjectStateChangeSignalInfo where
        type HaskellCallbackType ObjectStateChangeSignalInfo = ObjectStateChangeCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectStateChangeCallback cb
            cb'' <- mk_ObjectStateChangeCallback cb'
            connectSignalFunPtr obj "state-change" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::state-change"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:stateChange"})

    #endif

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

    type C_ObjectVisibleDataChangedCallback =
        Ptr Object ->                           -- 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_ObjectVisibleDataChangedCallback ::
        GObject a => (a -> ObjectVisibleDataChangedCallback) ->
        C_ObjectVisibleDataChangedCallback
    wrap_ObjectVisibleDataChangedCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
    wrap_ObjectVisibleDataChangedCallback a -> IO ()
    gi'cb Ptr Object
    gi'selfPtr Ptr ()
    _ = do
        Ptr Object -> (Object -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Object
    gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Object
    gi'self -> a -> IO ()
    gi'cb (Object -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Object
    gi'self)

    -- | Connect a signal handler for the [visibleDataChanged](#signal:visibleDataChanged) 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 -> ((?self :: a) => ObjectVisibleDataChangedCallback) -> m SignalHandlerId
    onObjectVisibleDataChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onObjectVisibleDataChanged a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_ObjectVisibleDataChangedCallback
    wrapped' = (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
    wrap_ObjectVisibleDataChangedCallback a -> IO ()
    wrapped
        FunPtr C_ObjectVisibleDataChangedCallback
    wrapped'' <- C_ObjectVisibleDataChangedCallback
    -> IO (FunPtr C_ObjectVisibleDataChangedCallback)
    mk_ObjectVisibleDataChangedCallback C_ObjectVisibleDataChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectVisibleDataChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "visible-data-changed" FunPtr C_ObjectVisibleDataChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [visibleDataChanged](#signal:visibleDataChanged) 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
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterObjectVisibleDataChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectVisibleDataChangedCallback) -> m SignalHandlerId
    afterObjectVisibleDataChanged :: forall a (m :: * -> *).
    (IsObject a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterObjectVisibleDataChanged a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_ObjectVisibleDataChangedCallback
    wrapped' = (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
    wrap_ObjectVisibleDataChangedCallback a -> IO ()
    wrapped
        FunPtr C_ObjectVisibleDataChangedCallback
    wrapped'' <- C_ObjectVisibleDataChangedCallback
    -> IO (FunPtr C_ObjectVisibleDataChangedCallback)
    mk_ObjectVisibleDataChangedCallback C_ObjectVisibleDataChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_ObjectVisibleDataChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "visible-data-changed" FunPtr C_ObjectVisibleDataChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data ObjectVisibleDataChangedSignalInfo
    instance SignalInfo ObjectVisibleDataChangedSignalInfo where
        type HaskellCallbackType ObjectVisibleDataChangedSignalInfo = ObjectVisibleDataChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ObjectVisibleDataChangedCallback cb
            cb'' <- mk_ObjectVisibleDataChangedCallback cb'
            connectSignalFunPtr obj "visible-data-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object::visible-data-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:signal:visibleDataChanged"})

    #endif

    -- 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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
    getObjectAccessibleComponentLayer o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "accessible-component-layer"

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleComponentLayerPropertyInfo
    instance AttrInfo ObjectAccessibleComponentLayerPropertyInfo where
        type AttrAllowedOps ObjectAccessibleComponentLayerPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = (~) ()
        type AttrTransferTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = (~) ()
        type AttrTransferType ObjectAccessibleComponentLayerPropertyInfo = ()
        type AttrGetType ObjectAccessibleComponentLayerPropertyInfo = Int32
        type AttrLabel ObjectAccessibleComponentLayerPropertyInfo = "accessible-component-layer"
        type AttrOrigin ObjectAccessibleComponentLayerPropertyInfo = Object
        attrGet = getObjectAccessibleComponentLayer
        attrSet = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleComponentLayer"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleComponentLayer"
            })
    #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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
    getObjectAccessibleComponentMdiZorder o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "accessible-component-mdi-zorder"

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleComponentMdiZorderPropertyInfo
    instance AttrInfo ObjectAccessibleComponentMdiZorderPropertyInfo where
        type AttrAllowedOps ObjectAccessibleComponentMdiZorderPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = (~) ()
        type AttrTransferTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = (~) ()
        type AttrTransferType ObjectAccessibleComponentMdiZorderPropertyInfo = ()
        type AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo = Int32
        type AttrLabel ObjectAccessibleComponentMdiZorderPropertyInfo = "accessible-component-mdi-zorder"
        type AttrOrigin ObjectAccessibleComponentMdiZorderPropertyInfo = Object
        attrGet = getObjectAccessibleComponentMdiZorder
        attrSet = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleComponentMdiZorder"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleComponentMdiZorder"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Text)
    getObjectAccessibleDescription o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleDescription o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-description" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleDescription :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleDescription Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-description" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleDescription o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-description" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleDescriptionPropertyInfo
    instance AttrInfo ObjectAccessibleDescriptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleDescriptionPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleDescriptionPropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleDescriptionPropertyInfo = T.Text
        type AttrGetType ObjectAccessibleDescriptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleDescriptionPropertyInfo = "accessible-description"
        type AttrOrigin ObjectAccessibleDescriptionPropertyInfo = Object
        attrGet = getObjectAccessibleDescription
        attrSet = setObjectAccessibleDescription
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleDescription
        attrClear = clearObjectAccessibleDescription
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleDescription"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleDescription"
            })
    #endif

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

    -- | Get the value of the “@accessible-help-text@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' object #accessibleHelpText
    -- @
    getObjectAccessibleHelpText :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
    getObjectAccessibleHelpText :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Text)
    getObjectAccessibleHelpText o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "accessible-help-text"

    -- | Set the value of the “@accessible-help-text@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' object [ #accessibleHelpText 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setObjectAccessibleHelpText :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleHelpText :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleHelpText o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-help-text" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    val)

    -- | Construct a `GValueConstruct` with valid value for the “@accessible-help-text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructObjectAccessibleHelpText :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleHelpText :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleHelpText Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-help-text" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    -- | Set the value of the “@accessible-help-text@” 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' #accessibleHelpText
    -- @
    clearObjectAccessibleHelpText :: (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleHelpText :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleHelpText o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-help-text" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleHelpTextPropertyInfo
    instance AttrInfo ObjectAccessibleHelpTextPropertyInfo where
        type AttrAllowedOps ObjectAccessibleHelpTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleHelpTextPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleHelpTextPropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleHelpTextPropertyInfo = T.Text
        type AttrGetType ObjectAccessibleHelpTextPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleHelpTextPropertyInfo = "accessible-help-text"
        type AttrOrigin ObjectAccessibleHelpTextPropertyInfo = Object
        attrGet = getObjectAccessibleHelpText
        attrSet = setObjectAccessibleHelpText
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleHelpText
        attrClear = clearObjectAccessibleHelpText
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleHelpText"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleHelpText"
            })
    #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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
    getObjectAccessibleHypertextNlinks o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "accessible-hypertext-nlinks"

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleHypertextNlinksPropertyInfo
    instance AttrInfo ObjectAccessibleHypertextNlinksPropertyInfo where
        type AttrAllowedOps ObjectAccessibleHypertextNlinksPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = (~) ()
        type AttrTransferTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = (~) ()
        type AttrTransferType ObjectAccessibleHypertextNlinksPropertyInfo = ()
        type AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo = Int32
        type AttrLabel ObjectAccessibleHypertextNlinksPropertyInfo = "accessible-hypertext-nlinks"
        type AttrOrigin ObjectAccessibleHypertextNlinksPropertyInfo = Object
        attrGet = getObjectAccessibleHypertextNlinks
        attrSet = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleHypertextNlinks"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleHypertextNlinks"
            })
    #endif

    -- VVV Prop "accessible-id"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@accessible-id@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' object #accessibleId
    -- @
    getObjectAccessibleId :: (MonadIO m, IsObject o) => o -> m T.Text
    getObjectAccessibleId :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Text
    getObjectAccessibleId o
    obj = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> IO (Maybe Text) -> IO Text
    forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
    checkUnexpectedNothing Text
    "getObjectAccessibleId" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "accessible-id"

    -- | Set the value of the “@accessible-id@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' object [ #accessibleId 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setObjectAccessibleId :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
    setObjectAccessibleId :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleId o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-id" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    val)

    -- | Construct a `GValueConstruct` with valid value for the “@accessible-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructObjectAccessibleId :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleId :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleId Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-id" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleIdPropertyInfo
    instance AttrInfo ObjectAccessibleIdPropertyInfo where
        type AttrAllowedOps ObjectAccessibleIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleIdPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleIdPropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleIdPropertyInfo = T.Text
        type AttrGetType ObjectAccessibleIdPropertyInfo = T.Text
        type AttrLabel ObjectAccessibleIdPropertyInfo = "accessible-id"
        type AttrOrigin ObjectAccessibleIdPropertyInfo = Object
        attrGet = getObjectAccessibleId
        attrSet = setObjectAccessibleId
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleId
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleId"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleId"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Text)
    getObjectAccessibleName o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleName o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-name" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleName :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleName Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-name" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleName o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-name" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleNamePropertyInfo
    instance AttrInfo ObjectAccessibleNamePropertyInfo where
        type AttrAllowedOps ObjectAccessibleNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleNamePropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleNamePropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleNamePropertyInfo = T.Text
        type AttrGetType ObjectAccessibleNamePropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleNamePropertyInfo = "accessible-name"
        type AttrOrigin ObjectAccessibleNamePropertyInfo = Object
        attrGet = getObjectAccessibleName
        attrSet = setObjectAccessibleName
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleName
        attrClear = clearObjectAccessibleName
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleName"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleName"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Object)
    getObjectAccessibleParent o
    obj = IO (Maybe Object) -> m (Maybe Object)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "accessible-parent" ManagedPtr Object -> Object
    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 :: forall (m :: * -> *) o a.
    (MonadIO m, IsObject o, IsObject a) =>
    o -> a -> m ()
    setObjectAccessibleParent o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-parent" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    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, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
    constructObjectAccessibleParent :: forall o (m :: * -> *) a.
    (IsObject o, MonadIO m, IsObject a) =>
    a -> m (GValueConstruct o)
    constructObjectAccessibleParent a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "accessible-parent" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleParent o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Object -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-parent" (Maybe Object
    forall a. Maybe a
    Nothing :: Maybe Object)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleParentPropertyInfo
    instance AttrInfo ObjectAccessibleParentPropertyInfo where
        type AttrAllowedOps ObjectAccessibleParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
        type AttrTransferTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
        type AttrTransferType ObjectAccessibleParentPropertyInfo = Object
        type AttrGetType ObjectAccessibleParentPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleParentPropertyInfo = "accessible-parent"
        type AttrOrigin ObjectAccessibleParentPropertyInfo = Object
        attrGet = getObjectAccessibleParent
        attrSet = setObjectAccessibleParent
        attrTransfer _ v = do
            unsafeCastTo Object v
        attrConstruct = constructObjectAccessibleParent
        attrClear = clearObjectAccessibleParent
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleParent"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleParent"
            })
    #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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Role
    getObjectAccessibleRole o
    obj = IO Role -> m Role
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Role -> m Role) -> IO Role -> m Role
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Role
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Role -> m ()
    setObjectAccessibleRole o
    obj Role
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Role -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "accessible-role" 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, MIO.MonadIO m) => Atk.Enums.Role -> m (GValueConstruct o)
    constructObjectAccessibleRole :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Role -> m (GValueConstruct o)
    constructObjectAccessibleRole Role
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Role -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "accessible-role" Role
    val

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleRolePropertyInfo
    instance AttrInfo ObjectAccessibleRolePropertyInfo where
        type AttrAllowedOps ObjectAccessibleRolePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleRolePropertyInfo = (~) Atk.Enums.Role
        type AttrTransferTypeConstraint ObjectAccessibleRolePropertyInfo = (~) Atk.Enums.Role
        type AttrTransferType ObjectAccessibleRolePropertyInfo = Atk.Enums.Role
        type AttrGetType ObjectAccessibleRolePropertyInfo = Atk.Enums.Role
        type AttrLabel ObjectAccessibleRolePropertyInfo = "accessible-role"
        type AttrOrigin ObjectAccessibleRolePropertyInfo = Object
        attrGet = getObjectAccessibleRole
        attrSet = setObjectAccessibleRole
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleRole
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleRole"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleRole"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Text)
    getObjectAccessibleTableCaption o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleTableCaption o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-table-caption" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleTableCaption :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleTableCaption Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-table-caption" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableCaption o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-table-caption" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableCaptionPropertyInfo
    instance AttrInfo ObjectAccessibleTableCaptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableCaptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleTableCaptionPropertyInfo = T.Text
        type AttrGetType ObjectAccessibleTableCaptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleTableCaptionPropertyInfo = "accessible-table-caption"
        type AttrOrigin ObjectAccessibleTableCaptionPropertyInfo = Object
        attrGet = getObjectAccessibleTableCaption
        attrSet = setObjectAccessibleTableCaption
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleTableCaption
        attrClear = clearObjectAccessibleTableCaption
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableCaption"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableCaption"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Object)
    getObjectAccessibleTableCaptionObject o
    obj = IO (Maybe Object) -> m (Maybe Object)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "accessible-table-caption-object" ManagedPtr Object -> 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 :: forall (m :: * -> *) o a.
    (MonadIO m, IsObject o, IsObject a) =>
    o -> a -> m ()
    setObjectAccessibleTableCaptionObject o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-caption-object" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    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, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
    constructObjectAccessibleTableCaptionObject :: forall o (m :: * -> *) a.
    (IsObject o, MonadIO m, IsObject a) =>
    a -> m (GValueConstruct o)
    constructObjectAccessibleTableCaptionObject a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "accessible-table-caption-object" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableCaptionObject o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Object -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-caption-object" (Maybe Object
    forall a. Maybe a
    Nothing :: Maybe Object)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableCaptionObjectPropertyInfo
    instance AttrInfo ObjectAccessibleTableCaptionObjectPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableCaptionObjectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
        type AttrTransferTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
        type AttrTransferType ObjectAccessibleTableCaptionObjectPropertyInfo = Object
        type AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableCaptionObjectPropertyInfo = "accessible-table-caption-object"
        type AttrOrigin ObjectAccessibleTableCaptionObjectPropertyInfo = Object
        attrGet = getObjectAccessibleTableCaptionObject
        attrSet = setObjectAccessibleTableCaptionObject
        attrTransfer _ v = do
            unsafeCastTo Object v
        attrConstruct = constructObjectAccessibleTableCaptionObject
        attrClear = clearObjectAccessibleTableCaptionObject
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableCaptionObject"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableCaptionObject"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Text)
    getObjectAccessibleTableColumnDescription o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleTableColumnDescription o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-table-column-description" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleTableColumnDescription :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleTableColumnDescription Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-table-column-description" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableColumnDescription o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-table-column-description" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableColumnDescriptionPropertyInfo
    instance AttrInfo ObjectAccessibleTableColumnDescriptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableColumnDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleTableColumnDescriptionPropertyInfo = T.Text
        type AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleTableColumnDescriptionPropertyInfo = "accessible-table-column-description"
        type AttrOrigin ObjectAccessibleTableColumnDescriptionPropertyInfo = Object
        attrGet = getObjectAccessibleTableColumnDescription
        attrSet = setObjectAccessibleTableColumnDescription
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleTableColumnDescription
        attrClear = clearObjectAccessibleTableColumnDescription
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableColumnDescription"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableColumnDescription"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Object)
    getObjectAccessibleTableColumnHeader o
    obj = IO (Maybe Object) -> m (Maybe Object)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "accessible-table-column-header" ManagedPtr Object -> Object
    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 :: forall (m :: * -> *) o a.
    (MonadIO m, IsObject o, IsObject a) =>
    o -> a -> m ()
    setObjectAccessibleTableColumnHeader o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-column-header" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    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, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
    constructObjectAccessibleTableColumnHeader :: forall o (m :: * -> *) a.
    (IsObject o, MonadIO m, IsObject a) =>
    a -> m (GValueConstruct o)
    constructObjectAccessibleTableColumnHeader a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "accessible-table-column-header" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableColumnHeader o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Object -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-column-header" (Maybe Object
    forall a. Maybe a
    Nothing :: Maybe Object)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableColumnHeaderPropertyInfo
    instance AttrInfo ObjectAccessibleTableColumnHeaderPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableColumnHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
        type AttrTransferTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
        type AttrTransferType ObjectAccessibleTableColumnHeaderPropertyInfo = Object
        type AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableColumnHeaderPropertyInfo = "accessible-table-column-header"
        type AttrOrigin ObjectAccessibleTableColumnHeaderPropertyInfo = Object
        attrGet = getObjectAccessibleTableColumnHeader
        attrSet = setObjectAccessibleTableColumnHeader
        attrTransfer _ v = do
            unsafeCastTo Object v
        attrConstruct = constructObjectAccessibleTableColumnHeader
        attrClear = clearObjectAccessibleTableColumnHeader
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableColumnHeader"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableColumnHeader"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Text)
    getObjectAccessibleTableRowDescription o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Text -> m ()
    setObjectAccessibleTableRowDescription o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-table-row-description" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructObjectAccessibleTableRowDescription :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructObjectAccessibleTableRowDescription Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "accessible-table-row-description" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableRowDescription o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "accessible-table-row-description" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableRowDescriptionPropertyInfo
    instance AttrInfo ObjectAccessibleTableRowDescriptionPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableRowDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = (~) T.Text
        type AttrTransferType ObjectAccessibleTableRowDescriptionPropertyInfo = T.Text
        type AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo = (Maybe T.Text)
        type AttrLabel ObjectAccessibleTableRowDescriptionPropertyInfo = "accessible-table-row-description"
        type AttrOrigin ObjectAccessibleTableRowDescriptionPropertyInfo = Object
        attrGet = getObjectAccessibleTableRowDescription
        attrSet = setObjectAccessibleTableRowDescription
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleTableRowDescription
        attrClear = clearObjectAccessibleTableRowDescription
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableRowDescription"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableRowDescription"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Object)
    getObjectAccessibleTableRowHeader o
    obj = IO (Maybe Object) -> m (Maybe Object)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "accessible-table-row-header" ManagedPtr Object -> Object
    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 :: forall (m :: * -> *) o a.
    (MonadIO m, IsObject o, IsObject a) =>
    o -> a -> m ()
    setObjectAccessibleTableRowHeader o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-row-header" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    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, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
    constructObjectAccessibleTableRowHeader :: forall o (m :: * -> *) a.
    (IsObject o, MonadIO m, IsObject a) =>
    a -> m (GValueConstruct o)
    constructObjectAccessibleTableRowHeader a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "accessible-table-row-header" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableRowHeader o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Object -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-row-header" (Maybe Object
    forall a. Maybe a
    Nothing :: Maybe Object)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableRowHeaderPropertyInfo
    instance AttrInfo ObjectAccessibleTableRowHeaderPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableRowHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
        type AttrTransferTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
        type AttrTransferType ObjectAccessibleTableRowHeaderPropertyInfo = Object
        type AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableRowHeaderPropertyInfo = "accessible-table-row-header"
        type AttrOrigin ObjectAccessibleTableRowHeaderPropertyInfo = Object
        attrGet = getObjectAccessibleTableRowHeader
        attrSet = setObjectAccessibleTableRowHeader
        attrTransfer _ v = do
            unsafeCastTo Object v
        attrConstruct = constructObjectAccessibleTableRowHeader
        attrClear = clearObjectAccessibleTableRowHeader
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableRowHeader"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableRowHeader"
            })
    #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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> m (Maybe Object)
    getObjectAccessibleTableSummary o
    obj = IO (Maybe Object) -> m (Maybe Object)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "accessible-table-summary" ManagedPtr Object -> Object
    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 :: forall (m :: * -> *) o a.
    (MonadIO m, IsObject o, IsObject a) =>
    o -> a -> m ()
    setObjectAccessibleTableSummary o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-summary" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    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, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
    constructObjectAccessibleTableSummary :: forall o (m :: * -> *) a.
    (IsObject o, MonadIO m, IsObject a) =>
    a -> m (GValueConstruct o)
    constructObjectAccessibleTableSummary a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "accessible-table-summary" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
    clearObjectAccessibleTableSummary o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Object -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "accessible-table-summary" (Maybe Object
    forall a. Maybe a
    Nothing :: Maybe Object)

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleTableSummaryPropertyInfo
    instance AttrInfo ObjectAccessibleTableSummaryPropertyInfo where
        type AttrAllowedOps ObjectAccessibleTableSummaryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
        type AttrTransferTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
        type AttrTransferType ObjectAccessibleTableSummaryPropertyInfo = Object
        type AttrGetType ObjectAccessibleTableSummaryPropertyInfo = (Maybe Object)
        type AttrLabel ObjectAccessibleTableSummaryPropertyInfo = "accessible-table-summary"
        type AttrOrigin ObjectAccessibleTableSummaryPropertyInfo = Object
        attrGet = getObjectAccessibleTableSummary
        attrSet = setObjectAccessibleTableSummary
        attrTransfer _ v = do
            unsafeCastTo Object v
        attrConstruct = constructObjectAccessibleTableSummary
        attrClear = clearObjectAccessibleTableSummary
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleTableSummary"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableSummary"
            })
    #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 :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Double
    getObjectAccessibleValue o
    obj = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Double
    forall a. GObject a => a -> String -> IO Double
    B.Properties.getObjectPropertyDouble o
    obj String
    "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 :: forall (m :: * -> *) o.
    (MonadIO m, IsObject o) =>
    o -> Double -> m ()
    setObjectAccessibleValue o
    obj Double
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Double -> IO ()
    forall a. GObject a => a -> String -> Double -> IO ()
    B.Properties.setObjectPropertyDouble o
    obj String
    "accessible-value" Double
    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, MIO.MonadIO m) => Double -> m (GValueConstruct o)
    constructObjectAccessibleValue :: forall o (m :: * -> *).
    (IsObject o, MonadIO m) =>
    Double -> m (GValueConstruct o)
    constructObjectAccessibleValue Double
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Double -> IO (GValueConstruct o)
    forall o. String -> Double -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyDouble String
    "accessible-value" Double
    val

    #if defined(ENABLE_OVERLOADING)
    data ObjectAccessibleValuePropertyInfo
    instance AttrInfo ObjectAccessibleValuePropertyInfo where
        type AttrAllowedOps ObjectAccessibleValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo = IsObject
        type AttrSetTypeConstraint ObjectAccessibleValuePropertyInfo = (~) Double
        type AttrTransferTypeConstraint ObjectAccessibleValuePropertyInfo = (~) Double
        type AttrTransferType ObjectAccessibleValuePropertyInfo = Double
        type AttrGetType ObjectAccessibleValuePropertyInfo = Double
        type AttrLabel ObjectAccessibleValuePropertyInfo = "accessible-value"
        type AttrOrigin ObjectAccessibleValuePropertyInfo = Object
        attrGet = getObjectAccessibleValue
        attrSet = setObjectAccessibleValue
        attrTransfer _ v = do
            return v
        attrConstruct = constructObjectAccessibleValue
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.accessibleValue"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#g:attr:accessibleValue"
            })
    #endif

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

    #if defined(ENABLE_OVERLOADING)
    objectAccessibleComponentLayer :: AttrLabelProxy "accessibleComponentLayer"
    objectAccessibleComponentLayer = AttrLabelProxy

    objectAccessibleComponentMdiZorder :: AttrLabelProxy "accessibleComponentMdiZorder"
    objectAccessibleComponentMdiZorder = AttrLabelProxy

    objectAccessibleDescription :: AttrLabelProxy "accessibleDescription"
    objectAccessibleDescription = AttrLabelProxy

    objectAccessibleHelpText :: AttrLabelProxy "accessibleHelpText"
    objectAccessibleHelpText = AttrLabelProxy

    objectAccessibleHypertextNlinks :: AttrLabelProxy "accessibleHypertextNlinks"
    objectAccessibleHypertextNlinks = AttrLabelProxy

    objectAccessibleId :: AttrLabelProxy "accessibleId"
    objectAccessibleId = 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 defined(ENABLE_OVERLOADING)
    type instance O.SignalList Object = ObjectSignalList
    type ObjectSignalList = ('[ '("activeDescendantChanged", ObjectActiveDescendantChangedSignalInfo), '("announcement", ObjectAnnouncementSignalInfo), '("attributeChanged", ObjectAttributeChangedSignalInfo), '("childrenChanged", ObjectChildrenChangedSignalInfo), '("focusEvent", ObjectFocusEventSignalInfo), '("notification", ObjectNotificationSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", ObjectPropertyChangeSignalInfo), '("stateChange", ObjectStateChangeSignalInfo), '("visibleDataChanged", ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, DK.Type)])

    #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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object' to which an AtkRelation is to be added.
        -> Atk.Enums.RelationType
        -- ^ /@relationship@/: The t'GI.Atk.Enums.RelationType' of the relation
        -> b
        -- ^ /@target@/: The t'GI.Atk.Objects.Object.Object' which is to be the target of the relation.
        -> m Bool
        -- ^ __Returns:__ TRUE if the relationship is added.
    objectAddRelationship :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a -> RelationType -> b -> m Bool
    objectAddRelationship a
    object RelationType
    relationship b
    target = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    object' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    object
        let relationship' :: CUInt
    relationship' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (RelationType -> Int) -> RelationType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RelationType -> Int
    forall a. Enum a => a -> Int
    fromEnum) RelationType
    relationship
        Ptr Object
    target' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    target
        CInt
    result <- Ptr Object -> CUInt -> Ptr Object -> IO CInt
    atk_object_add_relationship Ptr Object
    object' CUInt
    relationship' Ptr Object
    target'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    object
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    target
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

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

    instance O.OverloadedMethodInfo ObjectAddRelationshipMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectAddRelationship",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Text
    objectGetAccessibleId a
    accessible = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    result <- Ptr Object -> IO CString
    atk_object_get_accessible_id Ptr Object
    accessible'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectGetAccessibleId" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

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

    instance O.OverloadedMethodInfo ObjectGetAccessibleIdMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetAccessibleId",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m [Ptr ()]
    objectGetAttributes a
    accessible = IO [Ptr ()] -> m [Ptr ()]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr (GSList (Ptr ()))
    result <- Ptr Object -> IO (Ptr (GSList (Ptr ())))
    atk_object_get_attributes Ptr Object
    accessible'
        [Ptr ()]
    result' <- Ptr (GSList (Ptr ())) -> IO [Ptr ()]
    forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
    unpackGSList Ptr (GSList (Ptr ()))
    result
        Ptr (GSList (Ptr ())) -> IO ()
    forall a. Ptr (GSList a) -> IO ()
    g_slist_free Ptr (GSList (Ptr ()))
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        [Ptr ()] -> IO [Ptr ()]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Ptr ()]
    result'

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

    instance O.OverloadedMethodInfo ObjectGetAttributesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetAttributes",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m T.Text
        -- ^ __Returns:__ a character string representing the accessible description
        -- of the accessible.
    objectGetDescription :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Text
    objectGetDescription a
    accessible = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    result <- Ptr Object -> IO CString
    atk_object_get_description Ptr Object
    accessible'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectGetDescription" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

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

    instance O.OverloadedMethodInfo ObjectGetDescriptionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetDescription",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v:objectGetDescription"
            })

    #endif

    -- method Object::get_help_text
    -- 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

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

    -- | Gets the help text associated with the accessible.
    --
    -- /Since: 2.52/
    objectGetHelpText ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
        -> m T.Text
        -- ^ __Returns:__ a character string representing the help text or the object, or
        -- NULL if no such string was set.
    objectGetHelpText :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Text
    objectGetHelpText a
    accessible = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    result <- Ptr Object -> IO CString
    atk_object_get_help_text Ptr Object
    accessible'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectGetHelpText" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data ObjectGetHelpTextMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetHelpTextMethodInfo a signature where
        overloadedMethod = objectGetHelpText

    instance O.OverloadedMethodInfo ObjectGetHelpTextMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetHelpText",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v:objectGetHelpText"
            })

    #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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m Int32
        -- ^ __Returns:__ an integer which is the index of the accessible in its parent
    objectGetIndexInParent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Int32
    objectGetIndexInParent a
    accessible = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Int32
    result <- Ptr Object -> IO Int32
    atk_object_get_index_in_parent Ptr Object
    accessible'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Int32 -> IO Int32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

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

    instance O.OverloadedMethodInfo ObjectGetIndexInParentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetIndexInParent",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m Atk.Enums.Layer
        -- ^ __Returns:__ an t'GI.Atk.Enums.Layer' which is the layer of the accessible
    objectGetLayer :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Layer
    objectGetLayer a
    accessible = IO Layer -> m Layer
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Layer -> m Layer) -> IO Layer -> m Layer
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CUInt
    result <- Ptr Object -> IO CUInt
    atk_object_get_layer Ptr Object
    accessible'
        let result' :: Layer
    result' = (Int -> Layer
    forall a. Enum a => Int -> a
    toEnum (Int -> Layer) -> (CUInt -> Int) -> CUInt -> Layer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Layer -> IO Layer
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Layer
    result'

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

    instance O.OverloadedMethodInfo ObjectGetLayerMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetLayer",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Int32
    objectGetMdiZorder a
    accessible = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Int32
    result <- Ptr Object -> IO Int32
    atk_object_get_mdi_zorder Ptr Object
    accessible'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Int32 -> IO Int32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

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

    instance O.OverloadedMethodInfo ObjectGetMdiZorderMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetMdiZorder",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m Int32
        -- ^ __Returns:__ an integer representing the number of accessible children
        -- of the accessible.
    objectGetNAccessibleChildren :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Int32
    objectGetNAccessibleChildren a
    accessible = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Int32
    result <- Ptr Object -> IO Int32
    atk_object_get_n_accessible_children Ptr Object
    accessible'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Int32 -> IO Int32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

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

    instance O.OverloadedMethodInfo ObjectGetNAccessibleChildrenMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetNAccessibleChildren",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m T.Text
        -- ^ __Returns:__ a character string representing the accessible name of the object.
    objectGetName :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Text
    objectGetName a
    accessible = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    result <- Ptr Object -> IO CString
    atk_object_get_name Ptr Object
    accessible'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectGetName" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

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

    instance O.OverloadedMethodInfo ObjectGetNameMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetName",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m T.Text
        -- ^ __Returns:__ a UTF-8 string indicating the POSIX-style LC_MESSAGES
        --          locale of /@accessible@/.
    objectGetObjectLocale :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Text
    objectGetObjectLocale a
    accessible = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    result <- Ptr Object -> IO CString
    atk_object_get_object_locale Ptr Object
    accessible'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectGetObjectLocale" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

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

    instance O.OverloadedMethodInfo ObjectGetObjectLocaleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetObjectLocale",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m Object
        -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the accessible
        -- parent of the accessible
    objectGetParent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Object
    objectGetParent a
    accessible = IO Object -> m Object
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Object -> m Object) -> IO Object -> m Object
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr Object
    result <- Ptr Object -> IO (Ptr Object)
    atk_object_get_parent Ptr Object
    accessible'
        Text -> Ptr Object -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectGetParent" Ptr Object
    result
        Object
    result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Object -> Object
    Object) Ptr Object
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Object -> IO Object
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result'

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

    instance O.OverloadedMethodInfo ObjectGetParentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetParent",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m Atk.Enums.Role
        -- ^ __Returns:__ an t'GI.Atk.Enums.Role' which is the role of the accessible
    objectGetRole :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Role
    objectGetRole a
    accessible = IO Role -> m Role
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Role -> m Role) -> IO Role -> m Role
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CUInt
    result <- Ptr Object -> IO CUInt
    atk_object_get_role Ptr Object
    accessible'
        let result' :: Role
    result' = (Int -> Role
    forall a. Enum a => Int -> a
    toEnum (Int -> Role) -> (CUInt -> Int) -> CUInt -> Role
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Role -> IO Role
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Role
    result'

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

    instance O.OverloadedMethodInfo ObjectGetRoleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectGetRole",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'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 t'GI.Atk.Objects.Object.Object'
    objectInitialize ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        -- ^ /@accessible@/: a t'GI.Atk.Objects.Object.Object'
        -> Ptr ()
        -- ^ /@data@/: a @/gpointer/@ which identifies the object for which the AtkObject was created.
        -> m ()
    objectInitialize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Ptr () -> m ()
    objectInitialize a
    accessible Ptr ()
    data_ = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        C_ObjectVisibleDataChangedCallback
    atk_object_initialize Ptr Object
    accessible' Ptr ()
    data_
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectInitializeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectInitialize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Word64 -> Bool -> m ()
    objectNotifyStateChange a
    accessible Word64
    state Bool
    value = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        let value' :: CInt
    value' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    value
        Ptr Object -> Word64 -> CInt -> IO ()
    atk_object_notify_state_change Ptr Object
    accessible' Word64
    state CInt
    value'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectNotifyStateChangeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectNotifyStateChange",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 'P.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 t'GI.Atk.Objects.Object.Object'
        -> m Object
        -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the accessible
        -- parent of the accessible if assigned
    objectPeekParent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m Object
    objectPeekParent a
    accessible = IO Object -> m Object
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Object -> m Object) -> IO Object -> m Object
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr Object
    result <- Ptr Object -> IO (Ptr Object)
    atk_object_peek_parent Ptr Object
    accessible'
        Text -> Ptr Object -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectPeekParent" Ptr Object
    result
        Object
    result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Object -> Object
    Object) Ptr Object
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Object -> IO Object
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result'

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

    instance O.OverloadedMethodInfo ObjectPeekParentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectPeekParent",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> Int32
        -- ^ /@i@/: a gint representing the position of the child, starting from 0
        -> m Object
        -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the specified
        -- accessible child of the accessible.
    objectRefAccessibleChild :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Int32 -> m Object
    objectRefAccessibleChild a
    accessible Int32
    i = IO Object -> m Object
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Object -> m Object) -> IO Object -> m Object
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr Object
    result <- Ptr Object -> Int32 -> IO (Ptr Object)
    atk_object_ref_accessible_child Ptr Object
    accessible' Int32
    i
        Text -> Ptr Object -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectRefAccessibleChild" Ptr Object
    result
        Object
    result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Object -> Object
    Object) Ptr Object
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        Object -> IO Object
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result'

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

    instance O.OverloadedMethodInfo ObjectRefAccessibleChildMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectRefAccessibleChild",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.RelationSet.RelationSet' associated with the object.
    objectRefRelationSet ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
        -> m Atk.RelationSet.RelationSet
        -- ^ __Returns:__ an t'GI.Atk.Objects.RelationSet.RelationSet' representing the relation set
        -- of the object.
    objectRefRelationSet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m RelationSet
    objectRefRelationSet a
    accessible = IO RelationSet -> m RelationSet
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO RelationSet -> m RelationSet)
    -> IO RelationSet -> m RelationSet
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr RelationSet
    result <- Ptr Object -> IO (Ptr RelationSet)
    atk_object_ref_relation_set Ptr Object
    accessible'
        Text -> Ptr RelationSet -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectRefRelationSet" Ptr RelationSet
    result
        RelationSet
    result' <- ((ManagedPtr RelationSet -> RelationSet)
    -> Ptr RelationSet -> IO RelationSet
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr RelationSet -> RelationSet
    Atk.RelationSet.RelationSet) Ptr RelationSet
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        RelationSet -> IO RelationSet
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return RelationSet
    result'

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

    instance O.OverloadedMethodInfo ObjectRefRelationSetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectRefRelationSet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> m Atk.StateSet.StateSet
        -- ^ __Returns:__ a reference to an t'GI.Atk.Objects.StateSet.StateSet' which is the state
        -- set of the accessible
    objectRefStateSet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> m StateSet
    objectRefStateSet a
    accessible = IO StateSet -> m StateSet
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO StateSet -> m StateSet) -> IO StateSet -> m StateSet
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr StateSet
    result <- Ptr Object -> IO (Ptr StateSet)
    atk_object_ref_state_set Ptr Object
    accessible'
        Text -> Ptr StateSet -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "objectRefStateSet" Ptr StateSet
    result
        StateSet
    result' <- ((ManagedPtr StateSet -> StateSet) -> Ptr StateSet -> IO StateSet
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr StateSet -> StateSet
    Atk.StateSet.StateSet) Ptr StateSet
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        StateSet -> IO StateSet
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return StateSet
    result'

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

    instance O.OverloadedMethodInfo ObjectRefStateSetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectRefStateSet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> Word32
        -- ^ /@handlerId@/: a guint which identifies the handler to be removed.
        -> m ()
    objectRemovePropertyChangeHandler :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Word32 -> m ()
    objectRemovePropertyChangeHandler a
    accessible Word32
    handlerId = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr Object -> Word32 -> IO ()
    atk_object_remove_property_change_handler Ptr Object
    accessible' Word32
    handlerId
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectRemovePropertyChangeHandlerMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectRemovePropertyChangeHandler",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object' from which an AtkRelation is to be removed.
        -> Atk.Enums.RelationType
        -- ^ /@relationship@/: The t'GI.Atk.Enums.RelationType' of the relation
        -> b
        -- ^ /@target@/: The t'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 :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a -> RelationType -> b -> m Bool
    objectRemoveRelationship a
    object RelationType
    relationship b
    target = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    object' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    object
        let relationship' :: CUInt
    relationship' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (RelationType -> Int) -> RelationType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RelationType -> Int
    forall a. Enum a => a -> Int
    fromEnum) RelationType
    relationship
        Ptr Object
    target' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    target
        CInt
    result <- Ptr Object -> CUInt -> Ptr Object -> IO CInt
    atk_object_remove_relationship Ptr Object
    object' CUInt
    relationship' Ptr Object
    target'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    object
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    target
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

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

    instance O.OverloadedMethodInfo ObjectRemoveRelationshipMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectRemoveRelationship",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "id"
    --           , 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
    --           , argCallbackUserData = 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 ->                              -- id : 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 t'GI.Atk.Objects.Object.Object'
        -> T.Text
        -- ^ /@id@/: a character string to be set as the accessible id
        -> m ()
    objectSetAccessibleId :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Text -> m ()
    objectSetAccessibleId a
    accessible Text
    id = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    id' <- Text -> IO CString
    textToCString Text
    id
        Ptr Object -> CString -> IO ()
    atk_object_set_accessible_id Ptr Object
    accessible' CString
    id'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    id'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectSetAccessibleIdMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectSetAccessibleId",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> T.Text
        -- ^ /@description@/: a character string to be set as the accessible description
        -> m ()
    objectSetDescription :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Text -> m ()
    objectSetDescription a
    accessible Text
    description = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    description' <- Text -> IO CString
    textToCString Text
    description
        Ptr Object -> CString -> IO ()
    atk_object_set_description Ptr Object
    accessible' CString
    description'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    description'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectSetDescriptionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectSetDescription",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v:objectSetDescription"
            })

    #endif

    -- method Object::set_help_text
    -- 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "help_text"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a character string to be set as the accessible's help text"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    -- | Sets the help text associated with the accessible. This can be used to
    -- expose context-sensitive information to help a user understand how to
    -- interact with the object. You can\'t set the help text to NULL.
    -- This is reserved for the initial value. If you want to set the name to
    -- an empty value, you can use \"\".
    --
    -- /Since: 2.52/
    objectSetHelpText ::
        (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
        a
        -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
        -> T.Text
        -- ^ /@helpText@/: a character string to be set as the accessible\'s help text
        -> m ()
    objectSetHelpText :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Text -> m ()
    objectSetHelpText a
    accessible Text
    helpText = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    helpText' <- Text -> IO CString
    textToCString Text
    helpText
        Ptr Object -> CString -> IO ()
    atk_object_set_help_text Ptr Object
    accessible' CString
    helpText'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    helpText'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ObjectSetHelpTextMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectSetHelpTextMethodInfo a signature where
        overloadedMethod = objectSetHelpText

    instance O.OverloadedMethodInfo ObjectSetHelpTextMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectSetHelpText",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v:objectSetHelpText"
            })

    #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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> T.Text
        -- ^ /@name@/: a character string to be set as the accessible name
        -> m ()
    objectSetName :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Text -> m ()
    objectSetName a
    accessible Text
    name = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        Ptr Object -> CString -> IO ()
    atk_object_set_name Ptr Object
    accessible' CString
    name'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectSetNameMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectSetName",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> b
        -- ^ /@parent@/: an t'GI.Atk.Objects.Object.Object' to be set as the accessible parent
        -> m ()
    objectSetParent :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a -> b -> m ()
    objectSetParent a
    accessible b
    parent = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        Ptr Object
    parent' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    parent
        Ptr Object -> Ptr Object -> IO ()
    atk_object_set_parent Ptr Object
    accessible' Ptr Object
    parent'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    parent
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectSetParentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectSetParent",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v: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
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = 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 t'GI.Atk.Objects.Object.Object'
        -> Atk.Enums.Role
        -- ^ /@role@/: an t'GI.Atk.Enums.Role' to be set as the role
        -> m ()
    objectSetRole :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Role -> m ()
    objectSetRole a
    accessible Role
    role = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    accessible' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    accessible
        let role' :: CUInt
    role' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (Role -> Int) -> Role -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Role -> Int
    forall a. Enum a => a -> Int
    fromEnum) Role
    role
        Ptr Object -> CUInt -> IO ()
    atk_object_set_role Ptr Object
    accessible' CUInt
    role'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    accessible
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    instance O.OverloadedMethodInfo ObjectSetRoleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Object.objectSetRole",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Object.html#v:objectSetRole"
            })

    #endif