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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A visible column in a t'GI.Gtk.Objects.TreeView.TreeView' widget
    --
    -- The @GtkTreeViewColumn@ object represents a visible column in a @GtkTreeView@ widget.
    -- It allows to set properties of the column header, and functions as a holding pen
    -- for the cell renderers which determine how the data in the column is displayed.
    --
    -- Please refer to the <https://docs.gtk.org/gtk4/section-tree-widget.html tree widget conceptual overview>
    -- for an overview of all the objects and data types related to the tree widget and
    -- how they work together, and to the t'GI.Gtk.Objects.TreeView.TreeView' documentation for specifics
    -- about the CSS node structure for treeviews and their headers.

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

    module GI.Gtk.Objects.TreeViewColumn
        (

    -- * Exported types
        TreeViewColumn(..)                      ,
        IsTreeViewColumn                        ,
        toTreeViewColumn                        ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [addAttribute]("GI.Gtk.Objects.TreeViewColumn#g:method:addAttribute"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [cellGetPosition]("GI.Gtk.Objects.TreeViewColumn#g:method:cellGetPosition"), [cellGetSize]("GI.Gtk.Objects.TreeViewColumn#g:method:cellGetSize"), [cellIsVisible]("GI.Gtk.Objects.TreeViewColumn#g:method:cellIsVisible"), [cellSetCellData]("GI.Gtk.Objects.TreeViewColumn#g:method:cellSetCellData"), [clear]("GI.Gtk.Objects.TreeViewColumn#g:method:clear"), [clearAttributes]("GI.Gtk.Objects.TreeViewColumn#g:method:clearAttributes"), [clicked]("GI.Gtk.Objects.TreeViewColumn#g:method:clicked"), [focusCell]("GI.Gtk.Objects.TreeViewColumn#g:method:focusCell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [packEnd]("GI.Gtk.Objects.TreeViewColumn#g:method:packEnd"), [packStart]("GI.Gtk.Objects.TreeViewColumn#g:method:packStart"), [queueResize]("GI.Gtk.Objects.TreeViewColumn#g:method:queueResize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reorder]("GI.Gtk.Interfaces.CellLayout#g:method:reorder"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAlignment]("GI.Gtk.Objects.TreeViewColumn#g:method:getAlignment"), [getArea]("GI.Gtk.Interfaces.CellLayout#g:method:getArea"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getButton]("GI.Gtk.Objects.TreeViewColumn#g:method:getButton"), [getCells]("GI.Gtk.Interfaces.CellLayout#g:method:getCells"), [getClickable]("GI.Gtk.Objects.TreeViewColumn#g:method:getClickable"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getExpand]("GI.Gtk.Objects.TreeViewColumn#g:method:getExpand"), [getFixedWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:getFixedWidth"), [getMaxWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:getMaxWidth"), [getMinWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:getMinWidth"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReorderable]("GI.Gtk.Objects.TreeViewColumn#g:method:getReorderable"), [getResizable]("GI.Gtk.Objects.TreeViewColumn#g:method:getResizable"), [getSizing]("GI.Gtk.Objects.TreeViewColumn#g:method:getSizing"), [getSortColumnId]("GI.Gtk.Objects.TreeViewColumn#g:method:getSortColumnId"), [getSortIndicator]("GI.Gtk.Objects.TreeViewColumn#g:method:getSortIndicator"), [getSortOrder]("GI.Gtk.Objects.TreeViewColumn#g:method:getSortOrder"), [getSpacing]("GI.Gtk.Objects.TreeViewColumn#g:method:getSpacing"), [getTitle]("GI.Gtk.Objects.TreeViewColumn#g:method:getTitle"), [getTreeView]("GI.Gtk.Objects.TreeViewColumn#g:method:getTreeView"), [getVisible]("GI.Gtk.Objects.TreeViewColumn#g:method:getVisible"), [getWidget]("GI.Gtk.Objects.TreeViewColumn#g:method:getWidget"), [getWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:getWidth"), [getXOffset]("GI.Gtk.Objects.TreeViewColumn#g:method:getXOffset").
    --
    -- ==== Setters
    -- [setAlignment]("GI.Gtk.Objects.TreeViewColumn#g:method:setAlignment"), [setCellDataFunc]("GI.Gtk.Objects.TreeViewColumn#g:method:setCellDataFunc"), [setClickable]("GI.Gtk.Objects.TreeViewColumn#g:method:setClickable"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setExpand]("GI.Gtk.Objects.TreeViewColumn#g:method:setExpand"), [setFixedWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:setFixedWidth"), [setMaxWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:setMaxWidth"), [setMinWidth]("GI.Gtk.Objects.TreeViewColumn#g:method:setMinWidth"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReorderable]("GI.Gtk.Objects.TreeViewColumn#g:method:setReorderable"), [setResizable]("GI.Gtk.Objects.TreeViewColumn#g:method:setResizable"), [setSizing]("GI.Gtk.Objects.TreeViewColumn#g:method:setSizing"), [setSortColumnId]("GI.Gtk.Objects.TreeViewColumn#g:method:setSortColumnId"), [setSortIndicator]("GI.Gtk.Objects.TreeViewColumn#g:method:setSortIndicator"), [setSortOrder]("GI.Gtk.Objects.TreeViewColumn#g:method:setSortOrder"), [setSpacing]("GI.Gtk.Objects.TreeViewColumn#g:method:setSpacing"), [setTitle]("GI.Gtk.Objects.TreeViewColumn#g:method:setTitle"), [setVisible]("GI.Gtk.Objects.TreeViewColumn#g:method:setVisible"), [setWidget]("GI.Gtk.Objects.TreeViewColumn#g:method:setWidget").

    #if defined(ENABLE_OVERLOADING)
        ResolveTreeViewColumnMethod             ,
    #endif

    -- ** addAttribute #method:addAttribute#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnAddAttributeMethodInfo    ,
    #endif
        treeViewColumnAddAttribute              ,

    -- ** cellGetPosition #method:cellGetPosition#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnCellGetPositionMethodInfo ,
    #endif
        treeViewColumnCellGetPosition           ,

    -- ** cellGetSize #method:cellGetSize#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnCellGetSizeMethodInfo     ,
    #endif
        treeViewColumnCellGetSize               ,

    -- ** cellIsVisible #method:cellIsVisible#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnCellIsVisibleMethodInfo   ,
    #endif
        treeViewColumnCellIsVisible             ,

    -- ** cellSetCellData #method:cellSetCellData#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnCellSetCellDataMethodInfo ,
    #endif
        treeViewColumnCellSetCellData           ,

    -- ** clear #method:clear#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnClearMethodInfo           ,
    #endif
        treeViewColumnClear                     ,

    -- ** clearAttributes #method:clearAttributes#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnClearAttributesMethodInfo ,
    #endif
        treeViewColumnClearAttributes           ,

    -- ** clicked #method:clicked#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnClickedMethodInfo         ,
    #endif
        treeViewColumnClicked                   ,

    -- ** focusCell #method:focusCell#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnFocusCellMethodInfo       ,
    #endif
        treeViewColumnFocusCell                 ,

    -- ** getAlignment #method:getAlignment#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetAlignmentMethodInfo    ,
    #endif
        treeViewColumnGetAlignment              ,

    -- ** getButton #method:getButton#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetButtonMethodInfo       ,
    #endif
        treeViewColumnGetButton                 ,

    -- ** getClickable #method:getClickable#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetClickableMethodInfo    ,
    #endif
        treeViewColumnGetClickable              ,

    -- ** getExpand #method:getExpand#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetExpandMethodInfo       ,
    #endif
        treeViewColumnGetExpand                 ,

    -- ** getFixedWidth #method:getFixedWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetFixedWidthMethodInfo   ,
    #endif
        treeViewColumnGetFixedWidth             ,

    -- ** getMaxWidth #method:getMaxWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetMaxWidthMethodInfo     ,
    #endif
        treeViewColumnGetMaxWidth               ,

    -- ** getMinWidth #method:getMinWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetMinWidthMethodInfo     ,
    #endif
        treeViewColumnGetMinWidth               ,

    -- ** getReorderable #method:getReorderable#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetReorderableMethodInfo  ,
    #endif
        treeViewColumnGetReorderable            ,

    -- ** getResizable #method:getResizable#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetResizableMethodInfo    ,
    #endif
        treeViewColumnGetResizable              ,

    -- ** getSizing #method:getSizing#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetSizingMethodInfo       ,
    #endif
        treeViewColumnGetSizing                 ,

    -- ** getSortColumnId #method:getSortColumnId#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetSortColumnIdMethodInfo ,
    #endif
        treeViewColumnGetSortColumnId           ,

    -- ** getSortIndicator #method:getSortIndicator#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetSortIndicatorMethodInfo,
    #endif
        treeViewColumnGetSortIndicator          ,

    -- ** getSortOrder #method:getSortOrder#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetSortOrderMethodInfo    ,
    #endif
        treeViewColumnGetSortOrder              ,

    -- ** getSpacing #method:getSpacing#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetSpacingMethodInfo      ,
    #endif
        treeViewColumnGetSpacing                ,

    -- ** getTitle #method:getTitle#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetTitleMethodInfo        ,
    #endif
        treeViewColumnGetTitle                  ,

    -- ** getTreeView #method:getTreeView#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetTreeViewMethodInfo     ,
    #endif
        treeViewColumnGetTreeView               ,

    -- ** getVisible #method:getVisible#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetVisibleMethodInfo      ,
    #endif
        treeViewColumnGetVisible                ,

    -- ** getWidget #method:getWidget#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetWidgetMethodInfo       ,
    #endif
        treeViewColumnGetWidget                 ,

    -- ** getWidth #method:getWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetWidthMethodInfo        ,
    #endif
        treeViewColumnGetWidth                  ,

    -- ** getXOffset #method:getXOffset#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnGetXOffsetMethodInfo      ,
    #endif
        treeViewColumnGetXOffset                ,

    -- ** new #method:new#

        treeViewColumnNew                       ,

    -- ** newWithArea #method:newWithArea#

        treeViewColumnNewWithArea               ,

    -- ** packEnd #method:packEnd#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnPackEndMethodInfo         ,
    #endif
        treeViewColumnPackEnd                   ,

    -- ** packStart #method:packStart#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnPackStartMethodInfo       ,
    #endif
        treeViewColumnPackStart                 ,

    -- ** queueResize #method:queueResize#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnQueueResizeMethodInfo     ,
    #endif
        treeViewColumnQueueResize               ,

    -- ** setAlignment #method:setAlignment#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetAlignmentMethodInfo    ,
    #endif
        treeViewColumnSetAlignment              ,

    -- ** setCellDataFunc #method:setCellDataFunc#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetCellDataFuncMethodInfo ,
    #endif
        treeViewColumnSetCellDataFunc           ,

    -- ** setClickable #method:setClickable#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetClickableMethodInfo    ,
    #endif
        treeViewColumnSetClickable              ,

    -- ** setExpand #method:setExpand#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetExpandMethodInfo       ,
    #endif
        treeViewColumnSetExpand                 ,

    -- ** setFixedWidth #method:setFixedWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetFixedWidthMethodInfo   ,
    #endif
        treeViewColumnSetFixedWidth             ,

    -- ** setMaxWidth #method:setMaxWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetMaxWidthMethodInfo     ,
    #endif
        treeViewColumnSetMaxWidth               ,

    -- ** setMinWidth #method:setMinWidth#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetMinWidthMethodInfo     ,
    #endif
        treeViewColumnSetMinWidth               ,

    -- ** setReorderable #method:setReorderable#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetReorderableMethodInfo  ,
    #endif
        treeViewColumnSetReorderable            ,

    -- ** setResizable #method:setResizable#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetResizableMethodInfo    ,
    #endif
        treeViewColumnSetResizable              ,

    -- ** setSizing #method:setSizing#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetSizingMethodInfo       ,
    #endif
        treeViewColumnSetSizing                 ,

    -- ** setSortColumnId #method:setSortColumnId#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetSortColumnIdMethodInfo ,
    #endif
        treeViewColumnSetSortColumnId           ,

    -- ** setSortIndicator #method:setSortIndicator#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetSortIndicatorMethodInfo,
    #endif
        treeViewColumnSetSortIndicator          ,

    -- ** setSortOrder #method:setSortOrder#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetSortOrderMethodInfo    ,
    #endif
        treeViewColumnSetSortOrder              ,

    -- ** setSpacing #method:setSpacing#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetSpacingMethodInfo      ,
    #endif
        treeViewColumnSetSpacing                ,

    -- ** setTitle #method:setTitle#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetTitleMethodInfo        ,
    #endif
        treeViewColumnSetTitle                  ,

    -- ** setVisible #method:setVisible#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetVisibleMethodInfo      ,
    #endif
        treeViewColumnSetVisible                ,

    -- ** setWidget #method:setWidget#

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSetWidgetMethodInfo       ,
    #endif
        treeViewColumnSetWidget                 ,

     -- * Properties

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnAlignmentPropertyInfo     ,
    #endif
        constructTreeViewColumnAlignment        ,
        getTreeViewColumnAlignment              ,
        setTreeViewColumnAlignment              ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnAlignment                 ,
    #endif

    -- ** cellArea #attr:cellArea#
    -- | The @GtkCellArea@ used to layout cell renderers for this column.
    --
    -- If no area is specified when creating the tree view column with 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnNewWithArea'
    -- a horizontally oriented @GtkCellAreaBox@ will be used.

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnCellAreaPropertyInfo      ,
    #endif
        constructTreeViewColumnCellArea         ,
        getTreeViewColumnCellArea               ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnCellArea                  ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnClickablePropertyInfo     ,
    #endif
        constructTreeViewColumnClickable        ,
        getTreeViewColumnClickable              ,
        setTreeViewColumnClickable              ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnClickable                 ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnExpandPropertyInfo        ,
    #endif
        constructTreeViewColumnExpand           ,
        getTreeViewColumnExpand                 ,
        setTreeViewColumnExpand                 ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnExpand                    ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnFixedWidthPropertyInfo    ,
    #endif
        constructTreeViewColumnFixedWidth       ,
        getTreeViewColumnFixedWidth             ,
        setTreeViewColumnFixedWidth             ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnFixedWidth                ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnMaxWidthPropertyInfo      ,
    #endif
        constructTreeViewColumnMaxWidth         ,
        getTreeViewColumnMaxWidth               ,
        setTreeViewColumnMaxWidth               ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnMaxWidth                  ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnMinWidthPropertyInfo      ,
    #endif
        constructTreeViewColumnMinWidth         ,
        getTreeViewColumnMinWidth               ,
        setTreeViewColumnMinWidth               ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnMinWidth                  ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnReorderablePropertyInfo   ,
    #endif
        constructTreeViewColumnReorderable      ,
        getTreeViewColumnReorderable            ,
        setTreeViewColumnReorderable            ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnReorderable               ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnResizablePropertyInfo     ,
    #endif
        constructTreeViewColumnResizable        ,
        getTreeViewColumnResizable              ,
        setTreeViewColumnResizable              ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnResizable                 ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSizingPropertyInfo        ,
    #endif
        constructTreeViewColumnSizing           ,
        getTreeViewColumnSizing                 ,
        setTreeViewColumnSizing                 ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnSizing                    ,
    #endif

    -- ** sortColumnId #attr:sortColumnId#
    -- | Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
    -- clickable. Set to -1 to make the column unsortable.

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSortColumnIdPropertyInfo  ,
    #endif
        constructTreeViewColumnSortColumnId     ,
        getTreeViewColumnSortColumnId           ,
        setTreeViewColumnSortColumnId           ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnSortColumnId              ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSortIndicatorPropertyInfo ,
    #endif
        constructTreeViewColumnSortIndicator    ,
        getTreeViewColumnSortIndicator          ,
        setTreeViewColumnSortIndicator          ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnSortIndicator             ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSortOrderPropertyInfo     ,
    #endif
        constructTreeViewColumnSortOrder        ,
        getTreeViewColumnSortOrder              ,
        setTreeViewColumnSortOrder              ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnSortOrder                 ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnSpacingPropertyInfo       ,
    #endif
        constructTreeViewColumnSpacing          ,
        getTreeViewColumnSpacing                ,
        setTreeViewColumnSpacing                ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnSpacing                   ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnTitlePropertyInfo         ,
    #endif
        constructTreeViewColumnTitle            ,
        getTreeViewColumnTitle                  ,
        setTreeViewColumnTitle                  ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnTitle                     ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnVisiblePropertyInfo       ,
    #endif
        constructTreeViewColumnVisible          ,
        getTreeViewColumnVisible                ,
        setTreeViewColumnVisible                ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnVisible                   ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnWidgetPropertyInfo        ,
    #endif
        clearTreeViewColumnWidget               ,
        constructTreeViewColumnWidget           ,
        getTreeViewColumnWidget                 ,
        setTreeViewColumnWidget                 ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnWidget                    ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnWidthPropertyInfo         ,
    #endif
        getTreeViewColumnWidth                  ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnWidth                     ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnXOffsetPropertyInfo       ,
    #endif
        getTreeViewColumnXOffset                ,
    #if defined(ENABLE_OVERLOADING)
        treeViewColumnXOffset                   ,
    #endif

     -- * Signals

    -- ** clicked #signal:clicked#

        TreeViewColumnClickedCallback           ,
    #if defined(ENABLE_OVERLOADING)
        TreeViewColumnClickedSignalInfo         ,
    #endif
        afterTreeViewColumnClicked              ,
        onTreeViewColumnClicked                 ,

        ) where

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

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

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
    import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import qualified GI.Gdk.Objects.Device as Gdk.Device
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.Event as Gdk.Event
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
    import qualified GI.Gdk.Objects.Surface as Gdk.Surface
    import qualified GI.Gdk.Objects.Texture as Gdk.Texture
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import qualified GI.Graphene.Structs.Point as Graphene.Point
    import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import qualified GI.Graphene.Structs.Size as Graphene.Size
    import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
    import qualified GI.Gsk.Enums as Gsk.Enums
    import qualified GI.Gsk.Flags as Gsk.Flags
    import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
    import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
    import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
    import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
    import qualified GI.Gsk.Structs.ComponentTransfer as Gsk.ComponentTransfer
    import qualified GI.Gsk.Structs.Path as Gsk.Path
    import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
    import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
    import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
    import qualified GI.Gsk.Structs.Transform as Gsk.Transform
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellLayout as Gtk.CellLayout
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellArea as Gtk.CellArea
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellAreaContext as Gtk.CellAreaContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer
    import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreePath as Gtk.TreePath
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Objects.Context as Pango.Context
    import qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import qualified GI.Pango.Objects.Layout as Pango.Layout

    #else
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellLayout as Gtk.CellLayout
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellArea as Gtk.CellArea
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter

    #endif

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

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

    foreign import ccall "gtk_tree_view_column_get_type"
        c_gtk_tree_view_column_get_type :: IO B.Types.GType

    instance B.Types.TypedObject TreeViewColumn where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tree_view_column_get_type

    instance B.Types.GObject TreeViewColumn

    -- | Type class for types which can be safely cast to t'TreeViewColumn', for instance with `toTreeViewColumn`.
    class (SP.GObject o, O.IsDescendantOf TreeViewColumn o) => IsTreeViewColumn o
    instance (SP.GObject o, O.IsDescendantOf TreeViewColumn o) => IsTreeViewColumn o

    instance O.HasParentTypes TreeViewColumn
    type instance O.ParentTypes TreeViewColumn = '[GObject.Object.Object, Gtk.Buildable.Buildable, Gtk.CellLayout.CellLayout]

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveTreeViewColumnMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveTreeViewColumnMethod "addAttribute" o = TreeViewColumnAddAttributeMethodInfo
        ResolveTreeViewColumnMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTreeViewColumnMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTreeViewColumnMethod "cellGetPosition" o = TreeViewColumnCellGetPositionMethodInfo
        ResolveTreeViewColumnMethod "cellGetSize" o = TreeViewColumnCellGetSizeMethodInfo
        ResolveTreeViewColumnMethod "cellIsVisible" o = TreeViewColumnCellIsVisibleMethodInfo
        ResolveTreeViewColumnMethod "cellSetCellData" o = TreeViewColumnCellSetCellDataMethodInfo
        ResolveTreeViewColumnMethod "clear" o = TreeViewColumnClearMethodInfo
        ResolveTreeViewColumnMethod "clearAttributes" o = TreeViewColumnClearAttributesMethodInfo
        ResolveTreeViewColumnMethod "clicked" o = TreeViewColumnClickedMethodInfo
        ResolveTreeViewColumnMethod "focusCell" o = TreeViewColumnFocusCellMethodInfo
        ResolveTreeViewColumnMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTreeViewColumnMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTreeViewColumnMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTreeViewColumnMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTreeViewColumnMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTreeViewColumnMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTreeViewColumnMethod "packEnd" o = TreeViewColumnPackEndMethodInfo
        ResolveTreeViewColumnMethod "packStart" o = TreeViewColumnPackStartMethodInfo
        ResolveTreeViewColumnMethod "queueResize" o = TreeViewColumnQueueResizeMethodInfo
        ResolveTreeViewColumnMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTreeViewColumnMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTreeViewColumnMethod "reorder" o = Gtk.CellLayout.CellLayoutReorderMethodInfo
        ResolveTreeViewColumnMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTreeViewColumnMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTreeViewColumnMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTreeViewColumnMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTreeViewColumnMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTreeViewColumnMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTreeViewColumnMethod "getAlignment" o = TreeViewColumnGetAlignmentMethodInfo
        ResolveTreeViewColumnMethod "getArea" o = Gtk.CellLayout.CellLayoutGetAreaMethodInfo
        ResolveTreeViewColumnMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
        ResolveTreeViewColumnMethod "getButton" o = TreeViewColumnGetButtonMethodInfo
        ResolveTreeViewColumnMethod "getCells" o = Gtk.CellLayout.CellLayoutGetCellsMethodInfo
        ResolveTreeViewColumnMethod "getClickable" o = TreeViewColumnGetClickableMethodInfo
        ResolveTreeViewColumnMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTreeViewColumnMethod "getExpand" o = TreeViewColumnGetExpandMethodInfo
        ResolveTreeViewColumnMethod "getFixedWidth" o = TreeViewColumnGetFixedWidthMethodInfo
        ResolveTreeViewColumnMethod "getMaxWidth" o = TreeViewColumnGetMaxWidthMethodInfo
        ResolveTreeViewColumnMethod "getMinWidth" o = TreeViewColumnGetMinWidthMethodInfo
        ResolveTreeViewColumnMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTreeViewColumnMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTreeViewColumnMethod "getReorderable" o = TreeViewColumnGetReorderableMethodInfo
        ResolveTreeViewColumnMethod "getResizable" o = TreeViewColumnGetResizableMethodInfo
        ResolveTreeViewColumnMethod "getSizing" o = TreeViewColumnGetSizingMethodInfo
        ResolveTreeViewColumnMethod "getSortColumnId" o = TreeViewColumnGetSortColumnIdMethodInfo
        ResolveTreeViewColumnMethod "getSortIndicator" o = TreeViewColumnGetSortIndicatorMethodInfo
        ResolveTreeViewColumnMethod "getSortOrder" o = TreeViewColumnGetSortOrderMethodInfo
        ResolveTreeViewColumnMethod "getSpacing" o = TreeViewColumnGetSpacingMethodInfo
        ResolveTreeViewColumnMethod "getTitle" o = TreeViewColumnGetTitleMethodInfo
        ResolveTreeViewColumnMethod "getTreeView" o = TreeViewColumnGetTreeViewMethodInfo
        ResolveTreeViewColumnMethod "getVisible" o = TreeViewColumnGetVisibleMethodInfo
        ResolveTreeViewColumnMethod "getWidget" o = TreeViewColumnGetWidgetMethodInfo
        ResolveTreeViewColumnMethod "getWidth" o = TreeViewColumnGetWidthMethodInfo
        ResolveTreeViewColumnMethod "getXOffset" o = TreeViewColumnGetXOffsetMethodInfo
        ResolveTreeViewColumnMethod "setAlignment" o = TreeViewColumnSetAlignmentMethodInfo
        ResolveTreeViewColumnMethod "setCellDataFunc" o = TreeViewColumnSetCellDataFuncMethodInfo
        ResolveTreeViewColumnMethod "setClickable" o = TreeViewColumnSetClickableMethodInfo
        ResolveTreeViewColumnMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTreeViewColumnMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveTreeViewColumnMethod "setExpand" o = TreeViewColumnSetExpandMethodInfo
        ResolveTreeViewColumnMethod "setFixedWidth" o = TreeViewColumnSetFixedWidthMethodInfo
        ResolveTreeViewColumnMethod "setMaxWidth" o = TreeViewColumnSetMaxWidthMethodInfo
        ResolveTreeViewColumnMethod "setMinWidth" o = TreeViewColumnSetMinWidthMethodInfo
        ResolveTreeViewColumnMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTreeViewColumnMethod "setReorderable" o = TreeViewColumnSetReorderableMethodInfo
        ResolveTreeViewColumnMethod "setResizable" o = TreeViewColumnSetResizableMethodInfo
        ResolveTreeViewColumnMethod "setSizing" o = TreeViewColumnSetSizingMethodInfo
        ResolveTreeViewColumnMethod "setSortColumnId" o = TreeViewColumnSetSortColumnIdMethodInfo
        ResolveTreeViewColumnMethod "setSortIndicator" o = TreeViewColumnSetSortIndicatorMethodInfo
        ResolveTreeViewColumnMethod "setSortOrder" o = TreeViewColumnSetSortOrderMethodInfo
        ResolveTreeViewColumnMethod "setSpacing" o = TreeViewColumnSetSpacingMethodInfo
        ResolveTreeViewColumnMethod "setTitle" o = TreeViewColumnSetTitleMethodInfo
        ResolveTreeViewColumnMethod "setVisible" o = TreeViewColumnSetVisibleMethodInfo
        ResolveTreeViewColumnMethod "setWidget" o = TreeViewColumnSetWidgetMethodInfo
        ResolveTreeViewColumnMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

    instance (info ~ ResolveTreeViewColumnMethod t TreeViewColumn, O.OverloadedMethodInfo info TreeViewColumn) => OL.IsLabel t (O.MethodProxy info TreeViewColumn) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif

    -- signal TreeViewColumn::clicked
    -- | Emitted when the column\'s header has been clicked.
    type TreeViewColumnClickedCallback =
        IO ()

    type C_TreeViewColumnClickedCallback =
        Ptr TreeViewColumn ->                   -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_TreeViewColumnClickedCallback ::
        GObject a => (a -> TreeViewColumnClickedCallback) ->
        C_TreeViewColumnClickedCallback
    wrap_TreeViewColumnClickedCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_TreeViewColumnClickedCallback
    wrap_TreeViewColumnClickedCallback a -> IO ()
    gi'cb Ptr TreeViewColumn
    gi'selfPtr Ptr ()
    _ = do
        Ptr TreeViewColumn -> (TreeViewColumn -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr TreeViewColumn
    gi'selfPtr ((TreeViewColumn -> IO ()) -> IO ())
    -> (TreeViewColumn -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \TreeViewColumn
    gi'self -> a -> IO ()
    gi'cb (TreeViewColumn -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce TreeViewColumn
    gi'self)

    -- | Connect a signal handler for the [clicked](#signal:clicked) 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' treeViewColumn #clicked callback
    -- @
    --
    --
    onTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId
    onTreeViewColumnClicked :: forall a (m :: * -> *).
    (IsTreeViewColumn a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onTreeViewColumnClicked a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_TreeViewColumnClickedCallback
    wrapped' = (a -> IO ()) -> C_TreeViewColumnClickedCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_TreeViewColumnClickedCallback
    wrap_TreeViewColumnClickedCallback a -> IO ()
    wrapped
        wrapped'' <- C_TreeViewColumnClickedCallback
    -> IO (FunPtr C_TreeViewColumnClickedCallback)
    mk_TreeViewColumnClickedCallback C_TreeViewColumnClickedCallback
    wrapped'
        connectSignalFunPtr obj "clicked" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [clicked](#signal:clicked) 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' treeViewColumn #clicked callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId
    afterTreeViewColumnClicked :: forall a (m :: * -> *).
    (IsTreeViewColumn a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterTreeViewColumnClicked a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_TreeViewColumnClickedCallback
    wrapped' = (a -> IO ()) -> C_TreeViewColumnClickedCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_TreeViewColumnClickedCallback
    wrap_TreeViewColumnClickedCallback a -> IO ()
    wrapped
        wrapped'' <- C_TreeViewColumnClickedCallback
    -> IO (FunPtr C_TreeViewColumnClickedCallback)
    mk_TreeViewColumnClickedCallback C_TreeViewColumnClickedCallback
    wrapped'
        connectSignalFunPtr obj "clicked" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnClickedSignalInfo
    instance SignalInfo TreeViewColumnClickedSignalInfo where
        type HaskellCallbackType TreeViewColumnClickedSignalInfo = TreeViewColumnClickedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_TreeViewColumnClickedCallback cb
            cb'' <- mk_TreeViewColumnClickedCallback cb'
            connectSignalFunPtr obj "clicked" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn::clicked"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:signal:clicked"})

    #endif

    -- VVV Prop "alignment"
       -- Type: TBasicType TFloat
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@alignment@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #alignment
    -- @
    getTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> m Float
    getTreeViewColumnAlignment :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Float
    getTreeViewColumnAlignment o
    obj = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Float
    forall a. GObject a => a -> String -> IO Float
    B.Properties.getObjectPropertyFloat o
    obj String
    "alignment"

    -- | Set the value of the “@alignment@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #alignment 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> Float -> m ()
    setTreeViewColumnAlignment :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Float -> m ()
    setTreeViewColumnAlignment o
    obj Float
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Float -> IO ()
    forall a. GObject a => a -> String -> Float -> IO ()
    B.Properties.setObjectPropertyFloat o
    obj String
    "alignment" Float
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@alignment@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnAlignment :: (IsTreeViewColumn o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
    constructTreeViewColumnAlignment :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Float -> m (GValueConstruct o)
    constructTreeViewColumnAlignment Float
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Float -> IO (GValueConstruct o)
    forall o. String -> Float -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyFloat String
    "alignment" Float
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnAlignmentPropertyInfo
    instance AttrInfo TreeViewColumnAlignmentPropertyInfo where
        type AttrAllowedOps TreeViewColumnAlignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnAlignmentPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnAlignmentPropertyInfo = (~) Float
        type AttrTransferTypeConstraint TreeViewColumnAlignmentPropertyInfo = (~) Float
        type AttrTransferType TreeViewColumnAlignmentPropertyInfo = Float
        type AttrGetType TreeViewColumnAlignmentPropertyInfo = Float
        type AttrLabel TreeViewColumnAlignmentPropertyInfo = "alignment"
        type AttrOrigin TreeViewColumnAlignmentPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnAlignment
        attrSet = setTreeViewColumnAlignment
        attrPut = setTreeViewColumnAlignment
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnAlignment
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.alignment"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:alignment"
            })
    #endif

    -- VVV Prop "cell-area"
       -- Type: TInterface (Name {namespace = "Gtk", name = "CellArea"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@cell-area@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #cellArea
    -- @
    getTreeViewColumnCellArea :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Gtk.CellArea.CellArea)
    getTreeViewColumnCellArea :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m (Maybe CellArea)
    getTreeViewColumnCellArea o
    obj = IO (Maybe CellArea) -> m (Maybe CellArea)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe CellArea) -> m (Maybe CellArea))
    -> IO (Maybe CellArea) -> m (Maybe CellArea)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr CellArea -> CellArea)
    -> IO (Maybe CellArea)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "cell-area" ManagedPtr CellArea -> CellArea
    Gtk.CellArea.CellArea

    -- | Construct a t'GValueConstruct' with valid value for the “@cell-area@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnCellArea :: (IsTreeViewColumn o, MIO.MonadIO m, Gtk.CellArea.IsCellArea a) => a -> m (GValueConstruct o)
    constructTreeViewColumnCellArea :: forall o (m :: * -> *) a.
    (IsTreeViewColumn o, MonadIO m, IsCellArea a) =>
    a -> m (GValueConstruct o)
    constructTreeViewColumnCellArea a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "cell-area" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnCellAreaPropertyInfo
    instance AttrInfo TreeViewColumnCellAreaPropertyInfo where
        type AttrAllowedOps TreeViewColumnCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint TreeViewColumnCellAreaPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
        type AttrTransferTypeConstraint TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
        type AttrTransferType TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.CellArea
        type AttrGetType TreeViewColumnCellAreaPropertyInfo = (Maybe Gtk.CellArea.CellArea)
        type AttrLabel TreeViewColumnCellAreaPropertyInfo = "cell-area"
        type AttrOrigin TreeViewColumnCellAreaPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnCellArea
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.CellArea.CellArea v
        attrConstruct = constructTreeViewColumnCellArea
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.cellArea"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:cellArea"
            })
    #endif

    -- VVV Prop "clickable"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@clickable@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #clickable
    -- @
    getTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
    getTreeViewColumnClickable :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Bool
    getTreeViewColumnClickable o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "clickable"

    -- | Set the value of the “@clickable@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #clickable 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
    setTreeViewColumnClickable :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Bool -> m ()
    setTreeViewColumnClickable o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "clickable" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@clickable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnClickable :: (IsTreeViewColumn o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTreeViewColumnClickable :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTreeViewColumnClickable Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "clickable" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnClickablePropertyInfo
    instance AttrInfo TreeViewColumnClickablePropertyInfo where
        type AttrAllowedOps TreeViewColumnClickablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnClickablePropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnClickablePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TreeViewColumnClickablePropertyInfo = (~) Bool
        type AttrTransferType TreeViewColumnClickablePropertyInfo = Bool
        type AttrGetType TreeViewColumnClickablePropertyInfo = Bool
        type AttrLabel TreeViewColumnClickablePropertyInfo = "clickable"
        type AttrOrigin TreeViewColumnClickablePropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnClickable
        attrSet = setTreeViewColumnClickable
        attrPut = setTreeViewColumnClickable
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnClickable
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.clickable"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:clickable"
            })
    #endif

    -- VVV Prop "expand"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@expand@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #expand
    -- @
    getTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
    getTreeViewColumnExpand :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Bool
    getTreeViewColumnExpand o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "expand"

    -- | Set the value of the “@expand@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #expand 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
    setTreeViewColumnExpand :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Bool -> m ()
    setTreeViewColumnExpand o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "expand" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@expand@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnExpand :: (IsTreeViewColumn o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTreeViewColumnExpand :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTreeViewColumnExpand Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "expand" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnExpandPropertyInfo
    instance AttrInfo TreeViewColumnExpandPropertyInfo where
        type AttrAllowedOps TreeViewColumnExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnExpandPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnExpandPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TreeViewColumnExpandPropertyInfo = (~) Bool
        type AttrTransferType TreeViewColumnExpandPropertyInfo = Bool
        type AttrGetType TreeViewColumnExpandPropertyInfo = Bool
        type AttrLabel TreeViewColumnExpandPropertyInfo = "expand"
        type AttrOrigin TreeViewColumnExpandPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnExpand
        attrSet = setTreeViewColumnExpand
        attrPut = setTreeViewColumnExpand
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnExpand
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.expand"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:expand"
            })
    #endif

    -- VVV Prop "fixed-width"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@fixed-width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #fixedWidth
    -- @
    getTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnFixedWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnFixedWidth o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "fixed-width"

    -- | Set the value of the “@fixed-width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #fixedWidth 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
    setTreeViewColumnFixedWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Int32 -> m ()
    setTreeViewColumnFixedWidth o
    obj Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "fixed-width" Int32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@fixed-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnFixedWidth :: (IsTreeViewColumn o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
    constructTreeViewColumnFixedWidth :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Int32 -> m (GValueConstruct o)
    constructTreeViewColumnFixedWidth Int32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Int32 -> IO (GValueConstruct o)
    forall o. String -> Int32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyInt32 String
    "fixed-width" Int32
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnFixedWidthPropertyInfo
    instance AttrInfo TreeViewColumnFixedWidthPropertyInfo where
        type AttrAllowedOps TreeViewColumnFixedWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnFixedWidthPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnFixedWidthPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint TreeViewColumnFixedWidthPropertyInfo = (~) Int32
        type AttrTransferType TreeViewColumnFixedWidthPropertyInfo = Int32
        type AttrGetType TreeViewColumnFixedWidthPropertyInfo = Int32
        type AttrLabel TreeViewColumnFixedWidthPropertyInfo = "fixed-width"
        type AttrOrigin TreeViewColumnFixedWidthPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnFixedWidth
        attrSet = setTreeViewColumnFixedWidth
        attrPut = setTreeViewColumnFixedWidth
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnFixedWidth
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.fixedWidth"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:fixedWidth"
            })
    #endif

    -- VVV Prop "max-width"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@max-width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #maxWidth
    -- @
    getTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnMaxWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnMaxWidth o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "max-width"

    -- | Set the value of the “@max-width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #maxWidth 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
    setTreeViewColumnMaxWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Int32 -> m ()
    setTreeViewColumnMaxWidth o
    obj Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "max-width" Int32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@max-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnMaxWidth :: (IsTreeViewColumn o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
    constructTreeViewColumnMaxWidth :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Int32 -> m (GValueConstruct o)
    constructTreeViewColumnMaxWidth Int32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Int32 -> IO (GValueConstruct o)
    forall o. String -> Int32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyInt32 String
    "max-width" Int32
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnMaxWidthPropertyInfo
    instance AttrInfo TreeViewColumnMaxWidthPropertyInfo where
        type AttrAllowedOps TreeViewColumnMaxWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnMaxWidthPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnMaxWidthPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint TreeViewColumnMaxWidthPropertyInfo = (~) Int32
        type AttrTransferType TreeViewColumnMaxWidthPropertyInfo = Int32
        type AttrGetType TreeViewColumnMaxWidthPropertyInfo = Int32
        type AttrLabel TreeViewColumnMaxWidthPropertyInfo = "max-width"
        type AttrOrigin TreeViewColumnMaxWidthPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnMaxWidth
        attrSet = setTreeViewColumnMaxWidth
        attrPut = setTreeViewColumnMaxWidth
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnMaxWidth
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.maxWidth"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:maxWidth"
            })
    #endif

    -- VVV Prop "min-width"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@min-width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #minWidth
    -- @
    getTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnMinWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnMinWidth o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "min-width"

    -- | Set the value of the “@min-width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #minWidth 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
    setTreeViewColumnMinWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Int32 -> m ()
    setTreeViewColumnMinWidth o
    obj Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "min-width" Int32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@min-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnMinWidth :: (IsTreeViewColumn o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
    constructTreeViewColumnMinWidth :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Int32 -> m (GValueConstruct o)
    constructTreeViewColumnMinWidth Int32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Int32 -> IO (GValueConstruct o)
    forall o. String -> Int32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyInt32 String
    "min-width" Int32
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnMinWidthPropertyInfo
    instance AttrInfo TreeViewColumnMinWidthPropertyInfo where
        type AttrAllowedOps TreeViewColumnMinWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnMinWidthPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnMinWidthPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint TreeViewColumnMinWidthPropertyInfo = (~) Int32
        type AttrTransferType TreeViewColumnMinWidthPropertyInfo = Int32
        type AttrGetType TreeViewColumnMinWidthPropertyInfo = Int32
        type AttrLabel TreeViewColumnMinWidthPropertyInfo = "min-width"
        type AttrOrigin TreeViewColumnMinWidthPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnMinWidth
        attrSet = setTreeViewColumnMinWidth
        attrPut = setTreeViewColumnMinWidth
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnMinWidth
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.minWidth"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:minWidth"
            })
    #endif

    -- VVV Prop "reorderable"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@reorderable@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #reorderable
    -- @
    getTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
    getTreeViewColumnReorderable :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Bool
    getTreeViewColumnReorderable o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "reorderable"

    -- | Set the value of the “@reorderable@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #reorderable 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
    setTreeViewColumnReorderable :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Bool -> m ()
    setTreeViewColumnReorderable o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "reorderable" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@reorderable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnReorderable :: (IsTreeViewColumn o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTreeViewColumnReorderable :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTreeViewColumnReorderable Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "reorderable" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnReorderablePropertyInfo
    instance AttrInfo TreeViewColumnReorderablePropertyInfo where
        type AttrAllowedOps TreeViewColumnReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnReorderablePropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnReorderablePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TreeViewColumnReorderablePropertyInfo = (~) Bool
        type AttrTransferType TreeViewColumnReorderablePropertyInfo = Bool
        type AttrGetType TreeViewColumnReorderablePropertyInfo = Bool
        type AttrLabel TreeViewColumnReorderablePropertyInfo = "reorderable"
        type AttrOrigin TreeViewColumnReorderablePropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnReorderable
        attrSet = setTreeViewColumnReorderable
        attrPut = setTreeViewColumnReorderable
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnReorderable
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.reorderable"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:reorderable"
            })
    #endif

    -- VVV Prop "resizable"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@resizable@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #resizable
    -- @
    getTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
    getTreeViewColumnResizable :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Bool
    getTreeViewColumnResizable o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "resizable"

    -- | Set the value of the “@resizable@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #resizable 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
    setTreeViewColumnResizable :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Bool -> m ()
    setTreeViewColumnResizable o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "resizable" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@resizable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnResizable :: (IsTreeViewColumn o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTreeViewColumnResizable :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTreeViewColumnResizable Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "resizable" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnResizablePropertyInfo
    instance AttrInfo TreeViewColumnResizablePropertyInfo where
        type AttrAllowedOps TreeViewColumnResizablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnResizablePropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnResizablePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TreeViewColumnResizablePropertyInfo = (~) Bool
        type AttrTransferType TreeViewColumnResizablePropertyInfo = Bool
        type AttrGetType TreeViewColumnResizablePropertyInfo = Bool
        type AttrLabel TreeViewColumnResizablePropertyInfo = "resizable"
        type AttrOrigin TreeViewColumnResizablePropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnResizable
        attrSet = setTreeViewColumnResizable
        attrPut = setTreeViewColumnResizable
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnResizable
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.resizable"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:resizable"
            })
    #endif

    -- VVV Prop "sizing"
       -- Type: TInterface (Name {namespace = "Gtk", name = "TreeViewColumnSizing"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@sizing@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #sizing
    -- @
    getTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> m Gtk.Enums.TreeViewColumnSizing
    getTreeViewColumnSizing :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m TreeViewColumnSizing
    getTreeViewColumnSizing o
    obj = IO TreeViewColumnSizing -> m TreeViewColumnSizing
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO TreeViewColumnSizing -> m TreeViewColumnSizing)
    -> IO TreeViewColumnSizing -> m TreeViewColumnSizing
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO TreeViewColumnSizing
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "sizing"

    -- | Set the value of the “@sizing@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #sizing 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> Gtk.Enums.TreeViewColumnSizing -> m ()
    setTreeViewColumnSizing :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> TreeViewColumnSizing -> m ()
    setTreeViewColumnSizing o
    obj TreeViewColumnSizing
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> TreeViewColumnSizing -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "sizing" TreeViewColumnSizing
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@sizing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnSizing :: (IsTreeViewColumn o, MIO.MonadIO m) => Gtk.Enums.TreeViewColumnSizing -> m (GValueConstruct o)
    constructTreeViewColumnSizing :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    TreeViewColumnSizing -> m (GValueConstruct o)
    constructTreeViewColumnSizing TreeViewColumnSizing
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> TreeViewColumnSizing -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "sizing" TreeViewColumnSizing
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSizingPropertyInfo
    instance AttrInfo TreeViewColumnSizingPropertyInfo where
        type AttrAllowedOps TreeViewColumnSizingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnSizingPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnSizingPropertyInfo = (~) Gtk.Enums.TreeViewColumnSizing
        type AttrTransferTypeConstraint TreeViewColumnSizingPropertyInfo = (~) Gtk.Enums.TreeViewColumnSizing
        type AttrTransferType TreeViewColumnSizingPropertyInfo = Gtk.Enums.TreeViewColumnSizing
        type AttrGetType TreeViewColumnSizingPropertyInfo = Gtk.Enums.TreeViewColumnSizing
        type AttrLabel TreeViewColumnSizingPropertyInfo = "sizing"
        type AttrOrigin TreeViewColumnSizingPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnSizing
        attrSet = setTreeViewColumnSizing
        attrPut = setTreeViewColumnSizing
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnSizing
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.sizing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:sizing"
            })
    #endif

    -- VVV Prop "sort-column-id"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@sort-column-id@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #sortColumnId
    -- @
    getTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnSortColumnId :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnSortColumnId o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "sort-column-id"

    -- | Set the value of the “@sort-column-id@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #sortColumnId 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
    setTreeViewColumnSortColumnId :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Int32 -> m ()
    setTreeViewColumnSortColumnId o
    obj Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "sort-column-id" Int32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@sort-column-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnSortColumnId :: (IsTreeViewColumn o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
    constructTreeViewColumnSortColumnId :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Int32 -> m (GValueConstruct o)
    constructTreeViewColumnSortColumnId Int32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Int32 -> IO (GValueConstruct o)
    forall o. String -> Int32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyInt32 String
    "sort-column-id" Int32
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSortColumnIdPropertyInfo
    instance AttrInfo TreeViewColumnSortColumnIdPropertyInfo where
        type AttrAllowedOps TreeViewColumnSortColumnIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = (~) Int32
        type AttrTransferType TreeViewColumnSortColumnIdPropertyInfo = Int32
        type AttrGetType TreeViewColumnSortColumnIdPropertyInfo = Int32
        type AttrLabel TreeViewColumnSortColumnIdPropertyInfo = "sort-column-id"
        type AttrOrigin TreeViewColumnSortColumnIdPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnSortColumnId
        attrSet = setTreeViewColumnSortColumnId
        attrPut = setTreeViewColumnSortColumnId
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnSortColumnId
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.sortColumnId"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:sortColumnId"
            })
    #endif

    -- VVV Prop "sort-indicator"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@sort-indicator@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #sortIndicator
    -- @
    getTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
    getTreeViewColumnSortIndicator :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Bool
    getTreeViewColumnSortIndicator o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "sort-indicator"

    -- | Set the value of the “@sort-indicator@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #sortIndicator 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
    setTreeViewColumnSortIndicator :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Bool -> m ()
    setTreeViewColumnSortIndicator o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "sort-indicator" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@sort-indicator@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnSortIndicator :: (IsTreeViewColumn o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTreeViewColumnSortIndicator :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTreeViewColumnSortIndicator Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "sort-indicator" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSortIndicatorPropertyInfo
    instance AttrInfo TreeViewColumnSortIndicatorPropertyInfo where
        type AttrAllowedOps TreeViewColumnSortIndicatorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = (~) Bool
        type AttrTransferType TreeViewColumnSortIndicatorPropertyInfo = Bool
        type AttrGetType TreeViewColumnSortIndicatorPropertyInfo = Bool
        type AttrLabel TreeViewColumnSortIndicatorPropertyInfo = "sort-indicator"
        type AttrOrigin TreeViewColumnSortIndicatorPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnSortIndicator
        attrSet = setTreeViewColumnSortIndicator
        attrPut = setTreeViewColumnSortIndicator
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnSortIndicator
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.sortIndicator"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:sortIndicator"
            })
    #endif

    -- VVV Prop "sort-order"
       -- Type: TInterface (Name {namespace = "Gtk", name = "SortType"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@sort-order@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #sortOrder
    -- @
    getTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> m Gtk.Enums.SortType
    getTreeViewColumnSortOrder :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m SortType
    getTreeViewColumnSortOrder o
    obj = IO SortType -> m SortType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO SortType -> m SortType) -> IO SortType -> m SortType
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO SortType
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "sort-order"

    -- | Set the value of the “@sort-order@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #sortOrder 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> Gtk.Enums.SortType -> m ()
    setTreeViewColumnSortOrder :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> SortType -> m ()
    setTreeViewColumnSortOrder o
    obj SortType
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> SortType -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "sort-order" SortType
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@sort-order@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnSortOrder :: (IsTreeViewColumn o, MIO.MonadIO m) => Gtk.Enums.SortType -> m (GValueConstruct o)
    constructTreeViewColumnSortOrder :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    SortType -> m (GValueConstruct o)
    constructTreeViewColumnSortOrder SortType
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> SortType -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "sort-order" SortType
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSortOrderPropertyInfo
    instance AttrInfo TreeViewColumnSortOrderPropertyInfo where
        type AttrAllowedOps TreeViewColumnSortOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnSortOrderPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnSortOrderPropertyInfo = (~) Gtk.Enums.SortType
        type AttrTransferTypeConstraint TreeViewColumnSortOrderPropertyInfo = (~) Gtk.Enums.SortType
        type AttrTransferType TreeViewColumnSortOrderPropertyInfo = Gtk.Enums.SortType
        type AttrGetType TreeViewColumnSortOrderPropertyInfo = Gtk.Enums.SortType
        type AttrLabel TreeViewColumnSortOrderPropertyInfo = "sort-order"
        type AttrOrigin TreeViewColumnSortOrderPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnSortOrder
        attrSet = setTreeViewColumnSortOrder
        attrPut = setTreeViewColumnSortOrder
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnSortOrder
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.sortOrder"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:sortOrder"
            })
    #endif

    -- VVV Prop "spacing"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@spacing@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #spacing
    -- @
    getTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnSpacing :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnSpacing o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "spacing"

    -- | Set the value of the “@spacing@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #spacing 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
    setTreeViewColumnSpacing :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Int32 -> m ()
    setTreeViewColumnSpacing o
    obj Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "spacing" Int32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@spacing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnSpacing :: (IsTreeViewColumn o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
    constructTreeViewColumnSpacing :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Int32 -> m (GValueConstruct o)
    constructTreeViewColumnSpacing Int32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Int32 -> IO (GValueConstruct o)
    forall o. String -> Int32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyInt32 String
    "spacing" Int32
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSpacingPropertyInfo
    instance AttrInfo TreeViewColumnSpacingPropertyInfo where
        type AttrAllowedOps TreeViewColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnSpacingPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnSpacingPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint TreeViewColumnSpacingPropertyInfo = (~) Int32
        type AttrTransferType TreeViewColumnSpacingPropertyInfo = Int32
        type AttrGetType TreeViewColumnSpacingPropertyInfo = Int32
        type AttrLabel TreeViewColumnSpacingPropertyInfo = "spacing"
        type AttrOrigin TreeViewColumnSpacingPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnSpacing
        attrSet = setTreeViewColumnSpacing
        attrPut = setTreeViewColumnSpacing
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnSpacing
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.spacing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:spacing"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnTitlePropertyInfo
    instance AttrInfo TreeViewColumnTitlePropertyInfo where
        type AttrAllowedOps TreeViewColumnTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnTitlePropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnTitlePropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint TreeViewColumnTitlePropertyInfo = (~) T.Text
        type AttrTransferType TreeViewColumnTitlePropertyInfo = T.Text
        type AttrGetType TreeViewColumnTitlePropertyInfo = T.Text
        type AttrLabel TreeViewColumnTitlePropertyInfo = "title"
        type AttrOrigin TreeViewColumnTitlePropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnTitle
        attrSet = setTreeViewColumnTitle
        attrPut = setTreeViewColumnTitle
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnTitle
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.title"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:title"
            })
    #endif

    -- VVV Prop "visible"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@visible@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #visible
    -- @
    getTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
    getTreeViewColumnVisible :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Bool
    getTreeViewColumnVisible o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "visible"

    -- | Set the value of the “@visible@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #visible 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
    setTreeViewColumnVisible :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> Bool -> m ()
    setTreeViewColumnVisible o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "visible" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnVisible :: (IsTreeViewColumn o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTreeViewColumnVisible :: forall o (m :: * -> *).
    (IsTreeViewColumn o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTreeViewColumnVisible Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "visible" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnVisiblePropertyInfo
    instance AttrInfo TreeViewColumnVisiblePropertyInfo where
        type AttrAllowedOps TreeViewColumnVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint TreeViewColumnVisiblePropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnVisiblePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TreeViewColumnVisiblePropertyInfo = (~) Bool
        type AttrTransferType TreeViewColumnVisiblePropertyInfo = Bool
        type AttrGetType TreeViewColumnVisiblePropertyInfo = Bool
        type AttrLabel TreeViewColumnVisiblePropertyInfo = "visible"
        type AttrOrigin TreeViewColumnVisiblePropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnVisible
        attrSet = setTreeViewColumnVisible
        attrPut = setTreeViewColumnVisible
        attrTransfer _ v = do
            return v
        attrConstruct = constructTreeViewColumnVisible
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.visible"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:visible"
            })
    #endif

    -- VVV Prop "widget"
       -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just True,Just True)

    -- | Get the value of the “@widget@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #widget
    -- @
    getTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Gtk.Widget.Widget)
    getTreeViewColumnWidget :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m (Maybe Widget)
    getTreeViewColumnWidget o
    obj = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "widget" ManagedPtr Widget -> Widget
    Gtk.Widget.Widget

    -- | Set the value of the “@widget@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' treeViewColumn [ #widget 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o, Gtk.Widget.IsWidget a) => o -> a -> m ()
    setTreeViewColumnWidget :: forall (m :: * -> *) o a.
    (MonadIO m, IsTreeViewColumn o, IsWidget a) =>
    o -> a -> m ()
    setTreeViewColumnWidget o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "widget" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTreeViewColumnWidget :: (IsTreeViewColumn o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
    constructTreeViewColumnWidget :: forall o (m :: * -> *) a.
    (IsTreeViewColumn o, MonadIO m, IsWidget a) =>
    a -> m (GValueConstruct o)
    constructTreeViewColumnWidget a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "widget" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    -- | Set the value of the “@widget@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #widget
    -- @
    clearTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m ()
    clearTreeViewColumnWidget :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m ()
    clearTreeViewColumnWidget o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Widget -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "widget" (Maybe Widget
    forall a. Maybe a
    Nothing :: Maybe Gtk.Widget.Widget)

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnWidgetPropertyInfo
    instance AttrInfo TreeViewColumnWidgetPropertyInfo where
        type AttrAllowedOps TreeViewColumnWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint TreeViewColumnWidgetPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnWidgetPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint TreeViewColumnWidgetPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType TreeViewColumnWidgetPropertyInfo = Gtk.Widget.Widget
        type AttrGetType TreeViewColumnWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel TreeViewColumnWidgetPropertyInfo = "widget"
        type AttrOrigin TreeViewColumnWidgetPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnWidget
        attrSet = setTreeViewColumnWidget
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructTreeViewColumnWidget
        attrClear = clearTreeViewColumnWidget
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.widget"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:widget"
            })
    #endif

    -- VVV Prop "width"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@width@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #width
    -- @
    getTreeViewColumnWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnWidth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnWidth o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "width"

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnWidthPropertyInfo
    instance AttrInfo TreeViewColumnWidthPropertyInfo where
        type AttrAllowedOps TreeViewColumnWidthPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint TreeViewColumnWidthPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnWidthPropertyInfo = (~) ()
        type AttrTransferTypeConstraint TreeViewColumnWidthPropertyInfo = (~) ()
        type AttrTransferType TreeViewColumnWidthPropertyInfo = ()
        type AttrGetType TreeViewColumnWidthPropertyInfo = Int32
        type AttrLabel TreeViewColumnWidthPropertyInfo = "width"
        type AttrOrigin TreeViewColumnWidthPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnWidth
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.width"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:width"
            })
    #endif

    -- VVV Prop "x-offset"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@x-offset@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeViewColumn #xOffset
    -- @
    getTreeViewColumnXOffset :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
    getTreeViewColumnXOffset :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeViewColumn o) =>
    o -> m Int32
    getTreeViewColumnXOffset o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "x-offset"

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnXOffsetPropertyInfo
    instance AttrInfo TreeViewColumnXOffsetPropertyInfo where
        type AttrAllowedOps TreeViewColumnXOffsetPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint TreeViewColumnXOffsetPropertyInfo = IsTreeViewColumn
        type AttrSetTypeConstraint TreeViewColumnXOffsetPropertyInfo = (~) ()
        type AttrTransferTypeConstraint TreeViewColumnXOffsetPropertyInfo = (~) ()
        type AttrTransferType TreeViewColumnXOffsetPropertyInfo = ()
        type AttrGetType TreeViewColumnXOffsetPropertyInfo = Int32
        type AttrLabel TreeViewColumnXOffsetPropertyInfo = "x-offset"
        type AttrOrigin TreeViewColumnXOffsetPropertyInfo = TreeViewColumn
        attrGet = getTreeViewColumnXOffset
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.xOffset"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#g:attr:xOffset"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList TreeViewColumn
    type instance O.AttributeList TreeViewColumn = TreeViewColumnAttributeList
    type TreeViewColumnAttributeList = ('[ '("alignment", TreeViewColumnAlignmentPropertyInfo), '("cellArea", TreeViewColumnCellAreaPropertyInfo), '("clickable", TreeViewColumnClickablePropertyInfo), '("expand", TreeViewColumnExpandPropertyInfo), '("fixedWidth", TreeViewColumnFixedWidthPropertyInfo), '("maxWidth", TreeViewColumnMaxWidthPropertyInfo), '("minWidth", TreeViewColumnMinWidthPropertyInfo), '("reorderable", TreeViewColumnReorderablePropertyInfo), '("resizable", TreeViewColumnResizablePropertyInfo), '("sizing", TreeViewColumnSizingPropertyInfo), '("sortColumnId", TreeViewColumnSortColumnIdPropertyInfo), '("sortIndicator", TreeViewColumnSortIndicatorPropertyInfo), '("sortOrder", TreeViewColumnSortOrderPropertyInfo), '("spacing", TreeViewColumnSpacingPropertyInfo), '("title", TreeViewColumnTitlePropertyInfo), '("visible", TreeViewColumnVisiblePropertyInfo), '("widget", TreeViewColumnWidgetPropertyInfo), '("width", TreeViewColumnWidthPropertyInfo), '("xOffset", TreeViewColumnXOffsetPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    treeViewColumnAlignment :: AttrLabelProxy "alignment"
    treeViewColumnAlignment = AttrLabelProxy

    treeViewColumnCellArea :: AttrLabelProxy "cellArea"
    treeViewColumnCellArea = AttrLabelProxy

    treeViewColumnClickable :: AttrLabelProxy "clickable"
    treeViewColumnClickable = AttrLabelProxy

    treeViewColumnExpand :: AttrLabelProxy "expand"
    treeViewColumnExpand = AttrLabelProxy

    treeViewColumnFixedWidth :: AttrLabelProxy "fixedWidth"
    treeViewColumnFixedWidth = AttrLabelProxy

    treeViewColumnMaxWidth :: AttrLabelProxy "maxWidth"
    treeViewColumnMaxWidth = AttrLabelProxy

    treeViewColumnMinWidth :: AttrLabelProxy "minWidth"
    treeViewColumnMinWidth = AttrLabelProxy

    treeViewColumnReorderable :: AttrLabelProxy "reorderable"
    treeViewColumnReorderable = AttrLabelProxy

    treeViewColumnResizable :: AttrLabelProxy "resizable"
    treeViewColumnResizable = AttrLabelProxy

    treeViewColumnSizing :: AttrLabelProxy "sizing"
    treeViewColumnSizing = AttrLabelProxy

    treeViewColumnSortColumnId :: AttrLabelProxy "sortColumnId"
    treeViewColumnSortColumnId = AttrLabelProxy

    treeViewColumnSortIndicator :: AttrLabelProxy "sortIndicator"
    treeViewColumnSortIndicator = AttrLabelProxy

    treeViewColumnSortOrder :: AttrLabelProxy "sortOrder"
    treeViewColumnSortOrder = AttrLabelProxy

    treeViewColumnSpacing :: AttrLabelProxy "spacing"
    treeViewColumnSpacing = AttrLabelProxy

    treeViewColumnTitle :: AttrLabelProxy "title"
    treeViewColumnTitle = AttrLabelProxy

    treeViewColumnVisible :: AttrLabelProxy "visible"
    treeViewColumnVisible = AttrLabelProxy

    treeViewColumnWidget :: AttrLabelProxy "widget"
    treeViewColumnWidget = AttrLabelProxy

    treeViewColumnWidth :: AttrLabelProxy "width"
    treeViewColumnWidth = AttrLabelProxy

    treeViewColumnXOffset :: AttrLabelProxy "xOffset"
    treeViewColumnXOffset = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList TreeViewColumn = TreeViewColumnSignalList
    type TreeViewColumnSignalList = ('[ '("clicked", TreeViewColumnClickedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method TreeViewColumn::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_new" gtk_tree_view_column_new ::
        IO (Ptr TreeViewColumn)

    {-# DEPRECATED treeViewColumnNew ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Creates a new @GtkTreeViewColumn@.
    treeViewColumnNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m TreeViewColumn
        -- ^ __Returns:__ A newly created @GtkTreeViewColumn@.
    treeViewColumnNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TreeViewColumn
    treeViewColumnNew  = IO TreeViewColumn -> m TreeViewColumn
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TreeViewColumn -> m TreeViewColumn)
    -> IO TreeViewColumn -> m TreeViewColumn
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr TreeViewColumn)
    gtk_tree_view_column_new
        checkUnexpectedReturnNULL "treeViewColumnNew" result
        result' <- (newObject TreeViewColumn) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method TreeViewColumn::new_with_area
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "area"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellArea" }
    --           , argCType = Just "GtkCellArea*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the `GtkCellArea` that the newly created column should use to layout cells."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_new_with_area" gtk_tree_view_column_new_with_area ::
        Ptr Gtk.CellArea.CellArea ->            -- area : TInterface (Name {namespace = "Gtk", name = "CellArea"})
        IO (Ptr TreeViewColumn)

    {-# DEPRECATED treeViewColumnNewWithArea ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Creates a new @GtkTreeViewColumn@ using /@area@/ to render its cells.
    treeViewColumnNewWithArea ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.CellArea.IsCellArea a) =>
        a
        -- ^ /@area@/: the @GtkCellArea@ that the newly created column should use to layout cells.
        -> m TreeViewColumn
        -- ^ __Returns:__ A newly created @GtkTreeViewColumn@.
    treeViewColumnNewWithArea :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellArea a) =>
    a -> m TreeViewColumn
    treeViewColumnNewWithArea a
    area = IO TreeViewColumn -> m TreeViewColumn
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TreeViewColumn -> m TreeViewColumn)
    -> IO TreeViewColumn -> m TreeViewColumn
    forall a b. (a -> b) -> a -> b
    $ do
        area' <- a -> IO (Ptr CellArea)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    area
        result <- gtk_tree_view_column_new_with_area area'
        checkUnexpectedReturnNULL "treeViewColumnNewWithArea" result
        result' <- (newObject TreeViewColumn) result
        touchManagedPtr area
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method TreeViewColumn::add_attribute
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_renderer"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the `GtkCellRenderer` to set attributes on"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attribute"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "An attribute on the renderer"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The column position on the model to get the attribute from."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_add_attribute" gtk_tree_view_column_add_attribute ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        CString ->                              -- attribute : TBasicType TUTF8
        Int32 ->                                -- column : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnAddAttribute ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Adds an attribute mapping to the list in /@treeColumn@/.
    --
    -- The /@column@/ is the
    -- column of the model to get a value from, and the /@attribute@/ is the
    -- parameter on /@cellRenderer@/ to be set from the value. So for example
    -- if column 2 of the model contains strings, you could have the
    -- “text” attribute of a @GtkCellRendererText@ get its values from
    -- column 2.
    treeViewColumnAddAttribute ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> b
        -- ^ /@cellRenderer@/: the @GtkCellRenderer@ to set attributes on
        -> T.Text
        -- ^ /@attribute@/: An attribute on the renderer
        -> Int32
        -- ^ /@column@/: The column position on the model to get the attribute from.
        -> m ()
    treeViewColumnAddAttribute :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> Text -> Int32 -> m ()
    treeViewColumnAddAttribute a
    treeColumn b
    cellRenderer Text
    attribute Int32
    column = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
        attribute' <- textToCString attribute
        gtk_tree_view_column_add_attribute treeColumn' cellRenderer' attribute' column
        touchManagedPtr treeColumn
        touchManagedPtr cellRenderer
        freeMem attribute'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnAddAttributeMethodInfo
    instance (signature ~ (b -> T.Text -> Int32 -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnAddAttributeMethodInfo a signature where
        overloadedMethod = treeViewColumnAddAttribute

    instance O.OverloadedMethodInfo TreeViewColumnAddAttributeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnAddAttribute",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnAddAttribute"
            })

    #endif

    -- method TreeViewColumn::cell_get_position
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_renderer"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x_offset"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "return location for the horizontal\n  position of @cell within @tree_column"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the width of @cell"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_cell_get_position" gtk_tree_view_column_cell_get_position ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        Ptr Int32 ->                            -- x_offset : TBasicType TInt
        Ptr Int32 ->                            -- width : TBasicType TInt
        IO CInt

    {-# DEPRECATED treeViewColumnCellGetPosition ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Obtains the horizontal position and size of a cell in a column.
    --
    -- If the  cell is not found in the column, /@startPos@/ and /@width@/
    -- are not changed and 'P.False' is returned.
    treeViewColumnCellGetPosition ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> b
        -- ^ /@cellRenderer@/: a @GtkCellRenderer@
        -> m ((Bool, Int32, Int32))
        -- ^ __Returns:__ 'P.True' if /@cell@/ belongs to /@treeColumn@/
    treeViewColumnCellGetPosition :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> m (Bool, Int32, Int32)
    treeViewColumnCellGetPosition a
    treeColumn b
    cellRenderer = IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32))
    -> IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
        xOffset <- allocMem :: IO (Ptr Int32)
        width <- allocMem :: IO (Ptr Int32)
        result <- gtk_tree_view_column_cell_get_position treeColumn' cellRenderer' xOffset width
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        xOffset' <- peek xOffset
        width' <- peek width
        touchManagedPtr treeColumn
        touchManagedPtr cellRenderer
        freeMem xOffset
        freeMem width
        return (result', xOffset', width')

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnCellGetPositionMethodInfo
    instance (signature ~ (b -> m ((Bool, Int32, Int32))), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnCellGetPositionMethodInfo a signature where
        overloadedMethod = treeViewColumnCellGetPosition

    instance O.OverloadedMethodInfo TreeViewColumnCellGetPositionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnCellGetPosition",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnCellGetPosition"
            })

    #endif

    -- method TreeViewColumn::cell_get_size
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x_offset"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to return x offset of a cell relative to @cell_area"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "y_offset"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to return y offset of a cell relative to @cell_area"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to return width needed to render a cell"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to return height needed to render a cell"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_cell_get_size" gtk_tree_view_column_cell_get_size ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Int32 ->                            -- x_offset : TBasicType TInt
        Ptr Int32 ->                            -- y_offset : TBasicType TInt
        Ptr Int32 ->                            -- width : TBasicType TInt
        Ptr Int32 ->                            -- height : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnCellGetSize ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Obtains the width and height needed to render the column.  This is used
    -- primarily by the @GtkTreeView@.
    treeViewColumnCellGetSize ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m ((Int32, Int32, Int32, Int32))
    treeViewColumnCellGetSize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m (Int32, Int32, Int32, Int32)
    treeViewColumnCellGetSize a
    treeColumn = IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32))
    -> IO (Int32, Int32, Int32, Int32)
    -> m (Int32, Int32, Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        xOffset <- allocMem :: IO (Ptr Int32)
        yOffset <- allocMem :: IO (Ptr Int32)
        width <- allocMem :: IO (Ptr Int32)
        height <- allocMem :: IO (Ptr Int32)
        gtk_tree_view_column_cell_get_size treeColumn' xOffset yOffset width height
        xOffset' <- peek xOffset
        yOffset' <- peek yOffset
        width' <- peek width
        height' <- peek height
        touchManagedPtr treeColumn
        freeMem xOffset
        freeMem yOffset
        freeMem width
        freeMem height
        return (xOffset', yOffset', width', height')

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnCellGetSizeMethodInfo
    instance (signature ~ (m ((Int32, Int32, Int32, Int32))), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnCellGetSizeMethodInfo a signature where
        overloadedMethod = treeViewColumnCellGetSize

    instance O.OverloadedMethodInfo TreeViewColumnCellGetSizeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnCellGetSize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnCellGetSize"
            })

    #endif

    -- method TreeViewColumn::cell_is_visible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_cell_is_visible" gtk_tree_view_column_cell_is_visible ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnCellIsVisible ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns 'P.True' if any of the cells packed into the /@treeColumn@/ are visible.
    -- For this to be meaningful, you must first initialize the cells with
    -- 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnCellSetCellData'
    treeViewColumnCellIsVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m Bool
        -- ^ __Returns:__ 'P.True', if any of the cells packed into the /@treeColumn@/ are currently visible
    treeViewColumnCellIsVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnCellIsVisible a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_cell_is_visible treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnCellIsVisibleMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnCellIsVisibleMethodInfo a signature where
        overloadedMethod = treeViewColumnCellIsVisible

    instance O.OverloadedMethodInfo TreeViewColumnCellIsVisibleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnCellIsVisible",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnCellIsVisible"
            })

    #endif

    -- method TreeViewColumn::cell_set_cell_data
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "tree_model"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeModel" }
    --           , argCType = Just "GtkTreeModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "The `GtkTreeModel` to get the cell renderers attributes from."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeIter" }
    --           , argCType = Just "GtkTreeIter*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "The `GtkTreeIter` to get the cell renderer\8217s attributes from."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "is_expander"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE, if the row has children"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "is_expanded"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE, if the row has visible children"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_cell_set_cell_data" gtk_tree_view_column_cell_set_cell_data ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.TreeModel.TreeModel ->          -- tree_model : TInterface (Name {namespace = "Gtk", name = "TreeModel"})
        Ptr Gtk.TreeIter.TreeIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
        CInt ->                                 -- is_expander : TBasicType TBoolean
        CInt ->                                 -- is_expanded : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnCellSetCellData ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the cell renderer based on the /@treeModel@/ and /@iter@/.  That is, for
    -- every attribute mapping in /@treeColumn@/, it will get a value from the set
    -- column on the /@iter@/, and use that value to set the attribute on the cell
    -- renderer.  This is used primarily by the @GtkTreeView@.
    treeViewColumnCellSetCellData ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.TreeModel.IsTreeModel b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> b
        -- ^ /@treeModel@/: The @GtkTreeModel@ to get the cell renderers attributes from.
        -> Gtk.TreeIter.TreeIter
        -- ^ /@iter@/: The @GtkTreeIter@ to get the cell renderer’s attributes from.
        -> Bool
        -- ^ /@isExpander@/: 'P.True', if the row has children
        -> Bool
        -- ^ /@isExpanded@/: 'P.True', if the row has visible children
        -> m ()
    treeViewColumnCellSetCellData :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsTreeModel b) =>
    a -> b -> TreeIter -> Bool -> Bool -> m ()
    treeViewColumnCellSetCellData a
    treeColumn b
    treeModel TreeIter
    iter Bool
    isExpander Bool
    isExpanded = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        treeModel' <- unsafeManagedPtrCastPtr treeModel
        iter' <- unsafeManagedPtrGetPtr iter
        let isExpander' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    isExpander
        let isExpanded' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    isExpanded
        gtk_tree_view_column_cell_set_cell_data treeColumn' treeModel' iter' isExpander' isExpanded'
        touchManagedPtr treeColumn
        touchManagedPtr treeModel
        touchManagedPtr iter
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnCellSetCellDataMethodInfo
    instance (signature ~ (b -> Gtk.TreeIter.TreeIter -> Bool -> Bool -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.TreeModel.IsTreeModel b) => O.OverloadedMethod TreeViewColumnCellSetCellDataMethodInfo a signature where
        overloadedMethod = treeViewColumnCellSetCellData

    instance O.OverloadedMethodInfo TreeViewColumnCellSetCellDataMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnCellSetCellData",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnCellSetCellData"
            })

    #endif

    -- method TreeViewColumn::clear
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_clear" gtk_tree_view_column_clear ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO ()

    {-# DEPRECATED treeViewColumnClear ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Unsets all the mappings on all renderers on the /@treeColumn@/.
    treeViewColumnClear ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m ()
    treeViewColumnClear :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m ()
    treeViewColumnClear a
    treeColumn = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_clear treeColumn'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnClearMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnClearMethodInfo a signature where
        overloadedMethod = treeViewColumnClear

    instance O.OverloadedMethodInfo TreeViewColumnClearMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnClear",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnClear"
            })

    #endif

    -- method TreeViewColumn::clear_attributes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_renderer"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a `GtkCellRenderer` to clear the attribute mapping on."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_clear_attributes" gtk_tree_view_column_clear_attributes ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        IO ()

    {-# DEPRECATED treeViewColumnClearAttributes ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Clears all existing attributes previously set with
    -- @/gtk_tree_view_column_set_attributes()/@.
    treeViewColumnClearAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> b
        -- ^ /@cellRenderer@/: a @GtkCellRenderer@ to clear the attribute mapping on.
        -> m ()
    treeViewColumnClearAttributes :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> m ()
    treeViewColumnClearAttributes a
    treeColumn b
    cellRenderer = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
        gtk_tree_view_column_clear_attributes treeColumn' cellRenderer'
        touchManagedPtr treeColumn
        touchManagedPtr cellRenderer
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnClearAttributesMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnClearAttributesMethodInfo a signature where
        overloadedMethod = treeViewColumnClearAttributes

    instance O.OverloadedMethodInfo TreeViewColumnClearAttributesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnClearAttributes",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnClearAttributes"
            })

    #endif

    -- method TreeViewColumn::clicked
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_clicked" gtk_tree_view_column_clicked ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO ()

    {-# DEPRECATED treeViewColumnClicked ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Emits the “clicked” signal on the column.  This function will only work if
    -- /@treeColumn@/ is clickable.
    treeViewColumnClicked ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> m ()
    treeViewColumnClicked :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m ()
    treeViewColumnClicked a
    treeColumn = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_clicked treeColumn'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnClickedMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnClickedMethodInfo a signature where
        overloadedMethod = treeViewColumnClicked

    instance O.OverloadedMethodInfo TreeViewColumnClickedMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnClicked",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnClicked"
            })

    #endif

    -- method TreeViewColumn::focus_cell
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_focus_cell" gtk_tree_view_column_focus_cell ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        IO ()

    {-# DEPRECATED treeViewColumnFocusCell ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the current keyboard focus to be at /@cell@/, if the column contains
    -- 2 or more editable and activatable cells.
    treeViewColumnFocusCell ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> b
        -- ^ /@cell@/: A @GtkCellRenderer@
        -> m ()
    treeViewColumnFocusCell :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> m ()
    treeViewColumnFocusCell a
    treeColumn b
    cell = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cell' <- unsafeManagedPtrCastPtr cell
        gtk_tree_view_column_focus_cell treeColumn' cell'
        touchManagedPtr treeColumn
        touchManagedPtr cell
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnFocusCellMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnFocusCellMethodInfo a signature where
        overloadedMethod = treeViewColumnFocusCell

    instance O.OverloadedMethodInfo TreeViewColumnFocusCellMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnFocusCell",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnFocusCell"
            })

    #endif

    -- method TreeViewColumn::get_alignment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_alignment" gtk_tree_view_column_get_alignment ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CFloat

    {-# DEPRECATED treeViewColumnGetAlignment ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the current x alignment of /@treeColumn@/.  This value can range
    -- between 0.0 and 1.0.
    treeViewColumnGetAlignment ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Float
        -- ^ __Returns:__ The current alignent of /@treeColumn@/.
    treeViewColumnGetAlignment :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Float
    treeViewColumnGetAlignment a
    treeColumn = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_alignment treeColumn'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetAlignmentMethodInfo
    instance (signature ~ (m Float), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetAlignmentMethodInfo a signature where
        overloadedMethod = treeViewColumnGetAlignment

    instance O.OverloadedMethodInfo TreeViewColumnGetAlignmentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetAlignment",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetAlignment"
            })

    #endif

    -- method TreeViewColumn::get_button
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_button" gtk_tree_view_column_get_button ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO (Ptr Gtk.Widget.Widget)

    {-# DEPRECATED treeViewColumnGetButton ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the button used in the treeview column header
    treeViewColumnGetButton ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m Gtk.Widget.Widget
        -- ^ __Returns:__ The button for the column header.
    treeViewColumnGetButton :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Widget
    treeViewColumnGetButton a
    treeColumn = IO Widget -> m Widget
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_button treeColumn'
        checkUnexpectedReturnNULL "treeViewColumnGetButton" result
        result' <- (newObject Gtk.Widget.Widget) result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetButtonMethodInfo
    instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetButtonMethodInfo a signature where
        overloadedMethod = treeViewColumnGetButton

    instance O.OverloadedMethodInfo TreeViewColumnGetButtonMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetButton",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetButton"
            })

    #endif

    -- method TreeViewColumn::get_clickable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_clickable" gtk_tree_view_column_get_clickable ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnGetClickable ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns 'P.True' if the user can click on the header for the column.
    treeViewColumnGetClickable ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if user can click the column header.
    treeViewColumnGetClickable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnGetClickable a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_clickable treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetClickableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetClickableMethodInfo a signature where
        overloadedMethod = treeViewColumnGetClickable

    instance O.OverloadedMethodInfo TreeViewColumnGetClickableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetClickable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetClickable"
            })

    #endif

    -- method TreeViewColumn::get_expand
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_expand" gtk_tree_view_column_get_expand ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnGetExpand ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns 'P.True' if the column expands to fill available space.
    treeViewColumnGetExpand ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the column expands to fill available space.
    treeViewColumnGetExpand :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnGetExpand a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_expand treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetExpandMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetExpandMethodInfo a signature where
        overloadedMethod = treeViewColumnGetExpand

    instance O.OverloadedMethodInfo TreeViewColumnGetExpandMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetExpand",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetExpand"
            })

    #endif

    -- method TreeViewColumn::get_fixed_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_fixed_width" gtk_tree_view_column_get_fixed_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetFixedWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Gets the fixed width of the column.  This may not be the actual displayed
    -- width of the column; for that, use 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetWidth'.
    treeViewColumnGetFixedWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Int32
        -- ^ __Returns:__ The fixed width of the column.
    treeViewColumnGetFixedWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetFixedWidth a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_fixed_width treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetFixedWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetFixedWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnGetFixedWidth

    instance O.OverloadedMethodInfo TreeViewColumnGetFixedWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetFixedWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetFixedWidth"
            })

    #endif

    -- method TreeViewColumn::get_max_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_max_width" gtk_tree_view_column_get_max_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetMaxWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the maximum width in pixels of the /@treeColumn@/, or -1 if no maximum
    -- width is set.
    treeViewColumnGetMaxWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Int32
        -- ^ __Returns:__ The maximum width of the /@treeColumn@/.
    treeViewColumnGetMaxWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetMaxWidth a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_max_width treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetMaxWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetMaxWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnGetMaxWidth

    instance O.OverloadedMethodInfo TreeViewColumnGetMaxWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetMaxWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetMaxWidth"
            })

    #endif

    -- method TreeViewColumn::get_min_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_min_width" gtk_tree_view_column_get_min_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetMinWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the minimum width in pixels of the /@treeColumn@/, or -1 if no minimum
    -- width is set.
    treeViewColumnGetMinWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Int32
        -- ^ __Returns:__ The minimum width of the /@treeColumn@/.
    treeViewColumnGetMinWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetMinWidth a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_min_width treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetMinWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetMinWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnGetMinWidth

    instance O.OverloadedMethodInfo TreeViewColumnGetMinWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetMinWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetMinWidth"
            })

    #endif

    -- method TreeViewColumn::get_reorderable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_reorderable" gtk_tree_view_column_get_reorderable ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnGetReorderable ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns 'P.True' if the /@treeColumn@/ can be reordered by the user.
    treeViewColumnGetReorderable ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the /@treeColumn@/ can be reordered by the user.
    treeViewColumnGetReorderable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnGetReorderable a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_reorderable treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetReorderableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetReorderableMethodInfo a signature where
        overloadedMethod = treeViewColumnGetReorderable

    instance O.OverloadedMethodInfo TreeViewColumnGetReorderableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetReorderable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetReorderable"
            })

    #endif

    -- method TreeViewColumn::get_resizable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_resizable" gtk_tree_view_column_get_resizable ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnGetResizable ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns 'P.True' if the /@treeColumn@/ can be resized by the end user.
    treeViewColumnGetResizable ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m Bool
        -- ^ __Returns:__ 'P.True', if the /@treeColumn@/ can be resized.
    treeViewColumnGetResizable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnGetResizable a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_resizable treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetResizableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetResizableMethodInfo a signature where
        overloadedMethod = treeViewColumnGetResizable

    instance O.OverloadedMethodInfo TreeViewColumnGetResizableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetResizable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetResizable"
            })

    #endif

    -- method TreeViewColumn::get_sizing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gtk" , name = "TreeViewColumnSizing" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_sizing" gtk_tree_view_column_get_sizing ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CUInt

    {-# DEPRECATED treeViewColumnGetSizing ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the current type of /@treeColumn@/.
    treeViewColumnGetSizing ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Gtk.Enums.TreeViewColumnSizing
        -- ^ __Returns:__ The type of /@treeColumn@/.
    treeViewColumnGetSizing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m TreeViewColumnSizing
    treeViewColumnGetSizing a
    treeColumn = IO TreeViewColumnSizing -> m TreeViewColumnSizing
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TreeViewColumnSizing -> m TreeViewColumnSizing)
    -> IO TreeViewColumnSizing -> m TreeViewColumnSizing
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_sizing treeColumn'
        let result' = (Int -> TreeViewColumnSizing
    forall a. Enum a => Int -> a
    toEnum (Int -> TreeViewColumnSizing)
    -> (CUInt -> Int) -> CUInt -> TreeViewColumnSizing
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetSizingMethodInfo
    instance (signature ~ (m Gtk.Enums.TreeViewColumnSizing), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetSizingMethodInfo a signature where
        overloadedMethod = treeViewColumnGetSizing

    instance O.OverloadedMethodInfo TreeViewColumnGetSizingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetSizing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetSizing"
            })

    #endif

    -- method TreeViewColumn::get_sort_column_id
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_sort_column_id" gtk_tree_view_column_get_sort_column_id ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetSortColumnId ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Gets the logical /@sortColumnId@/ that the model sorts on
    -- when this column is selected for sorting.
    --
    -- See 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortColumnId'.
    treeViewColumnGetSortColumnId ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> m Int32
        -- ^ __Returns:__ the current /@sortColumnId@/ for this column, or -1 if
        --   this column can’t be used for sorting
    treeViewColumnGetSortColumnId :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetSortColumnId a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_sort_column_id treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetSortColumnIdMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetSortColumnIdMethodInfo a signature where
        overloadedMethod = treeViewColumnGetSortColumnId

    instance O.OverloadedMethodInfo TreeViewColumnGetSortColumnIdMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetSortColumnId",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetSortColumnId"
            })

    #endif

    -- method TreeViewColumn::get_sort_indicator
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_sort_indicator" gtk_tree_view_column_get_sort_indicator ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnGetSortIndicator ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Gets the value set by 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortIndicator'.
    treeViewColumnGetSortIndicator ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> m Bool
        -- ^ __Returns:__ whether the sort indicator arrow is displayed
    treeViewColumnGetSortIndicator :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnGetSortIndicator a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_sort_indicator treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetSortIndicatorMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetSortIndicatorMethodInfo a signature where
        overloadedMethod = treeViewColumnGetSortIndicator

    instance O.OverloadedMethodInfo TreeViewColumnGetSortIndicatorMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetSortIndicator",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetSortIndicator"
            })

    #endif

    -- method TreeViewColumn::get_sort_order
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "SortType" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_sort_order" gtk_tree_view_column_get_sort_order ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CUInt

    {-# DEPRECATED treeViewColumnGetSortOrder ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Gets the value set by 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortOrder'.
    treeViewColumnGetSortOrder ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> m Gtk.Enums.SortType
        -- ^ __Returns:__ the sort order the sort indicator is indicating
    treeViewColumnGetSortOrder :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m SortType
    treeViewColumnGetSortOrder a
    treeColumn = IO SortType -> m SortType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SortType -> m SortType) -> IO SortType -> m SortType
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_sort_order treeColumn'
        let result' = (Int -> SortType
    forall a. Enum a => Int -> a
    toEnum (Int -> SortType) -> (CUInt -> Int) -> CUInt -> SortType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetSortOrderMethodInfo
    instance (signature ~ (m Gtk.Enums.SortType), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetSortOrderMethodInfo a signature where
        overloadedMethod = treeViewColumnGetSortOrder

    instance O.OverloadedMethodInfo TreeViewColumnGetSortOrderMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetSortOrder",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetSortOrder"
            })

    #endif

    -- method TreeViewColumn::get_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_spacing" gtk_tree_view_column_get_spacing ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetSpacing ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the spacing of /@treeColumn@/.
    treeViewColumnGetSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Int32
        -- ^ __Returns:__ the spacing of /@treeColumn@/.
    treeViewColumnGetSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetSpacing a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_spacing treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetSpacingMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetSpacingMethodInfo a signature where
        overloadedMethod = treeViewColumnGetSpacing

    instance O.OverloadedMethodInfo TreeViewColumnGetSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetSpacing"
            })

    #endif

    -- method TreeViewColumn::get_title
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_title" gtk_tree_view_column_get_title ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CString

    {-# DEPRECATED treeViewColumnGetTitle ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the title of the widget.
    treeViewColumnGetTitle ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m T.Text
        -- ^ __Returns:__ the title of the column. This string should not be
        -- modified or freed.
    treeViewColumnGetTitle :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Text
    treeViewColumnGetTitle a
    treeColumn = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_title treeColumn'
        checkUnexpectedReturnNULL "treeViewColumnGetTitle" result
        result' <- cstringToText result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetTitleMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetTitleMethodInfo a signature where
        overloadedMethod = treeViewColumnGetTitle

    instance O.OverloadedMethodInfo TreeViewColumnGetTitleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetTitle",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetTitle"
            })

    #endif

    -- method TreeViewColumn::get_tree_view
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_tree_view" gtk_tree_view_column_get_tree_view ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO (Ptr Gtk.Widget.Widget)

    {-# DEPRECATED treeViewColumnGetTreeView ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the @GtkTreeView@ wherein /@treeColumn@/ has been inserted.
    -- If /@column@/ is currently not inserted in any tree view, 'P.Nothing' is
    -- returned.
    treeViewColumnGetTreeView ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ The tree view wherein /@column@/
        --   has been inserted
    treeViewColumnGetTreeView :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m (Maybe Widget)
    treeViewColumnGetTreeView a
    treeColumn = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_tree_view treeColumn'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr treeColumn
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetTreeViewMethodInfo
    instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetTreeViewMethodInfo a signature where
        overloadedMethod = treeViewColumnGetTreeView

    instance O.OverloadedMethodInfo TreeViewColumnGetTreeViewMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetTreeView",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetTreeView"
            })

    #endif

    -- method TreeViewColumn::get_visible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_visible" gtk_tree_view_column_get_visible ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO CInt

    {-# DEPRECATED treeViewColumnGetVisible ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns 'P.True' if /@treeColumn@/ is visible.
    treeViewColumnGetVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Bool
        -- ^ __Returns:__ whether the column is visible or not.  If it is visible, then
        -- the tree will show the column.
    treeViewColumnGetVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Bool
    treeViewColumnGetVisible a
    treeColumn = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_visible treeColumn'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr treeColumn
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetVisibleMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetVisibleMethodInfo a signature where
        overloadedMethod = treeViewColumnGetVisible

    instance O.OverloadedMethodInfo TreeViewColumnGetVisibleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetVisible",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetVisible"
            })

    #endif

    -- method TreeViewColumn::get_widget
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_widget" gtk_tree_view_column_get_widget ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO (Ptr Gtk.Widget.Widget)

    {-# DEPRECATED treeViewColumnGetWidget ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the @GtkWidget@ in the button on the column header.
    --
    -- If a custom widget has not been set then 'P.Nothing' is returned.
    treeViewColumnGetWidget ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ The @GtkWidget@ in the column header
    treeViewColumnGetWidget :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m (Maybe Widget)
    treeViewColumnGetWidget a
    treeColumn = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_widget treeColumn'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr treeColumn
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetWidgetMethodInfo
    instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetWidgetMethodInfo a signature where
        overloadedMethod = treeViewColumnGetWidget

    instance O.OverloadedMethodInfo TreeViewColumnGetWidgetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetWidget",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetWidget"
            })

    #endif

    -- method TreeViewColumn::get_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_width" gtk_tree_view_column_get_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the current size of /@treeColumn@/ in pixels.
    treeViewColumnGetWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Int32
        -- ^ __Returns:__ The current width of /@treeColumn@/.
    treeViewColumnGetWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetWidth a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_width treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnGetWidth

    instance O.OverloadedMethodInfo TreeViewColumnGetWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetWidth"
            })

    #endif

    -- method TreeViewColumn::get_x_offset
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_get_x_offset" gtk_tree_view_column_get_x_offset ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO Int32

    {-# DEPRECATED treeViewColumnGetXOffset ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Returns the current X offset of /@treeColumn@/ in pixels.
    treeViewColumnGetXOffset ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> m Int32
        -- ^ __Returns:__ The current X offset of /@treeColumn@/.
    treeViewColumnGetXOffset :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m Int32
    treeViewColumnGetXOffset a
    treeColumn = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        result <- gtk_tree_view_column_get_x_offset treeColumn'
        touchManagedPtr treeColumn
        return result

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnGetXOffsetMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnGetXOffsetMethodInfo a signature where
        overloadedMethod = treeViewColumnGetXOffset

    instance O.OverloadedMethodInfo TreeViewColumnGetXOffsetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetXOffset",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnGetXOffset"
            })

    #endif

    -- method TreeViewColumn::pack_end
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "expand"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "%TRUE if @cell is to be given extra space allocated to @tree_column."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_pack_end" gtk_tree_view_column_pack_end ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        CInt ->                                 -- expand : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnPackEnd ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Adds the /@cell@/ to end of the column. If /@expand@/ is 'P.False', then the /@cell@/
    -- is allocated no more space than it needs. Any unused space is divided
    -- evenly between cells for which /@expand@/ is 'P.True'.
    treeViewColumnPackEnd ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> b
        -- ^ /@cell@/: The @GtkCellRenderer@
        -> Bool
        -- ^ /@expand@/: 'P.True' if /@cell@/ is to be given extra space allocated to /@treeColumn@/.
        -> m ()
    treeViewColumnPackEnd :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> Bool -> m ()
    treeViewColumnPackEnd a
    treeColumn b
    cell Bool
    expand = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cell' <- unsafeManagedPtrCastPtr cell
        let expand' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    expand
        gtk_tree_view_column_pack_end treeColumn' cell' expand'
        touchManagedPtr treeColumn
        touchManagedPtr cell
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnPackEndMethodInfo
    instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnPackEndMethodInfo a signature where
        overloadedMethod = treeViewColumnPackEnd

    instance O.OverloadedMethodInfo TreeViewColumnPackEndMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnPackEnd",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnPackEnd"
            })

    #endif

    -- method TreeViewColumn::pack_start
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "expand"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "%TRUE if @cell is to be given extra space allocated to @tree_column."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_pack_start" gtk_tree_view_column_pack_start ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        CInt ->                                 -- expand : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnPackStart ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Packs the /@cell@/ into the beginning of the column. If /@expand@/ is 'P.False', then
    -- the /@cell@/ is allocated no more space than it needs. Any unused space is divided
    -- evenly between cells for which /@expand@/ is 'P.True'.
    treeViewColumnPackStart ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> b
        -- ^ /@cell@/: The @GtkCellRenderer@
        -> Bool
        -- ^ /@expand@/: 'P.True' if /@cell@/ is to be given extra space allocated to /@treeColumn@/.
        -> m ()
    treeViewColumnPackStart :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> Bool -> m ()
    treeViewColumnPackStart a
    treeColumn b
    cell Bool
    expand = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cell' <- unsafeManagedPtrCastPtr cell
        let expand' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    expand
        gtk_tree_view_column_pack_start treeColumn' cell' expand'
        touchManagedPtr treeColumn
        touchManagedPtr cell
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnPackStartMethodInfo
    instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnPackStartMethodInfo a signature where
        overloadedMethod = treeViewColumnPackStart

    instance O.OverloadedMethodInfo TreeViewColumnPackStartMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnPackStart",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnPackStart"
            })

    #endif

    -- method TreeViewColumn::queue_resize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_queue_resize" gtk_tree_view_column_queue_resize ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        IO ()

    {-# DEPRECATED treeViewColumnQueueResize ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Flags the column, and the cell renderers added to this column, to have
    -- their sizes renegotiated.
    treeViewColumnQueueResize ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> m ()
    treeViewColumnQueueResize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> m ()
    treeViewColumnQueueResize a
    treeColumn = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_queue_resize treeColumn'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnQueueResizeMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnQueueResizeMethodInfo a signature where
        overloadedMethod = treeViewColumnQueueResize

    instance O.OverloadedMethodInfo TreeViewColumnQueueResizeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnQueueResize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnQueueResize"
            })

    #endif

    -- method TreeViewColumn::set_alignment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The alignment, which is between [0.0 and 1.0] inclusive."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_alignment" gtk_tree_view_column_set_alignment ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CFloat ->                               -- xalign : TBasicType TFloat
        IO ()

    {-# DEPRECATED treeViewColumnSetAlignment ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the alignment of the title or custom widget inside the column header.
    -- The alignment determines its location inside the button -- 0.0 for left, 0.5
    -- for center, 1.0 for right.
    treeViewColumnSetAlignment ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Float
        -- ^ /@xalign@/: The alignment, which is between [0.0 and 1.0] inclusive.
        -> m ()
    treeViewColumnSetAlignment :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Float -> m ()
    treeViewColumnSetAlignment a
    treeColumn Float
    xalign = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let xalign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xalign
        gtk_tree_view_column_set_alignment treeColumn' xalign'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetAlignmentMethodInfo
    instance (signature ~ (Float -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetAlignmentMethodInfo a signature where
        overloadedMethod = treeViewColumnSetAlignment

    instance O.OverloadedMethodInfo TreeViewColumnSetAlignmentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetAlignment",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetAlignment"
            })

    #endif

    -- method TreeViewColumn::set_cell_data_func
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_renderer"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "func"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeCellDataFunc" }
    --           , argCType = Just "GtkTreeCellDataFunc"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkTreeCellDataFunc` to use."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeNotified
    --           , argClosure = 3
    --           , argDestroy = 4
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "func_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The user data for @func."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "destroy"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
    --           , argCType = Just "GDestroyNotify"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The destroy notification for @func_data"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_cell_data_func" gtk_tree_view_column_set_cell_data_func ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        FunPtr Gtk.Callbacks.C_TreeCellDataFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeCellDataFunc"})
        Ptr () ->                               -- func_data : TBasicType TPtr
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO ()

    {-# DEPRECATED treeViewColumnSetCellDataFunc ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the @GtkTreeCellDataFunc@ to use for the column.
    --
    -- This
    -- function is used instead of the standard attributes mapping for
    -- setting the column value, and should set the value of /@treeColumn@/\'s
    -- cell renderer as appropriate.  /@func@/ may be 'P.Nothing' to remove an
    -- older one.
    treeViewColumnSetCellDataFunc ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> b
        -- ^ /@cellRenderer@/: A @GtkCellRenderer@
        -> Maybe (Gtk.Callbacks.TreeCellDataFunc)
        -- ^ /@func@/: The @GtkTreeCellDataFunc@ to use.
        -> m ()
    treeViewColumnSetCellDataFunc :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) =>
    a -> b -> Maybe TreeCellDataFunc -> m ()
    treeViewColumnSetCellDataFunc a
    treeColumn b
    cellRenderer Maybe TreeCellDataFunc
    func = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
        maybeFunc <- case func of
            Maybe TreeCellDataFunc
    Nothing -> FunPtr C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_TreeCellDataFunc
    forall a. FunPtr a
    FP.nullFunPtr
            Just TreeCellDataFunc
    jFunc -> do
                jFunc' <- C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
    Gtk.Callbacks.mk_TreeCellDataFunc (Maybe (Ptr (FunPtr C_TreeCellDataFunc))
    -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc
    Gtk.Callbacks.wrap_TreeCellDataFunc Maybe (Ptr (FunPtr C_TreeCellDataFunc))
    forall a. Maybe a
    Nothing (TreeCellDataFunc -> TreeCellDataFunc_WithClosures
    Gtk.Callbacks.drop_closures_TreeCellDataFunc TreeCellDataFunc
    jFunc))
                return jFunc'
        let funcData = FunPtr C_TreeCellDataFunc -> Ptr ()
    forall a b. FunPtr a -> Ptr b
    castFunPtrToPtr FunPtr C_TreeCellDataFunc
    maybeFunc
        let destroy = FunPtr (Ptr a -> IO ())
    forall a. FunPtr (Ptr a -> IO ())
    SP.safeFreeFunPtrPtr
        gtk_tree_view_column_set_cell_data_func treeColumn' cellRenderer' maybeFunc funcData destroy
        touchManagedPtr treeColumn
        touchManagedPtr cellRenderer
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetCellDataFuncMethodInfo
    instance (signature ~ (b -> Maybe (Gtk.Callbacks.TreeCellDataFunc) -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod TreeViewColumnSetCellDataFuncMethodInfo a signature where
        overloadedMethod = treeViewColumnSetCellDataFunc

    instance O.OverloadedMethodInfo TreeViewColumnSetCellDataFuncMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetCellDataFunc",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetCellDataFunc"
            })

    #endif

    -- method TreeViewColumn::set_clickable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "clickable"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE if the header is active."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_clickable" gtk_tree_view_column_set_clickable ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CInt ->                                 -- clickable : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnSetClickable ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the header to be active if /@clickable@/ is 'P.True'.  When the header is
    -- active, then it can take keyboard focus, and can be clicked.
    treeViewColumnSetClickable ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Bool
        -- ^ /@clickable@/: 'P.True' if the header is active.
        -> m ()
    treeViewColumnSetClickable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Bool -> m ()
    treeViewColumnSetClickable a
    treeColumn Bool
    clickable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let clickable' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    clickable
        gtk_tree_view_column_set_clickable treeColumn' clickable'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetClickableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetClickableMethodInfo a signature where
        overloadedMethod = treeViewColumnSetClickable

    instance O.OverloadedMethodInfo TreeViewColumnSetClickableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetClickable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetClickable"
            })

    #endif

    -- method TreeViewColumn::set_expand
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "expand"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE if the column should expand to fill available space."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_expand" gtk_tree_view_column_set_expand ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CInt ->                                 -- expand : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnSetExpand ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the column to take available extra space.  This space is shared equally
    -- amongst all columns that have the expand set to 'P.True'.  If no column has this
    -- option set, then the last column gets all extra space.  By default, every
    -- column is created with this 'P.False'.
    --
    -- Along with “fixed-width”, the “expand” property changes when the column is
    -- resized by the user.
    treeViewColumnSetExpand ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Bool
        -- ^ /@expand@/: 'P.True' if the column should expand to fill available space.
        -> m ()
    treeViewColumnSetExpand :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Bool -> m ()
    treeViewColumnSetExpand a
    treeColumn Bool
    expand = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let expand' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    expand
        gtk_tree_view_column_set_expand treeColumn' expand'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetExpandMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetExpandMethodInfo a signature where
        overloadedMethod = treeViewColumnSetExpand

    instance O.OverloadedMethodInfo TreeViewColumnSetExpandMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetExpand",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetExpand"
            })

    #endif

    -- method TreeViewColumn::set_fixed_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "fixed_width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The new fixed width, in pixels, or -1."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_fixed_width" gtk_tree_view_column_set_fixed_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Int32 ->                                -- fixed_width : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnSetFixedWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | If /@fixedWidth@/ is not -1, sets the fixed width of /@treeColumn@/; otherwise
    -- unsets it.  The effective value of /@fixedWidth@/ is clamped between the
    -- minimum and maximum width of the column; however, the value stored in the
    -- “fixed-width” property is not clamped.  If the column sizing is
    -- 'GI.Gtk.Enums.TreeViewColumnSizingGrowOnly' or 'GI.Gtk.Enums.TreeViewColumnSizingAutosize', setting
    -- a fixed width overrides the automatically calculated width.  Note that
    -- /@fixedWidth@/ is only a hint to GTK; the width actually allocated to the
    -- column may be greater or less than requested.
    --
    -- Along with “expand”, the “fixed-width” property changes when the column is
    -- resized by the user.
    treeViewColumnSetFixedWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Int32
        -- ^ /@fixedWidth@/: The new fixed width, in pixels, or -1.
        -> m ()
    treeViewColumnSetFixedWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Int32 -> m ()
    treeViewColumnSetFixedWidth a
    treeColumn Int32
    fixedWidth = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_set_fixed_width treeColumn' fixedWidth
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetFixedWidthMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetFixedWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnSetFixedWidth

    instance O.OverloadedMethodInfo TreeViewColumnSetFixedWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetFixedWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetFixedWidth"
            })

    #endif

    -- method TreeViewColumn::set_max_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "max_width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The maximum width of the column in pixels, or -1."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_max_width" gtk_tree_view_column_set_max_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Int32 ->                                -- max_width : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnSetMaxWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the maximum width of the /@treeColumn@/.  If /@maxWidth@/ is -1, then the
    -- maximum width is unset.  Note, the column can actually be wider than max
    -- width if it’s the last column in a view.  In this case, the column expands to
    -- fill any extra space.
    treeViewColumnSetMaxWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Int32
        -- ^ /@maxWidth@/: The maximum width of the column in pixels, or -1.
        -> m ()
    treeViewColumnSetMaxWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Int32 -> m ()
    treeViewColumnSetMaxWidth a
    treeColumn Int32
    maxWidth = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_set_max_width treeColumn' maxWidth
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetMaxWidthMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetMaxWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnSetMaxWidth

    instance O.OverloadedMethodInfo TreeViewColumnSetMaxWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetMaxWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetMaxWidth"
            })

    #endif

    -- method TreeViewColumn::set_min_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min_width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The minimum width of the column in pixels, or -1."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_min_width" gtk_tree_view_column_set_min_width ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Int32 ->                                -- min_width : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnSetMinWidth ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the minimum width of the /@treeColumn@/.  If /@minWidth@/ is -1, then the
    -- minimum width is unset.
    treeViewColumnSetMinWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Int32
        -- ^ /@minWidth@/: The minimum width of the column in pixels, or -1.
        -> m ()
    treeViewColumnSetMinWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Int32 -> m ()
    treeViewColumnSetMinWidth a
    treeColumn Int32
    minWidth = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_set_min_width treeColumn' minWidth
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetMinWidthMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetMinWidthMethodInfo a signature where
        overloadedMethod = treeViewColumnSetMinWidth

    instance O.OverloadedMethodInfo TreeViewColumnSetMinWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetMinWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetMinWidth"
            })

    #endif

    -- method TreeViewColumn::set_reorderable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "reorderable"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE, if the column can be reordered."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_reorderable" gtk_tree_view_column_set_reorderable ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CInt ->                                 -- reorderable : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnSetReorderable ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | If /@reorderable@/ is 'P.True', then the column can be reordered by the end user
    -- dragging the header.
    treeViewColumnSetReorderable ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> Bool
        -- ^ /@reorderable@/: 'P.True', if the column can be reordered.
        -> m ()
    treeViewColumnSetReorderable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Bool -> m ()
    treeViewColumnSetReorderable a
    treeColumn Bool
    reorderable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let reorderable' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    reorderable
        gtk_tree_view_column_set_reorderable treeColumn' reorderable'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetReorderableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetReorderableMethodInfo a signature where
        overloadedMethod = treeViewColumnSetReorderable

    instance O.OverloadedMethodInfo TreeViewColumnSetReorderableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetReorderable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetReorderable"
            })

    #endif

    -- method TreeViewColumn::set_resizable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "resizable"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE, if the column can be resized"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_resizable" gtk_tree_view_column_set_resizable ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CInt ->                                 -- resizable : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnSetResizable ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | If /@resizable@/ is 'P.True', then the user can explicitly resize the column by
    -- grabbing the outer edge of the column button.
    --
    -- If resizable is 'P.True' and
    -- sizing mode of the column is 'GI.Gtk.Enums.TreeViewColumnSizingAutosize', then the sizing
    -- mode is changed to 'GI.Gtk.Enums.TreeViewColumnSizingGrowOnly'.
    treeViewColumnSetResizable ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@
        -> Bool
        -- ^ /@resizable@/: 'P.True', if the column can be resized
        -> m ()
    treeViewColumnSetResizable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Bool -> m ()
    treeViewColumnSetResizable a
    treeColumn Bool
    resizable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let resizable' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    resizable
        gtk_tree_view_column_set_resizable treeColumn' resizable'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetResizableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetResizableMethodInfo a signature where
        overloadedMethod = treeViewColumnSetResizable

    instance O.OverloadedMethodInfo TreeViewColumnSetResizableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetResizable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetResizable"
            })

    #endif

    -- method TreeViewColumn::set_sizing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "TreeViewColumnSizing" }
    --           , argCType = Just "GtkTreeViewColumnSizing"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkTreeViewColumn`Sizing."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_sizing" gtk_tree_view_column_set_sizing ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CUInt ->                                -- type : TInterface (Name {namespace = "Gtk", name = "TreeViewColumnSizing"})
        IO ()

    {-# DEPRECATED treeViewColumnSetSizing ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the growth behavior of /@treeColumn@/ to /@type@/.
    treeViewColumnSetSizing ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Gtk.Enums.TreeViewColumnSizing
        -- ^ /@type@/: The @GtkTreeViewColumn@Sizing.
        -> m ()
    treeViewColumnSetSizing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> TreeViewColumnSizing -> m ()
    treeViewColumnSetSizing a
    treeColumn TreeViewColumnSizing
    type_ = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let type_' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (TreeViewColumnSizing -> Int) -> TreeViewColumnSizing -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TreeViewColumnSizing -> Int
    forall a. Enum a => a -> Int
    fromEnum) TreeViewColumnSizing
    type_
        gtk_tree_view_column_set_sizing treeColumn' type_'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetSizingMethodInfo
    instance (signature ~ (Gtk.Enums.TreeViewColumnSizing -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetSizingMethodInfo a signature where
        overloadedMethod = treeViewColumnSetSizing

    instance O.OverloadedMethodInfo TreeViewColumnSetSizingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSizing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetSizing"
            })

    #endif

    -- method TreeViewColumn::set_sort_column_id
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "sort_column_id"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The @sort_column_id of the model to sort on."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_sort_column_id" gtk_tree_view_column_set_sort_column_id ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Int32 ->                                -- sort_column_id : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnSetSortColumnId ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the logical /@sortColumnId@/ that this column sorts on when this column
    -- is selected for sorting.  Doing so makes the column header clickable.
    treeViewColumnSetSortColumnId ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> Int32
        -- ^ /@sortColumnId@/: The /@sortColumnId@/ of the model to sort on.
        -> m ()
    treeViewColumnSetSortColumnId :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Int32 -> m ()
    treeViewColumnSetSortColumnId a
    treeColumn Int32
    sortColumnId = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_set_sort_column_id treeColumn' sortColumnId
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetSortColumnIdMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetSortColumnIdMethodInfo a signature where
        overloadedMethod = treeViewColumnSetSortColumnId

    instance O.OverloadedMethodInfo TreeViewColumnSetSortColumnIdMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortColumnId",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetSortColumnId"
            })

    #endif

    -- method TreeViewColumn::set_sort_indicator
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE to display an indicator that the column is sorted"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_sort_indicator" gtk_tree_view_column_set_sort_indicator ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnSetSortIndicator ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Call this function with a /@setting@/ of 'P.True' to display an arrow in
    -- the header button indicating the column is sorted. Call
    -- 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortOrder' to change the direction of
    -- the arrow.
    treeViewColumnSetSortIndicator ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> Bool
        -- ^ /@setting@/: 'P.True' to display an indicator that the column is sorted
        -> m ()
    treeViewColumnSetSortIndicator :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Bool -> m ()
    treeViewColumnSetSortIndicator a
    treeColumn Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_tree_view_column_set_sort_indicator treeColumn' setting'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetSortIndicatorMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetSortIndicatorMethodInfo a signature where
        overloadedMethod = treeViewColumnSetSortIndicator

    instance O.OverloadedMethodInfo TreeViewColumnSetSortIndicatorMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortIndicator",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetSortIndicator"
            })

    #endif

    -- method TreeViewColumn::set_sort_order
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeViewColumn`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SortType" }
    --           , argCType = Just "GtkSortType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "sort order that the sort indicator should indicate"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_sort_order" gtk_tree_view_column_set_sort_order ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CUInt ->                                -- order : TInterface (Name {namespace = "Gtk", name = "SortType"})
        IO ()

    {-# DEPRECATED treeViewColumnSetSortOrder ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Changes the appearance of the sort indicator.
    --
    -- This does not actually sort the model.  Use
    -- 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortColumnId' if you want automatic sorting
    -- support.  This function is primarily for custom sorting behavior, and should
    -- be used in conjunction with 'GI.Gtk.Interfaces.TreeSortable.treeSortableSetSortColumnId' to do
    -- that. For custom models, the mechanism will vary.
    --
    -- The sort indicator changes direction to indicate normal sort or reverse sort.
    -- Note that you must have the sort indicator enabled to see anything when
    -- calling this function; see 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortIndicator'.
    treeViewColumnSetSortOrder ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: a @GtkTreeViewColumn@
        -> Gtk.Enums.SortType
        -- ^ /@order@/: sort order that the sort indicator should indicate
        -> m ()
    treeViewColumnSetSortOrder :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> SortType -> m ()
    treeViewColumnSetSortOrder a
    treeColumn SortType
    order = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let order' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (SortType -> Int) -> SortType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SortType -> Int
    forall a. Enum a => a -> Int
    fromEnum) SortType
    order
        gtk_tree_view_column_set_sort_order treeColumn' order'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetSortOrderMethodInfo
    instance (signature ~ (Gtk.Enums.SortType -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetSortOrderMethodInfo a signature where
        overloadedMethod = treeViewColumnSetSortOrder

    instance O.OverloadedMethodInfo TreeViewColumnSetSortOrderMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortOrder",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetSortOrder"
            })

    #endif

    -- method TreeViewColumn::set_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "spacing"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "distance between cell renderers in pixels."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_spacing" gtk_tree_view_column_set_spacing ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Int32 ->                                -- spacing : TBasicType TInt
        IO ()

    {-# DEPRECATED treeViewColumnSetSpacing ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the spacing field of /@treeColumn@/, which is the number of pixels to
    -- place between cell renderers packed into it.
    treeViewColumnSetSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Int32
        -- ^ /@spacing@/: distance between cell renderers in pixels.
        -> m ()
    treeViewColumnSetSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Int32 -> m ()
    treeViewColumnSetSpacing a
    treeColumn Int32
    spacing = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        gtk_tree_view_column_set_spacing treeColumn' spacing
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetSpacingMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetSpacingMethodInfo a signature where
        overloadedMethod = treeViewColumnSetSpacing

    instance O.OverloadedMethodInfo TreeViewColumnSetSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetSpacing"
            })

    #endif

    -- method TreeViewColumn::set_title
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "title"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The title of the @tree_column."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_title" gtk_tree_view_column_set_title ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CString ->                              -- title : TBasicType TUTF8
        IO ()

    {-# DEPRECATED treeViewColumnSetTitle ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the title of the /@treeColumn@/.  If a custom widget has been set, then
    -- this value is ignored.
    treeViewColumnSetTitle ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> T.Text
        -- ^ /@title@/: The title of the /@treeColumn@/.
        -> m ()
    treeViewColumnSetTitle :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Text -> m ()
    treeViewColumnSetTitle a
    treeColumn Text
    title = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        title' <- textToCString title
        gtk_tree_view_column_set_title treeColumn' title'
        touchManagedPtr treeColumn
        freeMem title'
        return ()

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

    instance O.OverloadedMethodInfo TreeViewColumnSetTitleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetTitle",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetTitle"
            })

    #endif

    -- method TreeViewColumn::set_visible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "visible"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE if the @tree_column is visible."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_visible" gtk_tree_view_column_set_visible ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        CInt ->                                 -- visible : TBasicType TBoolean
        IO ()

    {-# DEPRECATED treeViewColumnSetVisible ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the visibility of /@treeColumn@/.
    treeViewColumnSetVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Bool
        -- ^ /@visible@/: 'P.True' if the /@treeColumn@/ is visible.
        -> m ()
    treeViewColumnSetVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a -> Bool -> m ()
    treeViewColumnSetVisible a
    treeColumn Bool
    visible = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        let visible' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    visible
        gtk_tree_view_column_set_visible treeColumn' visible'
        touchManagedPtr treeColumn
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetVisibleMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.OverloadedMethod TreeViewColumnSetVisibleMethodInfo a signature where
        overloadedMethod = treeViewColumnSetVisible

    instance O.OverloadedMethodInfo TreeViewColumnSetVisibleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetVisible",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetVisible"
            })

    #endif

    -- method TreeViewColumn::set_widget
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "tree_column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeViewColumn" }
    --           , argCType = Just "GtkTreeViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreeViewColumn`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A child `GtkWidget`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_view_column_set_widget" gtk_tree_view_column_set_widget ::
        Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
        Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    {-# DEPRECATED treeViewColumnSetWidget ["(Since version 4.10)","Use GtkColumnView instead"] #-}
    -- | Sets the widget in the header to be /@widget@/.  If widget is 'P.Nothing', then the
    -- header button is set with a @GtkLabel@ set to the title of /@treeColumn@/.
    treeViewColumnSetWidget ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@treeColumn@/: A @GtkTreeViewColumn@.
        -> Maybe (b)
        -- ^ /@widget@/: A child @GtkWidget@
        -> m ()
    treeViewColumnSetWidget :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeViewColumn a, IsWidget b) =>
    a -> Maybe b -> m ()
    treeViewColumnSetWidget a
    treeColumn Maybe b
    widget = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        treeColumn' <- a -> IO (Ptr TreeViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    treeColumn
        maybeWidget <- case widget of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jWidget -> do
                jWidget' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jWidget
                return jWidget'
        gtk_tree_view_column_set_widget treeColumn' maybeWidget
        touchManagedPtr treeColumn
        whenJust widget touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeViewColumnSetWidgetMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TreeViewColumnSetWidgetMethodInfo a signature where
        overloadedMethod = treeViewColumnSetWidget

    instance O.OverloadedMethodInfo TreeViewColumnSetWidgetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetWidget",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeViewColumn.html#v:treeViewColumnSetWidget"
            })

    #endif