    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- t'GI.Atk.Interfaces.Table.Table' should be implemented by components which present
    -- elements ordered via rows and columns.  It may also be used to
    -- present tree-structured information if the nodes of the trees can
    -- be said to contain multiple \"columns\".  Individual elements of an
    -- t'GI.Atk.Interfaces.Table.Table' are typically referred to as \"cells\". Those cells should
    -- implement the interface t'GI.Atk.Interfaces.TableCell.TableCell', but @/Atk/@ doesn\'t require
    -- them to be direct children of the current t'GI.Atk.Interfaces.Table.Table'. They can be
    -- grand-children, grand-grand-children etc. t'GI.Atk.Interfaces.Table.Table' provides the
    -- API needed to get a individual cell based on the row and column
    -- numbers.
    --
    -- Children of t'GI.Atk.Interfaces.Table.Table' are frequently \"lightweight\" objects, that
    -- is, they may not have backing widgets in the host UI toolkit.  They
    -- are therefore often transient.
    --
    -- Since tables are often very complex, t'GI.Atk.Interfaces.Table.Table' includes provision
    -- for offering simplified summary information, as well as row and
    -- column headers and captions.  Headers and captions are @/AtkObjects/@
    -- which may implement other interfaces (t'GI.Atk.Interfaces.Text.Text', t'GI.Atk.Interfaces.Image.Image', etc.) as
    -- appropriate.  t'GI.Atk.Interfaces.Table.Table' summaries may themselves be (simplified)
    -- @/AtkTables/@, etc.
    --
    -- Note for implementors: in the past, t'GI.Atk.Interfaces.Table.Table' required that all the
    -- cells should be direct children of t'GI.Atk.Interfaces.Table.Table', and provided some
    -- index based methods to request the cells. The practice showed that
    -- that forcing made t'GI.Atk.Interfaces.Table.Table' implementation complex, and hard to
    -- expose other kind of children, like rows or captions. Right now,
    -- index-based methods are deprecated.

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

    module GI.Atk.Interfaces.Table
        (

    -- * Exported types
        Table(..)                               ,
        IsTable                                 ,
        toTable                                 ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveTableMethod                      ,
    #endif

    -- ** addColumnSelection #method:addColumnSelection#

    #if defined(ENABLE_OVERLOADING)
        TableAddColumnSelectionMethodInfo       ,
    #endif
        tableAddColumnSelection                 ,

    -- ** addRowSelection #method:addRowSelection#

    #if defined(ENABLE_OVERLOADING)
        TableAddRowSelectionMethodInfo          ,
    #endif
        tableAddRowSelection                    ,

    -- ** getCaption #method:getCaption#

    #if defined(ENABLE_OVERLOADING)
        TableGetCaptionMethodInfo               ,
    #endif
        tableGetCaption                         ,

    -- ** getColumnAtIndex #method:getColumnAtIndex#

    #if defined(ENABLE_OVERLOADING)
        TableGetColumnAtIndexMethodInfo         ,
    #endif
        tableGetColumnAtIndex                   ,

    -- ** getColumnDescription #method:getColumnDescription#

    #if defined(ENABLE_OVERLOADING)
        TableGetColumnDescriptionMethodInfo     ,
    #endif
        tableGetColumnDescription               ,

    -- ** getColumnExtentAt #method:getColumnExtentAt#

    #if defined(ENABLE_OVERLOADING)
        TableGetColumnExtentAtMethodInfo        ,
    #endif
        tableGetColumnExtentAt                  ,

    -- ** getColumnHeader #method:getColumnHeader#

    #if defined(ENABLE_OVERLOADING)
        TableGetColumnHeaderMethodInfo          ,
    #endif
        tableGetColumnHeader                    ,

    -- ** getIndexAt #method:getIndexAt#

    #if defined(ENABLE_OVERLOADING)
        TableGetIndexAtMethodInfo               ,
    #endif
        tableGetIndexAt                         ,

    -- ** getNColumns #method:getNColumns#

    #if defined(ENABLE_OVERLOADING)
        TableGetNColumnsMethodInfo              ,
    #endif
        tableGetNColumns                        ,

    -- ** getNRows #method:getNRows#

    #if defined(ENABLE_OVERLOADING)
        TableGetNRowsMethodInfo                 ,
    #endif
        tableGetNRows                           ,

    -- ** getRowAtIndex #method:getRowAtIndex#

    #if defined(ENABLE_OVERLOADING)
        TableGetRowAtIndexMethodInfo            ,
    #endif
        tableGetRowAtIndex                      ,

    -- ** getRowDescription #method:getRowDescription#

    #if defined(ENABLE_OVERLOADING)
        TableGetRowDescriptionMethodInfo        ,
    #endif
        tableGetRowDescription                  ,

    -- ** getRowExtentAt #method:getRowExtentAt#

    #if defined(ENABLE_OVERLOADING)
        TableGetRowExtentAtMethodInfo           ,
    #endif
        tableGetRowExtentAt                     ,

    -- ** getRowHeader #method:getRowHeader#

    #if defined(ENABLE_OVERLOADING)
        TableGetRowHeaderMethodInfo             ,
    #endif
        tableGetRowHeader                       ,

    -- ** getSelectedColumns #method:getSelectedColumns#

    #if defined(ENABLE_OVERLOADING)
        TableGetSelectedColumnsMethodInfo       ,
    #endif
        tableGetSelectedColumns                 ,

    -- ** getSelectedRows #method:getSelectedRows#

    #if defined(ENABLE_OVERLOADING)
        TableGetSelectedRowsMethodInfo          ,
    #endif
        tableGetSelectedRows                    ,

    -- ** getSummary #method:getSummary#

    #if defined(ENABLE_OVERLOADING)
        TableGetSummaryMethodInfo               ,
    #endif
        tableGetSummary                         ,

    -- ** isColumnSelected #method:isColumnSelected#

    #if defined(ENABLE_OVERLOADING)
        TableIsColumnSelectedMethodInfo         ,
    #endif
        tableIsColumnSelected                   ,

    -- ** isRowSelected #method:isRowSelected#

    #if defined(ENABLE_OVERLOADING)
        TableIsRowSelectedMethodInfo            ,
    #endif
        tableIsRowSelected                      ,

    -- ** isSelected #method:isSelected#

    #if defined(ENABLE_OVERLOADING)
        TableIsSelectedMethodInfo               ,
    #endif
        tableIsSelected                         ,

    -- ** refAt #method:refAt#

    #if defined(ENABLE_OVERLOADING)
        TableRefAtMethodInfo                    ,
    #endif
        tableRefAt                              ,

    -- ** removeColumnSelection #method:removeColumnSelection#

    #if defined(ENABLE_OVERLOADING)
        TableRemoveColumnSelectionMethodInfo    ,
    #endif
        tableRemoveColumnSelection              ,

    -- ** removeRowSelection #method:removeRowSelection#

    #if defined(ENABLE_OVERLOADING)
        TableRemoveRowSelectionMethodInfo       ,
    #endif
        tableRemoveRowSelection                 ,

    -- ** setCaption #method:setCaption#

    #if defined(ENABLE_OVERLOADING)
        TableSetCaptionMethodInfo               ,
    #endif
        tableSetCaption                         ,

    -- ** setColumnDescription #method:setColumnDescription#

    #if defined(ENABLE_OVERLOADING)
        TableSetColumnDescriptionMethodInfo     ,
    #endif
        tableSetColumnDescription               ,

    -- ** setColumnHeader #method:setColumnHeader#

    #if defined(ENABLE_OVERLOADING)
        TableSetColumnHeaderMethodInfo          ,
    #endif
        tableSetColumnHeader                    ,

    -- ** setRowDescription #method:setRowDescription#

    #if defined(ENABLE_OVERLOADING)
        TableSetRowDescriptionMethodInfo        ,
    #endif
        tableSetRowDescription                  ,

    -- ** setRowHeader #method:setRowHeader#

    #if defined(ENABLE_OVERLOADING)
        TableSetRowHeaderMethodInfo             ,
    #endif
        tableSetRowHeader                       ,

    -- ** setSummary #method:setSummary#

    #if defined(ENABLE_OVERLOADING)
        TableSetSummaryMethodInfo               ,
    #endif
        tableSetSummary                         ,

     -- * Signals
    -- ** columnDeleted #signal:columnDeleted#

        C_TableColumnDeletedCallback            ,
        TableColumnDeletedCallback              ,
    #if defined(ENABLE_OVERLOADING)
        TableColumnDeletedSignalInfo            ,
    #endif
        afterTableColumnDeleted                 ,
        genClosure_TableColumnDeleted           ,
        mk_TableColumnDeletedCallback           ,
        noTableColumnDeletedCallback            ,
        onTableColumnDeleted                    ,
        wrap_TableColumnDeletedCallback         ,

    -- ** columnInserted #signal:columnInserted#

        C_TableColumnInsertedCallback           ,
        TableColumnInsertedCallback             ,
    #if defined(ENABLE_OVERLOADING)
        TableColumnInsertedSignalInfo           ,
    #endif
        afterTableColumnInserted                ,
        genClosure_TableColumnInserted          ,
        mk_TableColumnInsertedCallback          ,
        noTableColumnInsertedCallback           ,
        onTableColumnInserted                   ,
        wrap_TableColumnInsertedCallback        ,

    -- ** columnReordered #signal:columnReordered#

        C_TableColumnReorderedCallback          ,
        TableColumnReorderedCallback            ,
    #if defined(ENABLE_OVERLOADING)
        TableColumnReorderedSignalInfo          ,
    #endif
        afterTableColumnReordered               ,
        genClosure_TableColumnReordered         ,
        mk_TableColumnReorderedCallback         ,
        noTableColumnReorderedCallback          ,
        onTableColumnReordered                  ,
        wrap_TableColumnReorderedCallback       ,

    -- ** modelChanged #signal:modelChanged#

        C_TableModelChangedCallback             ,
        TableModelChangedCallback               ,
    #if defined(ENABLE_OVERLOADING)
        TableModelChangedSignalInfo             ,
    #endif
        afterTableModelChanged                  ,
        genClosure_TableModelChanged            ,
        mk_TableModelChangedCallback            ,
        noTableModelChangedCallback             ,
        onTableModelChanged                     ,
        wrap_TableModelChangedCallback          ,

    -- ** rowDeleted #signal:rowDeleted#

        C_TableRowDeletedCallback               ,
        TableRowDeletedCallback                 ,
    #if defined(ENABLE_OVERLOADING)
        TableRowDeletedSignalInfo               ,
    #endif
        afterTableRowDeleted                    ,
        genClosure_TableRowDeleted              ,
        mk_TableRowDeletedCallback              ,
        noTableRowDeletedCallback               ,
        onTableRowDeleted                       ,
        wrap_TableRowDeletedCallback            ,

    -- ** rowInserted #signal:rowInserted#

        C_TableRowInsertedCallback              ,
        TableRowInsertedCallback                ,
    #if defined(ENABLE_OVERLOADING)
        TableRowInsertedSignalInfo              ,
    #endif
        afterTableRowInserted                   ,
        genClosure_TableRowInserted             ,
        mk_TableRowInsertedCallback             ,
        noTableRowInsertedCallback              ,
        onTableRowInserted                      ,
        wrap_TableRowInsertedCallback           ,

    -- ** rowReordered #signal:rowReordered#

        C_TableRowReorderedCallback             ,
        TableRowReorderedCallback               ,
    #if defined(ENABLE_OVERLOADING)
        TableRowReorderedSignalInfo             ,
    #endif
        afterTableRowReordered                  ,
        genClosure_TableRowReordered            ,
        mk_TableRowReorderedCallback            ,
        noTableRowReorderedCallback             ,
        onTableRowReordered                     ,
        wrap_TableRowReorderedCallback          ,

        ) 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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
    import qualified GI.GObject.Objects.Object as GObject.Object

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

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

    foreign import ccall "atk_table_get_type"
        c_atk_table_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Table where
        glibType :: IO GType
    glibType = IO GType
    c_atk_table_get_type

    instance B.Types.GObject Table

    -- | Convert 'Table' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue Table where
        toGValue :: Table -> IO GValue
    toGValue o :: Table
    o = do
            GType
    gtype <- IO GType
    c_atk_table_get_type
            Table -> (Ptr Table -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Table
    o (GType -> (GValue -> Ptr Table -> IO ()) -> Ptr Table -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr Table -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO Table
    fromGValue gv :: GValue
    gv = do
            Ptr Table
    ptr <- GValue -> IO (Ptr Table)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr Table)
            (ManagedPtr Table -> Table) -> Ptr Table -> IO Table
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr Table -> Table
    Table Ptr Table
    ptr

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveTableMethod (t :: Symbol) (o :: *) :: * where
        ResolveTableMethod "addColumnSelection" o = TableAddColumnSelectionMethodInfo
        ResolveTableMethod "addRowSelection" o = TableAddRowSelectionMethodInfo
        ResolveTableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTableMethod "isColumnSelected" o = TableIsColumnSelectedMethodInfo
        ResolveTableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTableMethod "isRowSelected" o = TableIsRowSelectedMethodInfo
        ResolveTableMethod "isSelected" o = TableIsSelectedMethodInfo
        ResolveTableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTableMethod "refAt" o = TableRefAtMethodInfo
        ResolveTableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTableMethod "removeColumnSelection" o = TableRemoveColumnSelectionMethodInfo
        ResolveTableMethod "removeRowSelection" o = TableRemoveRowSelectionMethodInfo
        ResolveTableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTableMethod "getCaption" o = TableGetCaptionMethodInfo
        ResolveTableMethod "getColumnAtIndex" o = TableGetColumnAtIndexMethodInfo
        ResolveTableMethod "getColumnDescription" o = TableGetColumnDescriptionMethodInfo
        ResolveTableMethod "getColumnExtentAt" o = TableGetColumnExtentAtMethodInfo
        ResolveTableMethod "getColumnHeader" o = TableGetColumnHeaderMethodInfo
        ResolveTableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTableMethod "getIndexAt" o = TableGetIndexAtMethodInfo
        ResolveTableMethod "getNColumns" o = TableGetNColumnsMethodInfo
        ResolveTableMethod "getNRows" o = TableGetNRowsMethodInfo
        ResolveTableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTableMethod "getRowAtIndex" o = TableGetRowAtIndexMethodInfo
        ResolveTableMethod "getRowDescription" o = TableGetRowDescriptionMethodInfo
        ResolveTableMethod "getRowExtentAt" o = TableGetRowExtentAtMethodInfo
        ResolveTableMethod "getRowHeader" o = TableGetRowHeaderMethodInfo
        ResolveTableMethod "getSelectedColumns" o = TableGetSelectedColumnsMethodInfo
        ResolveTableMethod "getSelectedRows" o = TableGetSelectedRowsMethodInfo
        ResolveTableMethod "getSummary" o = TableGetSummaryMethodInfo
        ResolveTableMethod "setCaption" o = TableSetCaptionMethodInfo
        ResolveTableMethod "setColumnDescription" o = TableSetColumnDescriptionMethodInfo
        ResolveTableMethod "setColumnHeader" o = TableSetColumnHeaderMethodInfo
        ResolveTableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveTableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTableMethod "setRowDescription" o = TableSetRowDescriptionMethodInfo
        ResolveTableMethod "setRowHeader" o = TableSetRowHeaderMethodInfo
        ResolveTableMethod "setSummary" o = TableSetSummaryMethodInfo
        ResolveTableMethod l o = O.MethodResolutionFailed l o

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

    #endif

    -- method Table::add_column_selection
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_add_column_selection" atk_table_add_column_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    -- | Adds the specified /@column@/ to the selection.
    tableAddColumnSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if the column was successfully added to
        -- the selection, or 0 if value does not implement this interface.
    tableAddColumnSelection :: a -> Int32 -> m Bool
    tableAddColumnSelection table :: a
    table column :: Int32
    column = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> IO CInt
    atk_table_add_column_selection Ptr Table
    table' Int32
    column
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableAddColumnSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableAddColumnSelectionMethodInfo a signature where
        overloadedMethod = tableAddColumnSelection

    #endif

    -- method Table::add_row_selection
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_add_row_selection" atk_table_add_row_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CInt

    -- | Adds the specified /@row@/ to the selection.
    tableAddRowSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if row was successfully added to selection,
        -- or 0 if value does not implement this interface.
    tableAddRowSelection :: a -> Int32 -> m Bool
    tableAddRowSelection table :: a
    table row :: Int32
    row = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> IO CInt
    atk_table_add_row_selection Ptr Table
    table' Int32
    row
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableAddRowSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableAddRowSelectionMethodInfo a signature where
        overloadedMethod = tableAddRowSelection

    #endif

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

    foreign import ccall "atk_table_get_caption" atk_table_get_caption ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO (Ptr Atk.Object.Object)

    -- | Gets the caption for the /@table@/.
    tableGetCaption ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableInterface
        -> m (Maybe Atk.Object.Object)
        -- ^ __Returns:__ a AtkObject* representing the
        -- table caption, or 'P.Nothing' if value does not implement this interface.
    tableGetCaption :: a -> m (Maybe Object)
    tableGetCaption table :: a
    table = IO (Maybe Object) -> m (Maybe Object)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    result <- Ptr Table -> IO (Ptr Object)
    atk_table_get_caption Ptr Table
    table'
        Maybe Object
    maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Object
    result ((Ptr Object -> IO Object) -> IO (Maybe Object))
    -> (Ptr Object -> IO Object) -> IO (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Object
    result' -> do
            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
    Atk.Object.Object) Ptr Object
    result'
            Object -> IO Object
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Maybe Object -> IO (Maybe Object)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Object
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TableGetCaptionMethodInfo
    instance (signature ~ (m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetCaptionMethodInfo a signature where
        overloadedMethod = tableGetCaption

    #endif

    -- method Table::get_column_at_index
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableInterface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "index_"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing an index in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_column_at_index" atk_table_get_column_at_index ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- index_ : TBasicType TInt
        IO Int32

    {-# DEPRECATED tableGetColumnAtIndex ["Since 2.12."] #-}
    -- | Gets a @/gint/@ representing the column at the specified /@index_@/.
    tableGetColumnAtIndex ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableInterface
        -> Int32
        -- ^ /@index_@/: a @/gint/@ representing an index in /@table@/
        -> m Int32
        -- ^ __Returns:__ a gint representing the column at the specified index,
        -- or -1 if the table does not implement this method.
    tableGetColumnAtIndex :: a -> Int32 -> m Int32
    tableGetColumnAtIndex table :: a
    table index_ :: Int32
    index_ = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> IO Int32
    atk_table_get_column_at_index Ptr Table
    table' Int32
    index_
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetColumnAtIndexMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnAtIndexMethodInfo a signature where
        overloadedMethod = tableGetColumnAtIndex

    #endif

    -- method Table::get_column_description
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_column_description" atk_table_get_column_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CString

    -- | Gets the description text of the specified /@column@/ in the table
    tableGetColumnDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m T.Text
        -- ^ __Returns:__ a gchar* representing the column description, or 'P.Nothing'
        -- if value does not implement this interface.
    tableGetColumnDescription :: a -> Int32 -> m Text
    tableGetColumnDescription table :: a
    table column :: Int32
    column = IO Text -> m Text
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CString
    result <- Ptr Table -> Int32 -> IO CString
    atk_table_get_column_description Ptr Table
    table' Int32
    column
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "tableGetColumnDescription" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableGetColumnDescriptionMethodInfo
    instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnDescriptionMethodInfo a signature where
        overloadedMethod = tableGetColumnDescription

    #endif

    -- method Table::get_column_extent_at
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_column_extent_at" atk_table_get_column_extent_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO Int32

    -- | Gets the number of columns occupied by the accessible object
    -- at the specified /@row@/ and /@column@/ in the /@table@/.
    tableGetColumnExtentAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Int32
        -- ^ __Returns:__ a gint representing the column extent at specified position, or 0
        -- if value does not implement this interface.
    tableGetColumnExtentAt :: a -> Int32 -> Int32 -> m Int32
    tableGetColumnExtentAt table :: a
    table row :: Int32
    row column :: Int32
    column = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> Int32 -> IO Int32
    atk_table_get_column_extent_at Ptr Table
    table' Int32
    row Int32
    column
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetColumnExtentAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnExtentAtMethodInfo a signature where
        overloadedMethod = tableGetColumnExtentAt

    #endif

    -- method Table::get_column_header
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in the table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_column_header" atk_table_get_column_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO (Ptr Atk.Object.Object)

    -- | Gets the column header of a specified column in an accessible table.
    tableGetColumnHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in the table
        -> m (Maybe Atk.Object.Object)
        -- ^ __Returns:__ a AtkObject* representing the
        -- specified column header, or 'P.Nothing' if value does not implement this
        -- interface.
    tableGetColumnHeader :: a -> Int32 -> m (Maybe Object)
    tableGetColumnHeader table :: a
    table column :: Int32
    column = IO (Maybe Object) -> m (Maybe Object)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    result <- Ptr Table -> Int32 -> IO (Ptr Object)
    atk_table_get_column_header Ptr Table
    table' Int32
    column
        Maybe Object
    maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Object
    result ((Ptr Object -> IO Object) -> IO (Maybe Object))
    -> (Ptr Object -> IO Object) -> IO (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Object
    result' -> do
            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
    Atk.Object.Object) Ptr Object
    result'
            Object -> IO Object
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Maybe Object -> IO (Maybe Object)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Object
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TableGetColumnHeaderMethodInfo
    instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnHeaderMethodInfo a signature where
        overloadedMethod = tableGetColumnHeader

    #endif

    -- method Table::get_index_at
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_index_at" atk_table_get_index_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO Int32

    {-# DEPRECATED tableGetIndexAt ["Since 2.12. Use 'GI.Atk.Interfaces.Table.tableRefAt' in order to get the","accessible that represents the cell at (/@row@/, /@column@/)"] #-}
    -- | Gets a @/gint/@ representing the index at the specified /@row@/ and
    -- /@column@/.
    tableGetIndexAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Int32
        -- ^ __Returns:__ a @/gint/@ representing the index at specified position.
        -- The value -1 is returned if the object at row,column is not a child
        -- of table or table does not implement this interface.
    tableGetIndexAt :: a -> Int32 -> Int32 -> m Int32
    tableGetIndexAt table :: a
    table row :: Int32
    row column :: Int32
    column = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> Int32 -> IO Int32
    atk_table_get_index_at Ptr Table
    table' Int32
    row Int32
    column
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetIndexAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetIndexAtMethodInfo a signature where
        overloadedMethod = tableGetIndexAt

    #endif

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

    foreign import ccall "atk_table_get_n_columns" atk_table_get_n_columns ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO Int32

    -- | Gets the number of columns in the table.
    tableGetNColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> m Int32
        -- ^ __Returns:__ a gint representing the number of columns, or 0
        -- if value does not implement this interface.
    tableGetNColumns :: a -> m Int32
    tableGetNColumns table :: a
    table = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> IO Int32
    atk_table_get_n_columns Ptr Table
    table'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetNColumnsMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetNColumnsMethodInfo a signature where
        overloadedMethod = tableGetNColumns

    #endif

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

    foreign import ccall "atk_table_get_n_rows" atk_table_get_n_rows ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO Int32

    -- | Gets the number of rows in the table.
    tableGetNRows ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> m Int32
        -- ^ __Returns:__ a gint representing the number of rows, or 0
        -- if value does not implement this interface.
    tableGetNRows :: a -> m Int32
    tableGetNRows table :: a
    table = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> IO Int32
    atk_table_get_n_rows Ptr Table
    table'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetNRowsMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetNRowsMethodInfo a signature where
        overloadedMethod = tableGetNRows

    #endif

    -- method Table::get_row_at_index
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableInterface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "index_"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing an index in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_row_at_index" atk_table_get_row_at_index ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- index_ : TBasicType TInt
        IO Int32

    {-# DEPRECATED tableGetRowAtIndex ["since 2.12."] #-}
    -- | Gets a @/gint/@ representing the row at the specified /@index_@/.
    tableGetRowAtIndex ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableInterface
        -> Int32
        -- ^ /@index_@/: a @/gint/@ representing an index in /@table@/
        -> m Int32
        -- ^ __Returns:__ a gint representing the row at the specified index,
        -- or -1 if the table does not implement this method.
    tableGetRowAtIndex :: a -> Int32 -> m Int32
    tableGetRowAtIndex table :: a
    table index_ :: Int32
    index_ = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> IO Int32
    atk_table_get_row_at_index Ptr Table
    table' Int32
    index_
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetRowAtIndexMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetRowAtIndexMethodInfo a signature where
        overloadedMethod = tableGetRowAtIndex

    #endif

    -- method Table::get_row_description
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_row_description" atk_table_get_row_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CString

    -- | Gets the description text of the specified row in the table
    tableGetRowDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> m (Maybe T.Text)
        -- ^ __Returns:__ a gchar* representing the row description, or
        -- 'P.Nothing' if value does not implement this interface.
    tableGetRowDescription :: a -> Int32 -> m (Maybe Text)
    tableGetRowDescription table :: a
    table row :: Int32
    row = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CString
    result <- Ptr Table -> Int32 -> IO CString
    atk_table_get_row_description Ptr Table
    table' Int32
    row
        Maybe Text
    maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull CString
    result ((CString -> IO Text) -> IO (Maybe Text))
    -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \result' :: CString
    result' -> do
            Text
    result'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result'
            Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Maybe Text -> IO (Maybe Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TableGetRowDescriptionMethodInfo
    instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsTable a) => O.MethodInfo TableGetRowDescriptionMethodInfo a signature where
        overloadedMethod = tableGetRowDescription

    #endif

    -- method Table::get_row_extent_at
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_row_extent_at" atk_table_get_row_extent_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO Int32

    -- | Gets the number of rows occupied by the accessible object
    -- at a specified /@row@/ and /@column@/ in the /@table@/.
    tableGetRowExtentAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Int32
        -- ^ __Returns:__ a gint representing the row extent at specified position, or 0
        -- if value does not implement this interface.
    tableGetRowExtentAt :: a -> Int32 -> Int32 -> m Int32
    tableGetRowExtentAt table :: a
    table row :: Int32
    row column :: Int32
    column = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> Int32 -> IO Int32
    atk_table_get_row_extent_at Ptr Table
    table' Int32
    row Int32
    column
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetRowExtentAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetRowExtentAtMethodInfo a signature where
        overloadedMethod = tableGetRowExtentAt

    #endif

    -- method Table::get_row_header
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in the table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_row_header" atk_table_get_row_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO (Ptr Atk.Object.Object)

    -- | Gets the row header of a specified row in an accessible table.
    tableGetRowHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in the table
        -> m (Maybe Atk.Object.Object)
        -- ^ __Returns:__ a AtkObject* representing the
        -- specified row header, or 'P.Nothing' if value does not implement this
        -- interface.
    tableGetRowHeader :: a -> Int32 -> m (Maybe Object)
    tableGetRowHeader table :: a
    table row :: Int32
    row = IO (Maybe Object) -> m (Maybe Object)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    result <- Ptr Table -> Int32 -> IO (Ptr Object)
    atk_table_get_row_header Ptr Table
    table' Int32
    row
        Maybe Object
    maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Object
    result ((Ptr Object -> IO Object) -> IO (Maybe Object))
    -> (Ptr Object -> IO Object) -> IO (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Object
    result' -> do
            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
    Atk.Object.Object) Ptr Object
    result'
            Object -> IO Object
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Maybe Object -> IO (Maybe Object)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Object
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TableGetRowHeaderMethodInfo
    instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetRowHeaderMethodInfo a signature where
        overloadedMethod = tableGetRowHeader

    #endif

    -- method Table::get_selected_columns
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "selected"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #gint** that is to contain the selected columns numbers"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_selected_columns" atk_table_get_selected_columns ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- selected : TBasicType TInt
        IO Int32

    -- | Gets the selected columns of the table by initializing **selected with
    -- the selected column numbers. This array should be freed by the caller.
    tableGetSelectedColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@selected@/: a @/gint/@** that is to contain the selected columns numbers
        -> m Int32
        -- ^ __Returns:__ a gint representing the number of selected columns,
        -- or @/0/@ if value does not implement this interface.
    tableGetSelectedColumns :: a -> Int32 -> m Int32
    tableGetSelectedColumns table :: a
    table selected :: Int32
    selected = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> IO Int32
    atk_table_get_selected_columns Ptr Table
    table' Int32
    selected
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetSelectedColumnsMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetSelectedColumnsMethodInfo a signature where
        overloadedMethod = tableGetSelectedColumns

    #endif

    -- method Table::get_selected_rows
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "selected"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #gint** that is to contain the selected row numbers"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_get_selected_rows" atk_table_get_selected_rows ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- selected : TBasicType TInt
        IO Int32

    -- | Gets the selected rows of the table by initializing **selected with
    -- the selected row numbers. This array should be freed by the caller.
    tableGetSelectedRows ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@selected@/: a @/gint/@** that is to contain the selected row numbers
        -> m Int32
        -- ^ __Returns:__ a gint representing the number of selected rows,
        -- or zero if value does not implement this interface.
    tableGetSelectedRows :: a -> Int32 -> m Int32
    tableGetSelectedRows table :: a
    table selected :: Int32
    selected = IO Int32 -> m Int32
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Int32
    result <- Ptr Table -> Int32 -> IO Int32
    atk_table_get_selected_rows Ptr Table
    table' Int32
    selected
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data TableGetSelectedRowsMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetSelectedRowsMethodInfo a signature where
        overloadedMethod = tableGetSelectedRows

    #endif

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

    foreign import ccall "atk_table_get_summary" atk_table_get_summary ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO (Ptr Atk.Object.Object)

    -- | Gets the summary description of the table.
    tableGetSummary ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> m Atk.Object.Object
        -- ^ __Returns:__ a AtkObject* representing a summary description
        -- of the table, or zero if value does not implement this interface.
    tableGetSummary :: a -> m Object
    tableGetSummary table :: a
    table = IO Object -> m Object
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    result <- Ptr Table -> IO (Ptr Object)
    atk_table_get_summary Ptr Table
    table'
        Text -> Ptr Object -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "tableGetSummary" 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
    Atk.Object.Object) Ptr Object
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Object -> IO Object
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableGetSummaryMethodInfo
    instance (signature ~ (m Atk.Object.Object), MonadIO m, IsTable a) => O.MethodInfo TableGetSummaryMethodInfo a signature where
        overloadedMethod = tableGetSummary

    #endif

    -- method Table::is_column_selected
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_is_column_selected" atk_table_is_column_selected ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    -- | Gets a boolean value indicating whether the specified /@column@/
    -- is selected
    tableIsColumnSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if the column is selected, or 0
        -- if value does not implement this interface.
    tableIsColumnSelected :: a -> Int32 -> m Bool
    tableIsColumnSelected table :: a
    table column :: Int32
    column = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> IO CInt
    atk_table_is_column_selected Ptr Table
    table' Int32
    column
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableIsColumnSelectedMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsColumnSelectedMethodInfo a signature where
        overloadedMethod = tableIsColumnSelected

    #endif

    -- method Table::is_row_selected
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_is_row_selected" atk_table_is_row_selected ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CInt

    -- | Gets a boolean value indicating whether the specified /@row@/
    -- is selected
    tableIsRowSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if the row is selected, or 0
        -- if value does not implement this interface.
    tableIsRowSelected :: a -> Int32 -> m Bool
    tableIsRowSelected table :: a
    table row :: Int32
    row = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> IO CInt
    atk_table_is_row_selected Ptr Table
    table' Int32
    row
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableIsRowSelectedMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsRowSelectedMethodInfo a signature where
        overloadedMethod = tableIsRowSelected

    #endif

    -- method Table::is_selected
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_is_selected" atk_table_is_selected ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    -- | Gets a boolean value indicating whether the accessible object
    -- at the specified /@row@/ and /@column@/ is selected
    tableIsSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if the cell is selected, or 0
        -- if value does not implement this interface.
    tableIsSelected :: a -> Int32 -> Int32 -> m Bool
    tableIsSelected table :: a
    table row :: Int32
    row column :: Int32
    column = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> Int32 -> IO CInt
    atk_table_is_selected Ptr Table
    table' Int32
    row Int32
    column
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableIsSelectedMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsSelectedMethodInfo a signature where
        overloadedMethod = tableIsSelected

    #endif

    -- method Table::ref_at
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_ref_at" atk_table_ref_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO (Ptr Atk.Object.Object)

    -- | Get a reference to the table cell at /@row@/, /@column@/. This cell
    -- should implement the interface t'GI.Atk.Interfaces.TableCell.TableCell'
    tableRefAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Atk.Object.Object
        -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the referred
        -- to accessible
    tableRefAt :: a -> Int32 -> Int32 -> m Object
    tableRefAt table :: a
    table row :: Int32
    row column :: Int32
    column = IO Object -> m Object
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    result <- Ptr Table -> Int32 -> Int32 -> IO (Ptr Object)
    atk_table_ref_at Ptr Table
    table' Int32
    row Int32
    column
        Text -> Ptr Object -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "tableRefAt" 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
    Atk.Object.Object) Ptr Object
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Object -> IO Object
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableRefAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Atk.Object.Object), MonadIO m, IsTable a) => O.MethodInfo TableRefAtMethodInfo a signature where
        overloadedMethod = tableRefAt

    #endif

    -- method Table::remove_column_selection
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_remove_column_selection" atk_table_remove_column_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    -- | Adds the specified /@column@/ to the selection.
    tableRemoveColumnSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if the column was successfully removed from
        -- the selection, or 0 if value does not implement this interface.
    tableRemoveColumnSelection :: a -> Int32 -> m Bool
    tableRemoveColumnSelection table :: a
    table column :: Int32
    column = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> IO CInt
    atk_table_remove_column_selection Ptr Table
    table' Int32
    column
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableRemoveColumnSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableRemoveColumnSelectionMethodInfo a signature where
        overloadedMethod = tableRemoveColumnSelection

    #endif

    -- method Table::remove_row_selection
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_remove_row_selection" atk_table_remove_row_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CInt

    -- | Removes the specified /@row@/ from the selection.
    tableRemoveRowSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> m Bool
        -- ^ __Returns:__ a gboolean representing if the row was successfully removed from
        -- the selection, or 0 if value does not implement this interface.
    tableRemoveRowSelection :: a -> Int32 -> m Bool
    tableRemoveRowSelection table :: a
    table row :: Int32
    row = IO Bool -> m Bool
    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 Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CInt
    result <- Ptr Table -> Int32 -> IO CInt
    atk_table_remove_row_selection Ptr Table
    table' Int32
    row
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TableRemoveRowSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableRemoveRowSelectionMethodInfo a signature where
        overloadedMethod = tableRemoveRowSelection

    #endif

    -- method Table::set_caption
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "caption"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #AtkObject representing the caption to set for @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_caption" atk_table_set_caption ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Ptr Atk.Object.Object ->                -- caption : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    -- | Sets the caption for the table.
    tableSetCaption ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> b
        -- ^ /@caption@/: a t'GI.Atk.Objects.Object.Object' representing the caption to set for /@table@/
        -> m ()
    tableSetCaption :: a -> b -> m ()
    tableSetCaption table :: a
    table caption :: b
    caption = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    caption' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    caption
        Ptr Table -> Ptr Object -> IO ()
    atk_table_set_caption Ptr Table
    table' Ptr Object
    caption'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    caption
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TableSetCaptionMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetCaptionMethodInfo a signature where
        overloadedMethod = tableSetCaption

    #endif

    -- method Table::set_column_description
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "description"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #gchar representing the description text\nto set for the specified @column of the @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_column_description" atk_table_set_column_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        CString ->                              -- description : TBasicType TUTF8
        IO ()

    -- | Sets the description text for the specified /@column@/ of the /@table@/.
    tableSetColumnDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> T.Text
        -- ^ /@description@/: a @/gchar/@ representing the description text
        -- to set for the specified /@column@/ of the /@table@/
        -> m ()
    tableSetColumnDescription :: a -> Int32 -> Text -> m ()
    tableSetColumnDescription table :: a
    table column :: Int32
    column description :: Text
    description = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CString
    description' <- Text -> IO CString
    textToCString Text
    description
        Ptr Table -> Int32 -> CString -> IO ()
    atk_table_set_column_description Ptr Table
    table' Int32
    column CString
    description'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    description'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TableSetColumnDescriptionMethodInfo
    instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.MethodInfo TableSetColumnDescriptionMethodInfo a signature where
        overloadedMethod = tableSetColumnDescription

    #endif

    -- method Table::set_column_header
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a column in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "header"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an #AtkTable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_column_header" atk_table_set_column_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        Ptr Atk.Object.Object ->                -- header : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    -- | Sets the specified column header to /@header@/.
    tableSetColumnHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@column@/: a @/gint/@ representing a column in /@table@/
        -> b
        -- ^ /@header@/: an t'GI.Atk.Interfaces.Table.Table'
        -> m ()
    tableSetColumnHeader :: a -> Int32 -> b -> m ()
    tableSetColumnHeader table :: a
    table column :: Int32
    column header :: b
    header = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    header' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    header
        Ptr Table -> Int32 -> Ptr Object -> IO ()
    atk_table_set_column_header Ptr Table
    table' Int32
    column Ptr Object
    header'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    header
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TableSetColumnHeaderMethodInfo
    instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetColumnHeaderMethodInfo a signature where
        overloadedMethod = tableSetColumnHeader

    #endif

    -- method Table::set_row_description
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "description"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #gchar representing the description text\nto set for the specified @row of @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_row_description" atk_table_set_row_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        CString ->                              -- description : TBasicType TUTF8
        IO ()

    -- | Sets the description text for the specified /@row@/ of /@table@/.
    tableSetRowDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> T.Text
        -- ^ /@description@/: a @/gchar/@ representing the description text
        -- to set for the specified /@row@/ of /@table@/
        -> m ()
    tableSetRowDescription :: a -> Int32 -> Text -> m ()
    tableSetRowDescription table :: a
    table row :: Int32
    row description :: Text
    description = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        CString
    description' <- Text -> IO CString
    textToCString Text
    description
        Ptr Table -> Int32 -> CString -> IO ()
    atk_table_set_row_description Ptr Table
    table' Int32
    row CString
    description'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    description'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TableSetRowDescriptionMethodInfo
    instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.MethodInfo TableSetRowDescriptionMethodInfo a signature where
        overloadedMethod = tableSetRowDescription

    #endif

    -- method Table::set_row_header
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gint representing a row in @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "header"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an #AtkTable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_row_header" atk_table_set_row_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Ptr Atk.Object.Object ->                -- header : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    -- | Sets the specified row header to /@header@/.
    tableSetRowHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> Int32
        -- ^ /@row@/: a @/gint/@ representing a row in /@table@/
        -> b
        -- ^ /@header@/: an t'GI.Atk.Interfaces.Table.Table'
        -> m ()
    tableSetRowHeader :: a -> Int32 -> b -> m ()
    tableSetRowHeader table :: a
    table row :: Int32
    row header :: b
    header = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    header' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    header
        Ptr Table -> Int32 -> Ptr Object -> IO ()
    atk_table_set_row_header Ptr Table
    table' Int32
    row Ptr Object
    header'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    header
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TableSetRowHeaderMethodInfo
    instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetRowHeaderMethodInfo a signature where
        overloadedMethod = tableSetRowHeader

    #endif

    -- method Table::set_summary
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "table"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkTableIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "accessible"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "an #AtkObject representing the summary description\nto set for @table"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    -- | Sets the summary description of the table.
    tableSetSummary ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        -- ^ /@table@/: a GObject instance that implements AtkTableIface
        -> b
        -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object' representing the summary description
        -- to set for /@table@/
        -> m ()
    tableSetSummary :: a -> b -> m ()
    tableSetSummary table :: a
    table accessible :: b
    accessible = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Table
    table' <- a -> IO (Ptr Table)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    table
        Ptr Object
    accessible' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    accessible
        Ptr Table -> Ptr Object -> IO ()
    atk_table_set_summary Ptr Table
    table' Ptr Object
    accessible'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    table
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    accessible
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TableSetSummaryMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetSummaryMethodInfo a signature where
        overloadedMethod = tableSetSummary

    #endif

    -- signal Table::column-deleted
    -- | The \"column-deleted\" signal is emitted by an object which
    -- implements the AtkTable interface when a column is deleted.
    type TableColumnDeletedCallback =
        Int32
        -- ^ /@arg1@/: The index of the first column deleted.
        -> Int32
        -- ^ /@arg2@/: The number of columns deleted.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnDeletedCallback`@.
    noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback
    noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback
    noTableColumnDeletedCallback = Maybe TableColumnDeletedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableColumnDeleted :: MonadIO m => TableColumnDeletedCallback -> m (GClosure C_TableColumnDeletedCallback)
    genClosure_TableColumnDeleted :: TableColumnDeletedCallback
    -> m (GClosure C_TableColumnDeletedCallback)
    genClosure_TableColumnDeleted cb :: TableColumnDeletedCallback
    cb = IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnDeletedCallback)
     -> m (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnDeletedCallback TableColumnDeletedCallback
    cb
        C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
    cb' IO (FunPtr C_TableColumnDeletedCallback)
    -> (FunPtr C_TableColumnDeletedCallback
        -> IO (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableColumnDeletedCallback` into a `C_TableColumnDeletedCallback`.
    wrap_TableColumnDeletedCallback ::
        TableColumnDeletedCallback ->
        C_TableColumnDeletedCallback
    wrap_TableColumnDeletedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnDeletedCallback _cb :: TableColumnDeletedCallback
    _cb _ arg1 :: Int32
    arg1 arg2 :: Int32
    arg2 _ = do
        TableColumnDeletedCallback
    _cb  Int32
    arg1 Int32
    arg2

    -- | Connect a signal handler for the [columnDeleted](#signal:columnDeleted) 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' table #columnDeleted callback
    -- @
    --
    --
    onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
    onTableColumnDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    onTableColumnDeleted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnDeletedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "column-deleted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [columnDeleted](#signal:columnDeleted) 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' table #columnDeleted callback
    -- @
    --
    --
    afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
    afterTableColumnDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    afterTableColumnDeleted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnDeletedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "column-deleted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableColumnDeletedSignalInfo
    instance SignalInfo TableColumnDeletedSignalInfo where
        type HaskellCallbackType TableColumnDeletedSignalInfo = TableColumnDeletedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableColumnDeletedCallback cb
            cb'' <- mk_TableColumnDeletedCallback cb'
            connectSignalFunPtr obj "column-deleted" cb'' connectMode detail

    #endif

    -- signal Table::column-inserted
    -- | The \"column-inserted\" signal is emitted by an object which
    -- implements the AtkTable interface when a column is inserted.
    type TableColumnInsertedCallback =
        Int32
        -- ^ /@arg1@/: The index of the column inserted.
        -> Int32
        -- ^ /@arg2@/: The number of colums inserted.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnInsertedCallback`@.
    noTableColumnInsertedCallback :: Maybe TableColumnInsertedCallback
    noTableColumnInsertedCallback :: Maybe TableColumnDeletedCallback
    noTableColumnInsertedCallback = Maybe TableColumnDeletedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableColumnInserted :: MonadIO m => TableColumnInsertedCallback -> m (GClosure C_TableColumnInsertedCallback)
    genClosure_TableColumnInserted :: TableColumnDeletedCallback
    -> m (GClosure C_TableColumnDeletedCallback)
    genClosure_TableColumnInserted cb :: TableColumnDeletedCallback
    cb = IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnDeletedCallback)
     -> m (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnInsertedCallback TableColumnDeletedCallback
    cb
        C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
    cb' IO (FunPtr C_TableColumnDeletedCallback)
    -> (FunPtr C_TableColumnDeletedCallback
        -> IO (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableColumnInsertedCallback` into a `C_TableColumnInsertedCallback`.
    wrap_TableColumnInsertedCallback ::
        TableColumnInsertedCallback ->
        C_TableColumnInsertedCallback
    wrap_TableColumnInsertedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnInsertedCallback _cb :: TableColumnDeletedCallback
    _cb _ arg1 :: Int32
    arg1 arg2 :: Int32
    arg2 _ = do
        TableColumnDeletedCallback
    _cb  Int32
    arg1 Int32
    arg2

    -- | Connect a signal handler for the [columnInserted](#signal:columnInserted) 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' table #columnInserted callback
    -- @
    --
    --
    onTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
    onTableColumnInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    onTableColumnInserted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnInsertedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "column-inserted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [columnInserted](#signal:columnInserted) 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' table #columnInserted callback
    -- @
    --
    --
    afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
    afterTableColumnInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    afterTableColumnInserted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableColumnInsertedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "column-inserted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableColumnInsertedSignalInfo
    instance SignalInfo TableColumnInsertedSignalInfo where
        type HaskellCallbackType TableColumnInsertedSignalInfo = TableColumnInsertedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableColumnInsertedCallback cb
            cb'' <- mk_TableColumnInsertedCallback cb'
            connectSignalFunPtr obj "column-inserted" cb'' connectMode detail

    #endif

    -- signal Table::column-reordered
    -- | The \"column-reordered\" signal is emitted by an object which
    -- implements the AtkTable interface when the columns are
    -- reordered.
    type TableColumnReorderedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnReorderedCallback`@.
    noTableColumnReorderedCallback :: Maybe TableColumnReorderedCallback
    noTableColumnReorderedCallback :: Maybe (IO ())
    noTableColumnReorderedCallback = Maybe (IO ())
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableColumnReordered :: MonadIO m => TableColumnReorderedCallback -> m (GClosure C_TableColumnReorderedCallback)
    genClosure_TableColumnReordered :: IO () -> m (GClosure C_TableColumnReorderedCallback)
    genClosure_TableColumnReordered cb :: IO ()
    cb = IO (GClosure C_TableColumnReorderedCallback)
    -> m (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnReorderedCallback)
     -> m (GClosure C_TableColumnReorderedCallback))
    -> IO (GClosure C_TableColumnReorderedCallback)
    -> m (GClosure C_TableColumnReorderedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableColumnReorderedCallback IO ()
    cb
        C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
    cb' IO (FunPtr C_TableColumnReorderedCallback)
    -> (FunPtr C_TableColumnReorderedCallback
        -> IO (GClosure C_TableColumnReorderedCallback))
    -> IO (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnReorderedCallback
    -> IO (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableColumnReorderedCallback` into a `C_TableColumnReorderedCallback`.
    wrap_TableColumnReorderedCallback ::
        TableColumnReorderedCallback ->
        C_TableColumnReorderedCallback
    wrap_TableColumnReorderedCallback :: IO () -> C_TableColumnReorderedCallback
    wrap_TableColumnReorderedCallback _cb :: IO ()
    _cb _ _ = do
        IO ()
    _cb

    -- | Connect a signal handler for the [columnReordered](#signal:columnReordered) 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' table #columnReordered callback
    -- @
    --
    --
    onTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
    onTableColumnReordered :: a -> IO () -> m SignalHandlerId
    onTableColumnReordered obj :: a
    obj cb :: IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableColumnReorderedCallback IO ()
    cb
        FunPtr C_TableColumnReorderedCallback
    cb'' <- C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnReorderedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "column-reordered" FunPtr C_TableColumnReorderedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [columnReordered](#signal:columnReordered) 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' table #columnReordered callback
    -- @
    --
    --
    afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
    afterTableColumnReordered :: a -> IO () -> m SignalHandlerId
    afterTableColumnReordered obj :: a
    obj cb :: IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableColumnReorderedCallback IO ()
    cb
        FunPtr C_TableColumnReorderedCallback
    cb'' <- C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnReorderedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "column-reordered" FunPtr C_TableColumnReorderedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableColumnReorderedSignalInfo
    instance SignalInfo TableColumnReorderedSignalInfo where
        type HaskellCallbackType TableColumnReorderedSignalInfo = TableColumnReorderedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableColumnReorderedCallback cb
            cb'' <- mk_TableColumnReorderedCallback cb'
            connectSignalFunPtr obj "column-reordered" cb'' connectMode detail

    #endif

    -- signal Table::model-changed
    -- | The \"model-changed\" signal is emitted by an object which
    -- implements the AtkTable interface when the model displayed by
    -- the table changes.
    type TableModelChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableModelChangedCallback`@.
    noTableModelChangedCallback :: Maybe TableModelChangedCallback
    noTableModelChangedCallback :: Maybe (IO ())
    noTableModelChangedCallback = Maybe (IO ())
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableModelChanged :: MonadIO m => TableModelChangedCallback -> m (GClosure C_TableModelChangedCallback)
    genClosure_TableModelChanged :: IO () -> m (GClosure C_TableColumnReorderedCallback)
    genClosure_TableModelChanged cb :: IO ()
    cb = IO (GClosure C_TableColumnReorderedCallback)
    -> m (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnReorderedCallback)
     -> m (GClosure C_TableColumnReorderedCallback))
    -> IO (GClosure C_TableColumnReorderedCallback)
    -> m (GClosure C_TableColumnReorderedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableModelChangedCallback IO ()
    cb
        C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableModelChangedCallback C_TableColumnReorderedCallback
    cb' IO (FunPtr C_TableColumnReorderedCallback)
    -> (FunPtr C_TableColumnReorderedCallback
        -> IO (GClosure C_TableColumnReorderedCallback))
    -> IO (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnReorderedCallback
    -> IO (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableModelChangedCallback` into a `C_TableModelChangedCallback`.
    wrap_TableModelChangedCallback ::
        TableModelChangedCallback ->
        C_TableModelChangedCallback
    wrap_TableModelChangedCallback :: IO () -> C_TableColumnReorderedCallback
    wrap_TableModelChangedCallback _cb :: IO ()
    _cb _ _ = do
        IO ()
    _cb

    -- | Connect a signal handler for the [modelChanged](#signal:modelChanged) 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' table #modelChanged callback
    -- @
    --
    --
    onTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
    onTableModelChanged :: a -> IO () -> m SignalHandlerId
    onTableModelChanged obj :: a
    obj cb :: IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableModelChangedCallback IO ()
    cb
        FunPtr C_TableColumnReorderedCallback
    cb'' <- C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableModelChangedCallback C_TableColumnReorderedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnReorderedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "model-changed" FunPtr C_TableColumnReorderedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [modelChanged](#signal:modelChanged) 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' table #modelChanged callback
    -- @
    --
    --
    afterTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
    afterTableModelChanged :: a -> IO () -> m SignalHandlerId
    afterTableModelChanged obj :: a
    obj cb :: IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableModelChangedCallback IO ()
    cb
        FunPtr C_TableColumnReorderedCallback
    cb'' <- C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableModelChangedCallback C_TableColumnReorderedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnReorderedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "model-changed" FunPtr C_TableColumnReorderedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableModelChangedSignalInfo
    instance SignalInfo TableModelChangedSignalInfo where
        type HaskellCallbackType TableModelChangedSignalInfo = TableModelChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableModelChangedCallback cb
            cb'' <- mk_TableModelChangedCallback cb'
            connectSignalFunPtr obj "model-changed" cb'' connectMode detail

    #endif

    -- signal Table::row-deleted
    -- | The \"row-deleted\" signal is emitted by an object which
    -- implements the AtkTable interface when a row is deleted.
    type TableRowDeletedCallback =
        Int32
        -- ^ /@arg1@/: The index of the first row deleted.
        -> Int32
        -- ^ /@arg2@/: The number of rows deleted.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowDeletedCallback`@.
    noTableRowDeletedCallback :: Maybe TableRowDeletedCallback
    noTableRowDeletedCallback :: Maybe TableColumnDeletedCallback
    noTableRowDeletedCallback = Maybe TableColumnDeletedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableRowDeleted :: MonadIO m => TableRowDeletedCallback -> m (GClosure C_TableRowDeletedCallback)
    genClosure_TableRowDeleted :: TableColumnDeletedCallback
    -> m (GClosure C_TableColumnDeletedCallback)
    genClosure_TableRowDeleted cb :: TableColumnDeletedCallback
    cb = IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnDeletedCallback)
     -> m (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowDeletedCallback TableColumnDeletedCallback
    cb
        C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableRowDeletedCallback C_TableColumnDeletedCallback
    cb' IO (FunPtr C_TableColumnDeletedCallback)
    -> (FunPtr C_TableColumnDeletedCallback
        -> IO (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableRowDeletedCallback` into a `C_TableRowDeletedCallback`.
    wrap_TableRowDeletedCallback ::
        TableRowDeletedCallback ->
        C_TableRowDeletedCallback
    wrap_TableRowDeletedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowDeletedCallback _cb :: TableColumnDeletedCallback
    _cb _ arg1 :: Int32
    arg1 arg2 :: Int32
    arg2 _ = do
        TableColumnDeletedCallback
    _cb  Int32
    arg1 Int32
    arg2

    -- | Connect a signal handler for the [rowDeleted](#signal:rowDeleted) 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' table #rowDeleted callback
    -- @
    --
    --
    onTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
    onTableRowDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    onTableRowDeleted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowDeletedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableRowDeletedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "row-deleted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [rowDeleted](#signal:rowDeleted) 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' table #rowDeleted callback
    -- @
    --
    --
    afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
    afterTableRowDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    afterTableRowDeleted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowDeletedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableRowDeletedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "row-deleted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableRowDeletedSignalInfo
    instance SignalInfo TableRowDeletedSignalInfo where
        type HaskellCallbackType TableRowDeletedSignalInfo = TableRowDeletedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableRowDeletedCallback cb
            cb'' <- mk_TableRowDeletedCallback cb'
            connectSignalFunPtr obj "row-deleted" cb'' connectMode detail

    #endif

    -- signal Table::row-inserted
    -- | The \"row-inserted\" signal is emitted by an object which
    -- implements the AtkTable interface when a row is inserted.
    type TableRowInsertedCallback =
        Int32
        -- ^ /@arg1@/: The index of the first row inserted.
        -> Int32
        -- ^ /@arg2@/: The number of rows inserted.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowInsertedCallback`@.
    noTableRowInsertedCallback :: Maybe TableRowInsertedCallback
    noTableRowInsertedCallback :: Maybe TableColumnDeletedCallback
    noTableRowInsertedCallback = Maybe TableColumnDeletedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableRowInserted :: MonadIO m => TableRowInsertedCallback -> m (GClosure C_TableRowInsertedCallback)
    genClosure_TableRowInserted :: TableColumnDeletedCallback
    -> m (GClosure C_TableColumnDeletedCallback)
    genClosure_TableRowInserted cb :: TableColumnDeletedCallback
    cb = IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnDeletedCallback)
     -> m (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    -> m (GClosure C_TableColumnDeletedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowInsertedCallback TableColumnDeletedCallback
    cb
        C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableRowInsertedCallback C_TableColumnDeletedCallback
    cb' IO (FunPtr C_TableColumnDeletedCallback)
    -> (FunPtr C_TableColumnDeletedCallback
        -> IO (GClosure C_TableColumnDeletedCallback))
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableRowInsertedCallback` into a `C_TableRowInsertedCallback`.
    wrap_TableRowInsertedCallback ::
        TableRowInsertedCallback ->
        C_TableRowInsertedCallback
    wrap_TableRowInsertedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowInsertedCallback _cb :: TableColumnDeletedCallback
    _cb _ arg1 :: Int32
    arg1 arg2 :: Int32
    arg2 _ = do
        TableColumnDeletedCallback
    _cb  Int32
    arg1 Int32
    arg2

    -- | Connect a signal handler for the [rowInserted](#signal:rowInserted) 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' table #rowInserted callback
    -- @
    --
    --
    onTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
    onTableRowInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    onTableRowInserted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowInsertedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableRowInsertedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "row-inserted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [rowInserted](#signal:rowInserted) 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' table #rowInserted callback
    -- @
    --
    --
    afterTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
    afterTableRowInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
    afterTableRowInserted obj :: a
    obj cb :: TableColumnDeletedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnDeletedCallback
    cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
    wrap_TableRowInsertedCallback TableColumnDeletedCallback
    cb
        FunPtr C_TableColumnDeletedCallback
    cb'' <- C_TableColumnDeletedCallback
    -> IO (FunPtr C_TableColumnDeletedCallback)
    mk_TableRowInsertedCallback C_TableColumnDeletedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnDeletedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "row-inserted" FunPtr C_TableColumnDeletedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableRowInsertedSignalInfo
    instance SignalInfo TableRowInsertedSignalInfo where
        type HaskellCallbackType TableRowInsertedSignalInfo = TableRowInsertedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableRowInsertedCallback cb
            cb'' <- mk_TableRowInsertedCallback cb'
            connectSignalFunPtr obj "row-inserted" cb'' connectMode detail

    #endif

    -- signal Table::row-reordered
    -- | The \"row-reordered\" signal is emitted by an object which
    -- implements the AtkTable interface when the rows are
    -- reordered.
    type TableRowReorderedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowReorderedCallback`@.
    noTableRowReorderedCallback :: Maybe TableRowReorderedCallback
    noTableRowReorderedCallback :: Maybe (IO ())
    noTableRowReorderedCallback = Maybe (IO ())
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_TableRowReordered :: MonadIO m => TableRowReorderedCallback -> m (GClosure C_TableRowReorderedCallback)
    genClosure_TableRowReordered :: IO () -> m (GClosure C_TableColumnReorderedCallback)
    genClosure_TableRowReordered cb :: IO ()
    cb = IO (GClosure C_TableColumnReorderedCallback)
    -> m (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_TableColumnReorderedCallback)
     -> m (GClosure C_TableColumnReorderedCallback))
    -> IO (GClosure C_TableColumnReorderedCallback)
    -> m (GClosure C_TableColumnReorderedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableRowReorderedCallback IO ()
    cb
        C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableRowReorderedCallback C_TableColumnReorderedCallback
    cb' IO (FunPtr C_TableColumnReorderedCallback)
    -> (FunPtr C_TableColumnReorderedCallback
        -> IO (GClosure C_TableColumnReorderedCallback))
    -> IO (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_TableColumnReorderedCallback
    -> IO (GClosure C_TableColumnReorderedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `TableRowReorderedCallback` into a `C_TableRowReorderedCallback`.
    wrap_TableRowReorderedCallback ::
        TableRowReorderedCallback ->
        C_TableRowReorderedCallback
    wrap_TableRowReorderedCallback :: IO () -> C_TableColumnReorderedCallback
    wrap_TableRowReorderedCallback _cb :: IO ()
    _cb _ _ = do
        IO ()
    _cb

    -- | Connect a signal handler for the [rowReordered](#signal:rowReordered) 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' table #rowReordered callback
    -- @
    --
    --
    onTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
    onTableRowReordered :: a -> IO () -> m SignalHandlerId
    onTableRowReordered obj :: a
    obj cb :: IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableRowReorderedCallback IO ()
    cb
        FunPtr C_TableColumnReorderedCallback
    cb'' <- C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableRowReorderedCallback C_TableColumnReorderedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnReorderedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "row-reordered" FunPtr C_TableColumnReorderedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [rowReordered](#signal:rowReordered) 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' table #rowReordered callback
    -- @
    --
    --
    afterTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
    afterTableRowReordered :: a -> IO () -> m SignalHandlerId
    afterTableRowReordered obj :: a
    obj cb :: IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_TableColumnReorderedCallback
    cb' = IO () -> C_TableColumnReorderedCallback
    wrap_TableRowReorderedCallback IO ()
    cb
        FunPtr C_TableColumnReorderedCallback
    cb'' <- C_TableColumnReorderedCallback
    -> IO (FunPtr C_TableColumnReorderedCallback)
    mk_TableRowReorderedCallback C_TableColumnReorderedCallback
    cb'
        a
    -> Text
    -> FunPtr C_TableColumnReorderedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "row-reordered" FunPtr C_TableColumnReorderedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data TableRowReorderedSignalInfo
    instance SignalInfo TableRowReorderedSignalInfo where
        type HaskellCallbackType TableRowReorderedSignalInfo = TableRowReorderedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TableRowReorderedCallback cb
            cb'' <- mk_TableRowReorderedCallback cb'
            connectSignalFunPtr obj "row-reordered" cb'' connectMode detail

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Table = TableSignalList
    type TableSignalList = ('[ '("columnDeleted", TableColumnDeletedSignalInfo), '("columnInserted", TableColumnInsertedSignalInfo), '("columnReordered", TableColumnReorderedSignalInfo), '("modelChanged", TableModelChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowDeleted", TableRowDeletedSignalInfo), '("rowInserted", TableRowInsertedSignalInfo), '("rowReordered", TableRowReorderedSignalInfo)] :: [(Symbol, *)])

    #endif