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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Presents a large dynamic list of items using multiple columns with headers.
    --
    -- @GtkColumnView@ uses the factories of its columns to generate a cell widget for
    -- each column, for each visible item and displays them together as the row for
    -- this item.
    --
    -- The [ColumnView:showRowSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showRowSeparators") and
    -- [ColumnView:showColumnSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showColumnSeparators") properties offer a simple way
    -- to display separators between the rows or columns.
    --
    -- @GtkColumnView@ allows the user to select items according to the selection
    -- characteristics of the model. For models that allow multiple selected items,
    -- it is possible to turn on *rubberband selection*, using
    -- [ColumnView:enableRubberband]("GI.Gtk.Objects.ColumnView#g:attr:enableRubberband").
    --
    -- The column view supports sorting that can be customized by the user by
    -- clicking on column headers. To set this up, the @GtkSorter@ returned by
    -- 'GI.Gtk.Objects.ColumnView.columnViewGetSorter' must be attached to a sort model for the
    -- data that the view is showing, and the columns must have sorters attached to
    -- them by calling 'GI.Gtk.Objects.ColumnViewColumn.columnViewColumnSetSorter'. The initial sort
    -- order can be set with 'GI.Gtk.Objects.ColumnView.columnViewSortByColumn'.
    --
    -- The column view also supports interactive resizing and reordering of
    -- columns, via Drag-and-Drop of the column headers. This can be enabled or
    -- disabled with the [ColumnView:reorderable]("GI.Gtk.Objects.ColumnView#g:attr:reorderable") and
    -- [ColumnViewColumn:resizable]("GI.Gtk.Objects.ColumnViewColumn#g:attr:resizable") properties.
    --
    -- To learn more about the list widget framework, see the
    -- <https://docs.gtk.org/gtk4/section-list-widget.html overview>.
    --
    -- = CSS nodes
    --
    --
    --
    -- >columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
    -- >├── header
    -- >│   ├── <column header>
    -- >┊   ┊
    -- >│   ╰── <column header>
    -- >│
    -- >├── listview
    -- >│
    -- >┊
    -- >╰── [rubberband]
    --
    --
    -- @GtkColumnView@ uses a single CSS node named columnview. It may carry the
    -- .column-separators style class, when [ColumnView:showColumnSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showColumnSeparators")
    -- property is set. Header widgets appear below a node with name header.
    -- The rows are contained in a @GtkListView@ widget, so there is a listview
    -- node with the same structure as for a standalone @GtkListView@ widget.
    -- If [ColumnView:showRowSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showRowSeparators") is set, it will be passed
    -- on to the list view, causing its CSS node to carry the .separators style class.
    -- For rubberband selection, a node with name rubberband is used.
    --
    -- The main columnview node may also carry style classes to select
    -- the style of <https://docs.gtk.org/gtk4/section-list-widget.html#list-styles list presentation>:
    -- .rich-list, .navigation-sidebar or .data-table.
    --
    -- = Accessibility
    --
    -- @GtkColumnView@ uses the 'GI.Gtk.Enums.AccessibleRoleTreeGrid' role, header title
    -- widgets are using the 'GI.Gtk.Enums.AccessibleRoleColumnHeader' role. The row widgets
    -- are using the 'GI.Gtk.Enums.AccessibleRoleRow' role, and individual cells are using
    -- the 'GI.Gtk.Enums.AccessibleRoleGridCell' role

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

    module GI.Gtk.Objects.ColumnView
        (

    -- * Exported types
        ColumnView(..)                          ,
        IsColumnView                            ,
        toColumnView                            ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [appendColumn]("GI.Gtk.Objects.ColumnView#g:method:appendColumn"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertColumn]("GI.Gtk.Objects.ColumnView#g:method:insertColumn"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeColumn]("GI.Gtk.Objects.ColumnView#g:method:removeColumn"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [scrollTo]("GI.Gtk.Objects.ColumnView#g:method:scrollTo"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [sortByColumn]("GI.Gtk.Objects.ColumnView#g:method:sortByColumn"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updatePlatformState]("GI.Gtk.Interfaces.Accessible#g:method:updatePlatformState"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAccessibleId]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleId"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getColumns]("GI.Gtk.Objects.ColumnView#g:method:getColumns"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEnableRubberband]("GI.Gtk.Objects.ColumnView#g:method:getEnableRubberband"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getHadjustment"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeaderFactory]("GI.Gtk.Objects.ColumnView#g:method:getHeaderFactory"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModel]("GI.Gtk.Objects.ColumnView#g:method:getModel"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getReorderable]("GI.Gtk.Objects.ColumnView#g:method:getReorderable"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getRowFactory]("GI.Gtk.Objects.ColumnView#g:method:getRowFactory"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowColumnSeparators]("GI.Gtk.Objects.ColumnView#g:method:getShowColumnSeparators"), [getShowRowSeparators]("GI.Gtk.Objects.ColumnView#g:method:getShowRowSeparators"), [getSingleClickActivate]("GI.Gtk.Objects.ColumnView#g:method:getSingleClickActivate"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSorter]("GI.Gtk.Objects.ColumnView#g:method:getSorter"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTabBehavior]("GI.Gtk.Objects.ColumnView#g:method:getTabBehavior"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getVadjustment"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEnableRubberband]("GI.Gtk.Objects.ColumnView#g:method:setEnableRubberband"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHeaderFactory]("GI.Gtk.Objects.ColumnView#g:method:setHeaderFactory"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setModel]("GI.Gtk.Objects.ColumnView#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setReorderable]("GI.Gtk.Objects.ColumnView#g:method:setReorderable"), [setRowFactory]("GI.Gtk.Objects.ColumnView#g:method:setRowFactory"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowColumnSeparators]("GI.Gtk.Objects.ColumnView#g:method:setShowColumnSeparators"), [setShowRowSeparators]("GI.Gtk.Objects.ColumnView#g:method:setShowRowSeparators"), [setSingleClickActivate]("GI.Gtk.Objects.ColumnView#g:method:setSingleClickActivate"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTabBehavior]("GI.Gtk.Objects.ColumnView#g:method:setTabBehavior"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setVadjustment"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setVscrollPolicy").

    #if defined(ENABLE_OVERLOADING)
        ResolveColumnViewMethod                 ,
    #endif

    -- ** appendColumn #method:appendColumn#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewAppendColumnMethodInfo        ,
    #endif
        columnViewAppendColumn                  ,

    -- ** getColumns #method:getColumns#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetColumnsMethodInfo          ,
    #endif
        columnViewGetColumns                    ,

    -- ** getEnableRubberband #method:getEnableRubberband#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetEnableRubberbandMethodInfo ,
    #endif
        columnViewGetEnableRubberband           ,

    -- ** getHeaderFactory #method:getHeaderFactory#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetHeaderFactoryMethodInfo    ,
    #endif
        columnViewGetHeaderFactory              ,

    -- ** getModel #method:getModel#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetModelMethodInfo            ,
    #endif
        columnViewGetModel                      ,

    -- ** getReorderable #method:getReorderable#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetReorderableMethodInfo      ,
    #endif
        columnViewGetReorderable                ,

    -- ** getRowFactory #method:getRowFactory#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetRowFactoryMethodInfo       ,
    #endif
        columnViewGetRowFactory                 ,

    -- ** getShowColumnSeparators #method:getShowColumnSeparators#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetShowColumnSeparatorsMethodInfo,
    #endif
        columnViewGetShowColumnSeparators       ,

    -- ** getShowRowSeparators #method:getShowRowSeparators#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetShowRowSeparatorsMethodInfo,
    #endif
        columnViewGetShowRowSeparators          ,

    -- ** getSingleClickActivate #method:getSingleClickActivate#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetSingleClickActivateMethodInfo,
    #endif
        columnViewGetSingleClickActivate        ,

    -- ** getSorter #method:getSorter#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetSorterMethodInfo           ,
    #endif
        columnViewGetSorter                     ,

    -- ** getTabBehavior #method:getTabBehavior#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewGetTabBehaviorMethodInfo      ,
    #endif
        columnViewGetTabBehavior                ,

    -- ** insertColumn #method:insertColumn#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewInsertColumnMethodInfo        ,
    #endif
        columnViewInsertColumn                  ,

    -- ** new #method:new#

        columnViewNew                           ,

    -- ** removeColumn #method:removeColumn#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewRemoveColumnMethodInfo        ,
    #endif
        columnViewRemoveColumn                  ,

    -- ** scrollTo #method:scrollTo#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewScrollToMethodInfo            ,
    #endif
        columnViewScrollTo                      ,

    -- ** setEnableRubberband #method:setEnableRubberband#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetEnableRubberbandMethodInfo ,
    #endif
        columnViewSetEnableRubberband           ,

    -- ** setHeaderFactory #method:setHeaderFactory#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetHeaderFactoryMethodInfo    ,
    #endif
        columnViewSetHeaderFactory              ,

    -- ** setModel #method:setModel#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetModelMethodInfo            ,
    #endif
        columnViewSetModel                      ,

    -- ** setReorderable #method:setReorderable#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetReorderableMethodInfo      ,
    #endif
        columnViewSetReorderable                ,

    -- ** setRowFactory #method:setRowFactory#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetRowFactoryMethodInfo       ,
    #endif
        columnViewSetRowFactory                 ,

    -- ** setShowColumnSeparators #method:setShowColumnSeparators#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetShowColumnSeparatorsMethodInfo,
    #endif
        columnViewSetShowColumnSeparators       ,

    -- ** setShowRowSeparators #method:setShowRowSeparators#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetShowRowSeparatorsMethodInfo,
    #endif
        columnViewSetShowRowSeparators          ,

    -- ** setSingleClickActivate #method:setSingleClickActivate#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetSingleClickActivateMethodInfo,
    #endif
        columnViewSetSingleClickActivate        ,

    -- ** setTabBehavior #method:setTabBehavior#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSetTabBehaviorMethodInfo      ,
    #endif
        columnViewSetTabBehavior                ,

    -- ** sortByColumn #method:sortByColumn#

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSortByColumnMethodInfo        ,
    #endif
        columnViewSortByColumn                  ,

     -- * Properties

    -- ** columns #attr:columns#
    -- | The list of columns.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewColumnsPropertyInfo           ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewColumns                       ,
    #endif
        getColumnViewColumns                    ,

    -- ** enableRubberband #attr:enableRubberband#
    -- | Allow rubberband selection.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewEnableRubberbandPropertyInfo  ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewEnableRubberband              ,
    #endif
        constructColumnViewEnableRubberband     ,
        getColumnViewEnableRubberband           ,
        setColumnViewEnableRubberband           ,

    -- ** headerFactory #attr:headerFactory#
    -- | Factory for creating header widgets.
    --
    -- The factory must be for configuring t'GI.Gtk.Objects.ListHeader.ListHeader' objects.
    --
    -- /Since: 4.12/

    #if defined(ENABLE_OVERLOADING)
        ColumnViewHeaderFactoryPropertyInfo     ,
    #endif
        clearColumnViewHeaderFactory            ,
    #if defined(ENABLE_OVERLOADING)
        columnViewHeaderFactory                 ,
    #endif
        constructColumnViewHeaderFactory        ,
        getColumnViewHeaderFactory              ,
        setColumnViewHeaderFactory              ,

    -- ** model #attr:model#
    -- | Model for the items displayed.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewModelPropertyInfo             ,
    #endif
        clearColumnViewModel                    ,
    #if defined(ENABLE_OVERLOADING)
        columnViewModel                         ,
    #endif
        constructColumnViewModel                ,
        getColumnViewModel                      ,
        setColumnViewModel                      ,

    -- ** reorderable #attr:reorderable#
    -- | Whether columns are reorderable.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewReorderablePropertyInfo       ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewReorderable                   ,
    #endif
        constructColumnViewReorderable          ,
        getColumnViewReorderable                ,
        setColumnViewReorderable                ,

    -- ** rowFactory #attr:rowFactory#
    -- | The factory used for configuring rows.
    --
    -- The factory must be for configuring t'GI.Gtk.Objects.ColumnViewRow.ColumnViewRow' objects.
    --
    -- /Since: 4.12/

    #if defined(ENABLE_OVERLOADING)
        ColumnViewRowFactoryPropertyInfo        ,
    #endif
        clearColumnViewRowFactory               ,
    #if defined(ENABLE_OVERLOADING)
        columnViewRowFactory                    ,
    #endif
        constructColumnViewRowFactory           ,
        getColumnViewRowFactory                 ,
        setColumnViewRowFactory                 ,

    -- ** showColumnSeparators #attr:showColumnSeparators#
    -- | Show separators between columns.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewShowColumnSeparatorsPropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewShowColumnSeparators          ,
    #endif
        constructColumnViewShowColumnSeparators ,
        getColumnViewShowColumnSeparators       ,
        setColumnViewShowColumnSeparators       ,

    -- ** showRowSeparators #attr:showRowSeparators#
    -- | Show separators between rows.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewShowRowSeparatorsPropertyInfo ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewShowRowSeparators             ,
    #endif
        constructColumnViewShowRowSeparators    ,
        getColumnViewShowRowSeparators          ,
        setColumnViewShowRowSeparators          ,

    -- ** singleClickActivate #attr:singleClickActivate#
    -- | Activate rows on single click and select them on hover.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSingleClickActivatePropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewSingleClickActivate           ,
    #endif
        constructColumnViewSingleClickActivate  ,
        getColumnViewSingleClickActivate        ,
        setColumnViewSingleClickActivate        ,

    -- ** sorter #attr:sorter#
    -- | Sorter with the sorting choices of the user.

    #if defined(ENABLE_OVERLOADING)
        ColumnViewSorterPropertyInfo            ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewSorter                        ,
    #endif
        getColumnViewSorter                     ,

    -- ** tabBehavior #attr:tabBehavior#
    -- | Behavior of the \<kbd>Tab\<\/kbd> key
    --
    -- /Since: 4.12/

    #if defined(ENABLE_OVERLOADING)
        ColumnViewTabBehaviorPropertyInfo       ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        columnViewTabBehavior                   ,
    #endif
        constructColumnViewTabBehavior          ,
        getColumnViewTabBehavior                ,
        setColumnViewTabBehavior                ,

     -- * Signals

    -- ** activate #signal:activate#

        ColumnViewActivateCallback              ,
    #if defined(ENABLE_OVERLOADING)
        ColumnViewActivateSignalInfo            ,
    #endif
        afterColumnViewActivate                 ,
        onColumnViewActivate                    ,

        ) 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.Gio.Objects.MenuModel as Gio.MenuModel
    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.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.Scrollable as Gtk.Scrollable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.SelectionModel as Gtk.SelectionModel
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ColumnViewColumn as Gtk.ColumnViewColumn
    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.ListItemFactory as Gtk.ListItemFactory
    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.Sorter as Gtk.Sorter
    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.Bitset as Gtk.Bitset
    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.ScrollInfo as Gtk.ScrollInfo
    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.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    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.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.SelectionModel as Gtk.SelectionModel
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ColumnViewColumn as Gtk.ColumnViewColumn
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ListItemFactory as Gtk.ListItemFactory
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.ScrollInfo as Gtk.ScrollInfo

    #endif

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

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

    foreign import ccall "gtk_column_view_get_type"
        c_gtk_column_view_get_type :: IO B.Types.GType

    instance B.Types.TypedObject ColumnView where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_column_view_get_type

    instance B.Types.GObject ColumnView

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

    instance O.HasParentTypes ColumnView
    type instance O.ParentTypes ColumnView = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Scrollable.Scrollable]

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

    -- | Convert t'ColumnView' 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 ColumnView) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_column_view_get_type
        gvalueSet_ :: Ptr GValue -> Maybe ColumnView -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe ColumnView
    P.Nothing = Ptr GValue -> Ptr ColumnView -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr ColumnView
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr ColumnView)
        gvalueSet_ Ptr GValue
    gv (P.Just ColumnView
    obj) = ColumnView -> (Ptr ColumnView -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr ColumnView
    obj (Ptr GValue -> Ptr ColumnView -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe ColumnView)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr ColumnView)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr ColumnView)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject ColumnView ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveColumnViewMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveColumnViewMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
        ResolveColumnViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
        ResolveColumnViewMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
        ResolveColumnViewMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
        ResolveColumnViewMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
        ResolveColumnViewMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
        ResolveColumnViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
        ResolveColumnViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
        ResolveColumnViewMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
        ResolveColumnViewMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
        ResolveColumnViewMethod "appendColumn" o = ColumnViewAppendColumnMethodInfo
        ResolveColumnViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveColumnViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveColumnViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
        ResolveColumnViewMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
        ResolveColumnViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
        ResolveColumnViewMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
        ResolveColumnViewMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
        ResolveColumnViewMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
        ResolveColumnViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
        ResolveColumnViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
        ResolveColumnViewMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
        ResolveColumnViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
        ResolveColumnViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
        ResolveColumnViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveColumnViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveColumnViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveColumnViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
        ResolveColumnViewMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
        ResolveColumnViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
        ResolveColumnViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
        ResolveColumnViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
        ResolveColumnViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
        ResolveColumnViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
        ResolveColumnViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
        ResolveColumnViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
        ResolveColumnViewMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
        ResolveColumnViewMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
        ResolveColumnViewMethod "insertColumn" o = ColumnViewInsertColumnMethodInfo
        ResolveColumnViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
        ResolveColumnViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
        ResolveColumnViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveColumnViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
        ResolveColumnViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
        ResolveColumnViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
        ResolveColumnViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
        ResolveColumnViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
        ResolveColumnViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
        ResolveColumnViewMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
        ResolveColumnViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
        ResolveColumnViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveColumnViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveColumnViewMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
        ResolveColumnViewMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
        ResolveColumnViewMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
        ResolveColumnViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
        ResolveColumnViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
        ResolveColumnViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
        ResolveColumnViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
        ResolveColumnViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveColumnViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveColumnViewMethod "removeColumn" o = ColumnViewRemoveColumnMethodInfo
        ResolveColumnViewMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
        ResolveColumnViewMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
        ResolveColumnViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
        ResolveColumnViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
        ResolveColumnViewMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
        ResolveColumnViewMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
        ResolveColumnViewMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
        ResolveColumnViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveColumnViewMethod "scrollTo" o = ColumnViewScrollToMethodInfo
        ResolveColumnViewMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
        ResolveColumnViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
        ResolveColumnViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
        ResolveColumnViewMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
        ResolveColumnViewMethod "sortByColumn" o = ColumnViewSortByColumnMethodInfo
        ResolveColumnViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveColumnViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveColumnViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveColumnViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
        ResolveColumnViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
        ResolveColumnViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
        ResolveColumnViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
        ResolveColumnViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
        ResolveColumnViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveColumnViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
        ResolveColumnViewMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
        ResolveColumnViewMethod "updatePlatformState" o = Gtk.Accessible.AccessibleUpdatePlatformStateMethodInfo
        ResolveColumnViewMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
        ResolveColumnViewMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
        ResolveColumnViewMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
        ResolveColumnViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveColumnViewMethod "getAccessibleId" o = Gtk.Accessible.AccessibleGetAccessibleIdMethodInfo
        ResolveColumnViewMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
        ResolveColumnViewMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
        ResolveColumnViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
        ResolveColumnViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
        ResolveColumnViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
        ResolveColumnViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
        ResolveColumnViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
        ResolveColumnViewMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
        ResolveColumnViewMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
        ResolveColumnViewMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
        ResolveColumnViewMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
        ResolveColumnViewMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
        ResolveColumnViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
        ResolveColumnViewMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
        ResolveColumnViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
        ResolveColumnViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
        ResolveColumnViewMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
        ResolveColumnViewMethod "getColumns" o = ColumnViewGetColumnsMethodInfo
        ResolveColumnViewMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
        ResolveColumnViewMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
        ResolveColumnViewMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
        ResolveColumnViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveColumnViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
        ResolveColumnViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
        ResolveColumnViewMethod "getEnableRubberband" o = ColumnViewGetEnableRubberbandMethodInfo
        ResolveColumnViewMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
        ResolveColumnViewMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
        ResolveColumnViewMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
        ResolveColumnViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
        ResolveColumnViewMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
        ResolveColumnViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
        ResolveColumnViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
        ResolveColumnViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
        ResolveColumnViewMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
        ResolveColumnViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
        ResolveColumnViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
        ResolveColumnViewMethod "getHeaderFactory" o = ColumnViewGetHeaderFactoryMethodInfo
        ResolveColumnViewMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
        ResolveColumnViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
        ResolveColumnViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
        ResolveColumnViewMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
        ResolveColumnViewMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
        ResolveColumnViewMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
        ResolveColumnViewMethod "getLimitEvents" o = Gtk.Widget.WidgetGetLimitEventsMethodInfo
        ResolveColumnViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
        ResolveColumnViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
        ResolveColumnViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
        ResolveColumnViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
        ResolveColumnViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
        ResolveColumnViewMethod "getModel" o = ColumnViewGetModelMethodInfo
        ResolveColumnViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
        ResolveColumnViewMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
        ResolveColumnViewMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
        ResolveColumnViewMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
        ResolveColumnViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
        ResolveColumnViewMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
        ResolveColumnViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
        ResolveColumnViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
        ResolveColumnViewMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
        ResolveColumnViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
        ResolveColumnViewMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
        ResolveColumnViewMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
        ResolveColumnViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveColumnViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveColumnViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
        ResolveColumnViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
        ResolveColumnViewMethod "getReorderable" o = ColumnViewGetReorderableMethodInfo
        ResolveColumnViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
        ResolveColumnViewMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
        ResolveColumnViewMethod "getRowFactory" o = ColumnViewGetRowFactoryMethodInfo
        ResolveColumnViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
        ResolveColumnViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
        ResolveColumnViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
        ResolveColumnViewMethod "getShowColumnSeparators" o = ColumnViewGetShowColumnSeparatorsMethodInfo
        ResolveColumnViewMethod "getShowRowSeparators" o = ColumnViewGetShowRowSeparatorsMethodInfo
        ResolveColumnViewMethod "getSingleClickActivate" o = ColumnViewGetSingleClickActivateMethodInfo
        ResolveColumnViewMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
        ResolveColumnViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
        ResolveColumnViewMethod "getSorter" o = ColumnViewGetSorterMethodInfo
        ResolveColumnViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
        ResolveColumnViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
        ResolveColumnViewMethod "getTabBehavior" o = ColumnViewGetTabBehaviorMethodInfo
        ResolveColumnViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
        ResolveColumnViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
        ResolveColumnViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
        ResolveColumnViewMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
        ResolveColumnViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
        ResolveColumnViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
        ResolveColumnViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
        ResolveColumnViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
        ResolveColumnViewMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
        ResolveColumnViewMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
        ResolveColumnViewMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
        ResolveColumnViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
        ResolveColumnViewMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
        ResolveColumnViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
        ResolveColumnViewMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
        ResolveColumnViewMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
        ResolveColumnViewMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
        ResolveColumnViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveColumnViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveColumnViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
        ResolveColumnViewMethod "setEnableRubberband" o = ColumnViewSetEnableRubberbandMethodInfo
        ResolveColumnViewMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
        ResolveColumnViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
        ResolveColumnViewMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
        ResolveColumnViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
        ResolveColumnViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
        ResolveColumnViewMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
        ResolveColumnViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
        ResolveColumnViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
        ResolveColumnViewMethod "setHeaderFactory" o = ColumnViewSetHeaderFactoryMethodInfo
        ResolveColumnViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
        ResolveColumnViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
        ResolveColumnViewMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
        ResolveColumnViewMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
        ResolveColumnViewMethod "setLimitEvents" o = Gtk.Widget.WidgetSetLimitEventsMethodInfo
        ResolveColumnViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
        ResolveColumnViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
        ResolveColumnViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
        ResolveColumnViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
        ResolveColumnViewMethod "setModel" o = ColumnViewSetModelMethodInfo
        ResolveColumnViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
        ResolveColumnViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
        ResolveColumnViewMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
        ResolveColumnViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
        ResolveColumnViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveColumnViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
        ResolveColumnViewMethod "setReorderable" o = ColumnViewSetReorderableMethodInfo
        ResolveColumnViewMethod "setRowFactory" o = ColumnViewSetRowFactoryMethodInfo
        ResolveColumnViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
        ResolveColumnViewMethod "setShowColumnSeparators" o = ColumnViewSetShowColumnSeparatorsMethodInfo
        ResolveColumnViewMethod "setShowRowSeparators" o = ColumnViewSetShowRowSeparatorsMethodInfo
        ResolveColumnViewMethod "setSingleClickActivate" o = ColumnViewSetSingleClickActivateMethodInfo
        ResolveColumnViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
        ResolveColumnViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
        ResolveColumnViewMethod "setTabBehavior" o = ColumnViewSetTabBehaviorMethodInfo
        ResolveColumnViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
        ResolveColumnViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
        ResolveColumnViewMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
        ResolveColumnViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
        ResolveColumnViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
        ResolveColumnViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
        ResolveColumnViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
        ResolveColumnViewMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
        ResolveColumnViewMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveColumnViewMethod t ColumnView, O.OverloadedMethod info ColumnView p) => OL.IsLabel t (ColumnView -> 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 ~ ResolveColumnViewMethod t ColumnView, O.OverloadedMethod info ColumnView p, R.HasField t ColumnView p) => R.HasField t ColumnView p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif

    -- signal ColumnView::activate
    -- | Emitted when a row has been activated by the user, usually via activating
    -- the GtkListBase|list.activate-item action.
    --
    -- This allows for a convenient way to handle activation in a columnview.
    -- See 'GI.Gtk.Objects.ListItem.listItemSetActivatable' for details on how to use this
    -- signal.
    type ColumnViewActivateCallback =
        Word32
        -- ^ /@position@/: position of item to activate
        -> IO ()

    type C_ColumnViewActivateCallback =
        Ptr ColumnView ->                       -- object
        Word32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_ColumnViewActivateCallback ::
        GObject a => (a -> ColumnViewActivateCallback) ->
        C_ColumnViewActivateCallback
    wrap_ColumnViewActivateCallback :: forall a.
    GObject a =>
    (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
    wrap_ColumnViewActivateCallback a -> ColumnViewActivateCallback
    gi'cb Ptr ColumnView
    gi'selfPtr Word32
    position Ptr ()
    _ = do
        Ptr ColumnView -> (ColumnView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr ColumnView
    gi'selfPtr ((ColumnView -> IO ()) -> IO ()) -> (ColumnView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ColumnView
    gi'self -> a -> ColumnViewActivateCallback
    gi'cb (ColumnView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce ColumnView
    gi'self)  Word32
    position

    -- | Connect a signal handler for the [activate](#signal:activate) 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' columnView #activate callback
    -- @
    --
    --
    onColumnViewActivate :: (IsColumnView a, MonadIO m) => a -> ((?self :: a) => ColumnViewActivateCallback) -> m SignalHandlerId
    onColumnViewActivate :: forall a (m :: * -> *).
    (IsColumnView a, MonadIO m) =>
    a
    -> ((?self::a) => ColumnViewActivateCallback) -> m SignalHandlerId
    onColumnViewActivate a
    obj (?self::a) => ColumnViewActivateCallback
    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 -> ColumnViewActivateCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ColumnViewActivateCallback
    ColumnViewActivateCallback
    cb
        let wrapped' :: C_ColumnViewActivateCallback
    wrapped' = (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
    forall a.
    GObject a =>
    (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
    wrap_ColumnViewActivateCallback a -> ColumnViewActivateCallback
    wrapped
        wrapped'' <- C_ColumnViewActivateCallback
    -> IO (FunPtr C_ColumnViewActivateCallback)
    mk_ColumnViewActivateCallback C_ColumnViewActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [activate](#signal:activate) 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' columnView #activate 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.
    --
    afterColumnViewActivate :: (IsColumnView a, MonadIO m) => a -> ((?self :: a) => ColumnViewActivateCallback) -> m SignalHandlerId
    afterColumnViewActivate :: forall a (m :: * -> *).
    (IsColumnView a, MonadIO m) =>
    a
    -> ((?self::a) => ColumnViewActivateCallback) -> m SignalHandlerId
    afterColumnViewActivate a
    obj (?self::a) => ColumnViewActivateCallback
    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 -> ColumnViewActivateCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ColumnViewActivateCallback
    ColumnViewActivateCallback
    cb
        let wrapped' :: C_ColumnViewActivateCallback
    wrapped' = (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
    forall a.
    GObject a =>
    (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
    wrap_ColumnViewActivateCallback a -> ColumnViewActivateCallback
    wrapped
        wrapped'' <- C_ColumnViewActivateCallback
    -> IO (FunPtr C_ColumnViewActivateCallback)
    mk_ColumnViewActivateCallback C_ColumnViewActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectAfter Nothing

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

    #endif

    -- VVV Prop "columns"
       -- Type: TInterface (Name {namespace = "Gio", name = "ListModel"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

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

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

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

    -- | Get the value of the “@enable-rubberband@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' columnView #enableRubberband
    -- @
    getColumnViewEnableRubberband :: (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewEnableRubberband :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewEnableRubberband 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
    "enable-rubberband"

    -- | Set the value of the “@enable-rubberband@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #enableRubberband 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewEnableRubberband :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
    setColumnViewEnableRubberband :: forall (m :: * -> *) o.
    (MonadIO m, IsColumnView o) =>
    o -> Bool -> m ()
    setColumnViewEnableRubberband 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
    "enable-rubberband" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@enable-rubberband@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewEnableRubberband :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructColumnViewEnableRubberband :: forall o (m :: * -> *).
    (IsColumnView o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructColumnViewEnableRubberband 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
    "enable-rubberband" Bool
    val

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

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

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

    -- | Set the value of the “@header-factory@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #headerFactory 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewHeaderFactory :: (MonadIO m, IsColumnView o, Gtk.ListItemFactory.IsListItemFactory a) => o -> a -> m ()
    setColumnViewHeaderFactory :: forall (m :: * -> *) o a.
    (MonadIO m, IsColumnView o, IsListItemFactory a) =>
    o -> a -> m ()
    setColumnViewHeaderFactory 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
    "header-factory" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@header-factory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewHeaderFactory :: (IsColumnView o, MIO.MonadIO m, Gtk.ListItemFactory.IsListItemFactory a) => a -> m (GValueConstruct o)
    constructColumnViewHeaderFactory :: forall o (m :: * -> *) a.
    (IsColumnView o, MonadIO m, IsListItemFactory a) =>
    a -> m (GValueConstruct o)
    constructColumnViewHeaderFactory 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
    "header-factory" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    -- | Set the value of the “@header-factory@” 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' #headerFactory
    -- @
    clearColumnViewHeaderFactory :: (MonadIO m, IsColumnView o) => o -> m ()
    clearColumnViewHeaderFactory :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m ()
    clearColumnViewHeaderFactory 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 ListItemFactory -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "header-factory" (Maybe ListItemFactory
    forall a. Maybe a
    Nothing :: Maybe Gtk.ListItemFactory.ListItemFactory)

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewHeaderFactoryPropertyInfo
    instance AttrInfo ColumnViewHeaderFactoryPropertyInfo where
        type AttrAllowedOps ColumnViewHeaderFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ColumnViewHeaderFactoryPropertyInfo = IsColumnView
        type AttrSetTypeConstraint ColumnViewHeaderFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferTypeConstraint ColumnViewHeaderFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferType ColumnViewHeaderFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
        type AttrGetType ColumnViewHeaderFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
        type AttrLabel ColumnViewHeaderFactoryPropertyInfo = "header-factory"
        type AttrOrigin ColumnViewHeaderFactoryPropertyInfo = ColumnView
        attrGet = getColumnViewHeaderFactory
        attrSet = setColumnViewHeaderFactory
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
        attrConstruct = constructColumnViewHeaderFactory
        attrClear = clearColumnViewHeaderFactory
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.headerFactory"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ColumnView.html#g:attr:headerFactory"
            })
    #endif

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

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

    -- | Set the value of the “@model@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #model 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewModel :: (MonadIO m, IsColumnView o, Gtk.SelectionModel.IsSelectionModel a) => o -> a -> m ()
    setColumnViewModel :: forall (m :: * -> *) o a.
    (MonadIO m, IsColumnView o, IsSelectionModel a) =>
    o -> a -> m ()
    setColumnViewModel 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
    "model" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewModel :: (IsColumnView o, MIO.MonadIO m, Gtk.SelectionModel.IsSelectionModel a) => a -> m (GValueConstruct o)
    constructColumnViewModel :: forall o (m :: * -> *) a.
    (IsColumnView o, MonadIO m, IsSelectionModel a) =>
    a -> m (GValueConstruct o)
    constructColumnViewModel 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
    "model" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    -- | Set the value of the “@model@” 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' #model
    -- @
    clearColumnViewModel :: (MonadIO m, IsColumnView o) => o -> m ()
    clearColumnViewModel :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m ()
    clearColumnViewModel 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 SelectionModel -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "model" (Maybe SelectionModel
    forall a. Maybe a
    Nothing :: Maybe Gtk.SelectionModel.SelectionModel)

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewModelPropertyInfo
    instance AttrInfo ColumnViewModelPropertyInfo where
        type AttrAllowedOps ColumnViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ColumnViewModelPropertyInfo = IsColumnView
        type AttrSetTypeConstraint ColumnViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
        type AttrTransferTypeConstraint ColumnViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
        type AttrTransferType ColumnViewModelPropertyInfo = Gtk.SelectionModel.SelectionModel
        type AttrGetType ColumnViewModelPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
        type AttrLabel ColumnViewModelPropertyInfo = "model"
        type AttrOrigin ColumnViewModelPropertyInfo = ColumnView
        attrGet = getColumnViewModel
        attrSet = setColumnViewModel
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.SelectionModel.SelectionModel v
        attrConstruct = constructColumnViewModel
        attrClear = clearColumnViewModel
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.model"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ColumnView.html#g:attr:model"
            })
    #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' columnView #reorderable
    -- @
    getColumnViewReorderable :: (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewReorderable :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewReorderable 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' columnView [ #reorderable 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewReorderable :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
    setColumnViewReorderable :: forall (m :: * -> *) o.
    (MonadIO m, IsColumnView o) =>
    o -> Bool -> m ()
    setColumnViewReorderable 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`.
    constructColumnViewReorderable :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructColumnViewReorderable :: forall o (m :: * -> *).
    (IsColumnView o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructColumnViewReorderable 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 ColumnViewReorderablePropertyInfo
    instance AttrInfo ColumnViewReorderablePropertyInfo where
        type AttrAllowedOps ColumnViewReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint ColumnViewReorderablePropertyInfo = IsColumnView
        type AttrSetTypeConstraint ColumnViewReorderablePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint ColumnViewReorderablePropertyInfo = (~) Bool
        type AttrTransferType ColumnViewReorderablePropertyInfo = Bool
        type AttrGetType ColumnViewReorderablePropertyInfo = Bool
        type AttrLabel ColumnViewReorderablePropertyInfo = "reorderable"
        type AttrOrigin ColumnViewReorderablePropertyInfo = ColumnView
        attrGet = getColumnViewReorderable
        attrSet = setColumnViewReorderable
        attrPut = setColumnViewReorderable
        attrTransfer _ v = do
            return v
        attrConstruct = constructColumnViewReorderable
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.reorderable"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ColumnView.html#g:attr:reorderable"
            })
    #endif

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

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

    -- | Set the value of the “@row-factory@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #rowFactory 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewRowFactory :: (MonadIO m, IsColumnView o, Gtk.ListItemFactory.IsListItemFactory a) => o -> a -> m ()
    setColumnViewRowFactory :: forall (m :: * -> *) o a.
    (MonadIO m, IsColumnView o, IsListItemFactory a) =>
    o -> a -> m ()
    setColumnViewRowFactory 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
    "row-factory" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@row-factory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewRowFactory :: (IsColumnView o, MIO.MonadIO m, Gtk.ListItemFactory.IsListItemFactory a) => a -> m (GValueConstruct o)
    constructColumnViewRowFactory :: forall o (m :: * -> *) a.
    (IsColumnView o, MonadIO m, IsListItemFactory a) =>
    a -> m (GValueConstruct o)
    constructColumnViewRowFactory 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
    "row-factory" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    -- | Set the value of the “@row-factory@” 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' #rowFactory
    -- @
    clearColumnViewRowFactory :: (MonadIO m, IsColumnView o) => o -> m ()
    clearColumnViewRowFactory :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m ()
    clearColumnViewRowFactory 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 ListItemFactory -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "row-factory" (Maybe ListItemFactory
    forall a. Maybe a
    Nothing :: Maybe Gtk.ListItemFactory.ListItemFactory)

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewRowFactoryPropertyInfo
    instance AttrInfo ColumnViewRowFactoryPropertyInfo where
        type AttrAllowedOps ColumnViewRowFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ColumnViewRowFactoryPropertyInfo = IsColumnView
        type AttrSetTypeConstraint ColumnViewRowFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferTypeConstraint ColumnViewRowFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferType ColumnViewRowFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
        type AttrGetType ColumnViewRowFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
        type AttrLabel ColumnViewRowFactoryPropertyInfo = "row-factory"
        type AttrOrigin ColumnViewRowFactoryPropertyInfo = ColumnView
        attrGet = getColumnViewRowFactory
        attrSet = setColumnViewRowFactory
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
        attrConstruct = constructColumnViewRowFactory
        attrClear = clearColumnViewRowFactory
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.rowFactory"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ColumnView.html#g:attr:rowFactory"
            })
    #endif

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

    -- | Get the value of the “@show-column-separators@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' columnView #showColumnSeparators
    -- @
    getColumnViewShowColumnSeparators :: (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewShowColumnSeparators :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewShowColumnSeparators 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
    "show-column-separators"

    -- | Set the value of the “@show-column-separators@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #showColumnSeparators 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewShowColumnSeparators :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
    setColumnViewShowColumnSeparators :: forall (m :: * -> *) o.
    (MonadIO m, IsColumnView o) =>
    o -> Bool -> m ()
    setColumnViewShowColumnSeparators 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
    "show-column-separators" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@show-column-separators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewShowColumnSeparators :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructColumnViewShowColumnSeparators :: forall o (m :: * -> *).
    (IsColumnView o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructColumnViewShowColumnSeparators 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
    "show-column-separators" Bool
    val

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

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

    -- | Get the value of the “@show-row-separators@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' columnView #showRowSeparators
    -- @
    getColumnViewShowRowSeparators :: (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewShowRowSeparators :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewShowRowSeparators 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
    "show-row-separators"

    -- | Set the value of the “@show-row-separators@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #showRowSeparators 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewShowRowSeparators :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
    setColumnViewShowRowSeparators :: forall (m :: * -> *) o.
    (MonadIO m, IsColumnView o) =>
    o -> Bool -> m ()
    setColumnViewShowRowSeparators 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
    "show-row-separators" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@show-row-separators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewShowRowSeparators :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructColumnViewShowRowSeparators :: forall o (m :: * -> *).
    (IsColumnView o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructColumnViewShowRowSeparators 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
    "show-row-separators" Bool
    val

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

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

    -- | Get the value of the “@single-click-activate@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' columnView #singleClickActivate
    -- @
    getColumnViewSingleClickActivate :: (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewSingleClickActivate :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
    getColumnViewSingleClickActivate 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
    "single-click-activate"

    -- | Set the value of the “@single-click-activate@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #singleClickActivate 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewSingleClickActivate :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
    setColumnViewSingleClickActivate :: forall (m :: * -> *) o.
    (MonadIO m, IsColumnView o) =>
    o -> Bool -> m ()
    setColumnViewSingleClickActivate 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
    "single-click-activate" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@single-click-activate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewSingleClickActivate :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructColumnViewSingleClickActivate :: forall o (m :: * -> *).
    (IsColumnView o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructColumnViewSingleClickActivate 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
    "single-click-activate" Bool
    val

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

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

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

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

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

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

    -- | Set the value of the “@tab-behavior@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' columnView [ #tabBehavior 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setColumnViewTabBehavior :: (MonadIO m, IsColumnView o) => o -> Gtk.Enums.ListTabBehavior -> m ()
    setColumnViewTabBehavior :: forall (m :: * -> *) o.
    (MonadIO m, IsColumnView o) =>
    o -> ListTabBehavior -> m ()
    setColumnViewTabBehavior o
    obj ListTabBehavior
    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 -> ListTabBehavior -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "tab-behavior" ListTabBehavior
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@tab-behavior@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructColumnViewTabBehavior :: (IsColumnView o, MIO.MonadIO m) => Gtk.Enums.ListTabBehavior -> m (GValueConstruct o)
    constructColumnViewTabBehavior :: forall o (m :: * -> *).
    (IsColumnView o, MonadIO m) =>
    ListTabBehavior -> m (GValueConstruct o)
    constructColumnViewTabBehavior ListTabBehavior
    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 -> ListTabBehavior -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "tab-behavior" ListTabBehavior
    val

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewTabBehaviorPropertyInfo
    instance AttrInfo ColumnViewTabBehaviorPropertyInfo where
        type AttrAllowedOps ColumnViewTabBehaviorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint ColumnViewTabBehaviorPropertyInfo = IsColumnView
        type AttrSetTypeConstraint ColumnViewTabBehaviorPropertyInfo = (~) Gtk.Enums.ListTabBehavior
        type AttrTransferTypeConstraint ColumnViewTabBehaviorPropertyInfo = (~) Gtk.Enums.ListTabBehavior
        type AttrTransferType ColumnViewTabBehaviorPropertyInfo = Gtk.Enums.ListTabBehavior
        type AttrGetType ColumnViewTabBehaviorPropertyInfo = Gtk.Enums.ListTabBehavior
        type AttrLabel ColumnViewTabBehaviorPropertyInfo = "tab-behavior"
        type AttrOrigin ColumnViewTabBehaviorPropertyInfo = ColumnView
        attrGet = getColumnViewTabBehavior
        attrSet = setColumnViewTabBehavior
        attrPut = setColumnViewTabBehavior
        attrTransfer _ v = do
            return v
        attrConstruct = constructColumnViewTabBehavior
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.tabBehavior"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ColumnView.html#g:attr:tabBehavior"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList ColumnView
    type instance O.AttributeList ColumnView = ColumnViewAttributeList
    type ColumnViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("columns", ColumnViewColumnsPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("enableRubberband", ColumnViewEnableRubberbandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("headerFactory", ColumnViewHeaderFactoryPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("model", ColumnViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("reorderable", ColumnViewReorderablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("rowFactory", ColumnViewRowFactoryPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showColumnSeparators", ColumnViewShowColumnSeparatorsPropertyInfo), '("showRowSeparators", ColumnViewShowRowSeparatorsPropertyInfo), '("singleClickActivate", ColumnViewSingleClickActivatePropertyInfo), '("sorter", ColumnViewSorterPropertyInfo), '("tabBehavior", ColumnViewTabBehaviorPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    columnViewColumns :: AttrLabelProxy "columns"
    columnViewColumns = AttrLabelProxy

    columnViewEnableRubberband :: AttrLabelProxy "enableRubberband"
    columnViewEnableRubberband = AttrLabelProxy

    columnViewHeaderFactory :: AttrLabelProxy "headerFactory"
    columnViewHeaderFactory = AttrLabelProxy

    columnViewModel :: AttrLabelProxy "model"
    columnViewModel = AttrLabelProxy

    columnViewReorderable :: AttrLabelProxy "reorderable"
    columnViewReorderable = AttrLabelProxy

    columnViewRowFactory :: AttrLabelProxy "rowFactory"
    columnViewRowFactory = AttrLabelProxy

    columnViewShowColumnSeparators :: AttrLabelProxy "showColumnSeparators"
    columnViewShowColumnSeparators = AttrLabelProxy

    columnViewShowRowSeparators :: AttrLabelProxy "showRowSeparators"
    columnViewShowRowSeparators = AttrLabelProxy

    columnViewSingleClickActivate :: AttrLabelProxy "singleClickActivate"
    columnViewSingleClickActivate = AttrLabelProxy

    columnViewSorter :: AttrLabelProxy "sorter"
    columnViewSorter = AttrLabelProxy

    columnViewTabBehavior :: AttrLabelProxy "tabBehavior"
    columnViewTabBehavior = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList ColumnView = ColumnViewSignalList
    type ColumnViewSignalList = ('[ '("activate", ColumnViewActivateSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method ColumnView::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "model"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
    --           , argCType = Just "GtkSelectionModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the list model to use"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "ColumnView" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_column_view_new" gtk_column_view_new ::
        Ptr Gtk.SelectionModel.SelectionModel -> -- model : TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
        IO (Ptr ColumnView)

    -- | Creates a new @GtkColumnView@.
    --
    -- You most likely want to call 'GI.Gtk.Objects.ColumnView.columnViewAppendColumn'
    -- to add columns next.
    columnViewNew ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.SelectionModel.IsSelectionModel a) =>
        Maybe (a)
        -- ^ /@model@/: the list model to use
        -> m ColumnView
        -- ^ __Returns:__ a new @GtkColumnView@
    columnViewNew :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSelectionModel a) =>
    Maybe a -> m ColumnView
    columnViewNew Maybe a
    model = IO ColumnView -> m ColumnView
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ColumnView -> m ColumnView) -> IO ColumnView -> m ColumnView
    forall a b. (a -> b) -> a -> b
    $ do
        maybeModel <- case Maybe a
    model of
            Maybe a
    Nothing -> Ptr SelectionModel -> IO (Ptr SelectionModel)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr SelectionModel
    forall a. Ptr a
    FP.nullPtr
            Just a
    jModel -> do
                jModel' <- a -> IO (Ptr SelectionModel)
    forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
    B.ManagedPtr.disownObject a
    jModel
                return jModel'
        result <- gtk_column_view_new maybeModel
        checkUnexpectedReturnNULL "columnViewNew" result
        result' <- (newObject ColumnView) result
        whenJust model touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method ColumnView::append_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
    --           , argCType = Just "GtkColumnViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a column that hasn't been added to a `GtkColumnView` yet"
    --                 , 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_column_view_append_column" gtk_column_view_append_column ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
        IO ()

    -- | Appends the /@column@/ to the end of the columns in /@self@/.
    columnViewAppendColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
        a
        -- ^ /@self@/: a columnview
        -> b
        -- ^ /@column@/: a column that hasn\'t been added to a @GtkColumnView@ yet
        -> m ()
    columnViewAppendColumn :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
    a -> b -> m ()
    columnViewAppendColumn a
    self b
    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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        column' <- unsafeManagedPtrCastPtr column
        gtk_column_view_append_column self' column'
        touchManagedPtr self
        touchManagedPtr column
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewAppendColumnMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewAppendColumnMethodInfo a signature where
        overloadedMethod = columnViewAppendColumn

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

    #endif

    -- method ColumnView::get_columns
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_column_view_get_columns" gtk_column_view_get_columns ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO (Ptr Gio.ListModel.ListModel)

    -- | Gets the list of columns in this column view.
    --
    -- This list is constant over the lifetime of /@self@/ and can be used to
    -- monitor changes to the columns of /@self@/ by connecting to the
    -- [ListModel::itemsChanged]("GI.Gio.Interfaces.ListModel#g:signal:itemsChanged") signal.
    columnViewGetColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Gio.ListModel.ListModel
        -- ^ __Returns:__ The list managing the columns
    columnViewGetColumns :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m ListModel
    columnViewGetColumns a
    self = IO ListModel -> m ListModel
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_columns self'
        checkUnexpectedReturnNULL "columnViewGetColumns" result
        result' <- (newObject Gio.ListModel.ListModel) result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetColumnsMethodInfo
    instance (signature ~ (m Gio.ListModel.ListModel), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetColumnsMethodInfo a signature where
        overloadedMethod = columnViewGetColumns

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

    #endif

    -- method ColumnView::get_enable_rubberband
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , 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_column_view_get_enable_rubberband" gtk_column_view_get_enable_rubberband ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO CInt

    -- | Returns whether rows can be selected by dragging with the mouse.
    columnViewGetEnableRubberband ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Bool
        -- ^ __Returns:__ true if rubberband selection is enabled
    columnViewGetEnableRubberband :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m Bool
    columnViewGetEnableRubberband a
    self = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_enable_rubberband self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetEnableRubberbandMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetEnableRubberbandMethodInfo a signature where
        overloadedMethod = columnViewGetEnableRubberband

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

    #endif

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

    foreign import ccall "gtk_column_view_get_header_factory" gtk_column_view_get_header_factory ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO (Ptr Gtk.ListItemFactory.ListItemFactory)

    -- | Gets the factory that\'s currently used to populate section headers.
    --
    -- /Since: 4.12/
    columnViewGetHeaderFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m (Maybe Gtk.ListItemFactory.ListItemFactory)
        -- ^ __Returns:__ The factory in use
    columnViewGetHeaderFactory :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m (Maybe ListItemFactory)
    columnViewGetHeaderFactory a
    self = IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory))
    -> IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_header_factory self'
        maybeResult <- convertIfNonNull result $ \Ptr ListItemFactory
    result' -> do
            result'' <- ((ManagedPtr ListItemFactory -> ListItemFactory)
    -> Ptr ListItemFactory -> IO ListItemFactory
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr ListItemFactory -> ListItemFactory
    Gtk.ListItemFactory.ListItemFactory) Ptr ListItemFactory
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetHeaderFactoryMethodInfo
    instance (signature ~ (m (Maybe Gtk.ListItemFactory.ListItemFactory)), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetHeaderFactoryMethodInfo a signature where
        overloadedMethod = columnViewGetHeaderFactory

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

    #endif

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

    foreign import ccall "gtk_column_view_get_model" gtk_column_view_get_model ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO (Ptr Gtk.SelectionModel.SelectionModel)

    -- | Gets the model that\'s currently used to read the items displayed.
    columnViewGetModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m (Maybe Gtk.SelectionModel.SelectionModel)
        -- ^ __Returns:__ The model in use
    columnViewGetModel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m (Maybe SelectionModel)
    columnViewGetModel a
    self = IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe SelectionModel) -> m (Maybe SelectionModel))
    -> IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_model self'
        maybeResult <- convertIfNonNull result $ \Ptr SelectionModel
    result' -> do
            result'' <- ((ManagedPtr SelectionModel -> SelectionModel)
    -> Ptr SelectionModel -> IO SelectionModel
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr SelectionModel -> SelectionModel
    Gtk.SelectionModel.SelectionModel) Ptr SelectionModel
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetModelMethodInfo
    instance (signature ~ (m (Maybe Gtk.SelectionModel.SelectionModel)), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetModelMethodInfo a signature where
        overloadedMethod = columnViewGetModel

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

    #endif

    -- method ColumnView::get_reorderable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , 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_column_view_get_reorderable" gtk_column_view_get_reorderable ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO CInt

    -- | Returns whether columns are reorderable.
    columnViewGetReorderable ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Bool
        -- ^ __Returns:__ true if columns are reorderable
    columnViewGetReorderable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m Bool
    columnViewGetReorderable a
    self = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_reorderable self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetReorderableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetReorderableMethodInfo a signature where
        overloadedMethod = columnViewGetReorderable

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

    #endif

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

    foreign import ccall "gtk_column_view_get_row_factory" gtk_column_view_get_row_factory ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO (Ptr Gtk.ListItemFactory.ListItemFactory)

    -- | Gets the factory set via 'GI.Gtk.Objects.ColumnView.columnViewSetRowFactory'.
    --
    -- /Since: 4.12/
    columnViewGetRowFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m (Maybe Gtk.ListItemFactory.ListItemFactory)
        -- ^ __Returns:__ The factory
    columnViewGetRowFactory :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m (Maybe ListItemFactory)
    columnViewGetRowFactory a
    self = IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory))
    -> IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_row_factory self'
        maybeResult <- convertIfNonNull result $ \Ptr ListItemFactory
    result' -> do
            result'' <- ((ManagedPtr ListItemFactory -> ListItemFactory)
    -> Ptr ListItemFactory -> IO ListItemFactory
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr ListItemFactory -> ListItemFactory
    Gtk.ListItemFactory.ListItemFactory) Ptr ListItemFactory
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetRowFactoryMethodInfo
    instance (signature ~ (m (Maybe Gtk.ListItemFactory.ListItemFactory)), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetRowFactoryMethodInfo a signature where
        overloadedMethod = columnViewGetRowFactory

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

    #endif

    -- method ColumnView::get_show_column_separators
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , 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_column_view_get_show_column_separators" gtk_column_view_get_show_column_separators ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO CInt

    -- | Returns whether the list should show separators between columns.
    columnViewGetShowColumnSeparators ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Bool
        -- ^ __Returns:__ true if the list shows column separators
    columnViewGetShowColumnSeparators :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m Bool
    columnViewGetShowColumnSeparators a
    self = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_show_column_separators self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetShowColumnSeparatorsMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetShowColumnSeparatorsMethodInfo a signature where
        overloadedMethod = columnViewGetShowColumnSeparators

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

    #endif

    -- method ColumnView::get_show_row_separators
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , 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_column_view_get_show_row_separators" gtk_column_view_get_show_row_separators ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO CInt

    -- | Returns whether the list should show separators between rows.
    columnViewGetShowRowSeparators ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Bool
        -- ^ __Returns:__ true if the list shows separators
    columnViewGetShowRowSeparators :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m Bool
    columnViewGetShowRowSeparators a
    self = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_show_row_separators self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetShowRowSeparatorsMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetShowRowSeparatorsMethodInfo a signature where
        overloadedMethod = columnViewGetShowRowSeparators

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

    #endif

    -- method ColumnView::get_single_click_activate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , 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_column_view_get_single_click_activate" gtk_column_view_get_single_click_activate ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO CInt

    -- | Returns whether rows will be activated on single click and
    -- selected on hover.
    columnViewGetSingleClickActivate ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Bool
        -- ^ __Returns:__ true if rows are activated on single click
    columnViewGetSingleClickActivate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m Bool
    columnViewGetSingleClickActivate a
    self = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_single_click_activate self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetSingleClickActivateMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetSingleClickActivateMethodInfo a signature where
        overloadedMethod = columnViewGetSingleClickActivate

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

    #endif

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

    foreign import ccall "gtk_column_view_get_sorter" gtk_column_view_get_sorter ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO (Ptr Gtk.Sorter.Sorter)

    -- | Returns a special sorter that reflects the users sorting
    -- choices in the column view.
    --
    -- To allow users to customizable sorting by clicking on column
    -- headers, this sorter needs to be set on the sort model underneath
    -- the model that is displayed by the view.
    --
    -- See 'GI.Gtk.Objects.ColumnViewColumn.columnViewColumnSetSorter' for setting up
    -- per-column sorting.
    --
    -- Here is an example:
    --
    -- === /c code/
    -- >gtk_column_view_column_set_sorter (column, sorter);
    -- >gtk_column_view_append_column (view, column);
    -- >sorter = g_object_ref (gtk_column_view_get_sorter (view)));
    -- >model = gtk_sort_list_model_new (store, sorter);
    -- >selection = gtk_no_selection_new (model);
    -- >gtk_column_view_set_model (view, selection);
    columnViewGetSorter ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m (Maybe Gtk.Sorter.Sorter)
        -- ^ __Returns:__ the @GtkSorter@ of /@self@/
    columnViewGetSorter :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m (Maybe Sorter)
    columnViewGetSorter a
    self = IO (Maybe Sorter) -> m (Maybe Sorter)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Sorter) -> m (Maybe Sorter))
    -> IO (Maybe Sorter) -> m (Maybe Sorter)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_sorter self'
        maybeResult <- convertIfNonNull result $ \Ptr Sorter
    result' -> do
            result'' <- ((ManagedPtr Sorter -> Sorter) -> Ptr Sorter -> IO Sorter
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Sorter -> Sorter
    Gtk.Sorter.Sorter) Ptr Sorter
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetSorterMethodInfo
    instance (signature ~ (m (Maybe Gtk.Sorter.Sorter)), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetSorterMethodInfo a signature where
        overloadedMethod = columnViewGetSorter

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

    #endif

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

    foreign import ccall "gtk_column_view_get_tab_behavior" gtk_column_view_get_tab_behavior ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        IO CUInt

    -- | Gets the behavior set for the \<kbd>Tab\<\/kbd> key.
    --
    -- /Since: 4.12/
    columnViewGetTabBehavior ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> m Gtk.Enums.ListTabBehavior
        -- ^ __Returns:__ The behavior of the \<kbd>Tab\<\/kbd> key
    columnViewGetTabBehavior :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> m ListTabBehavior
    columnViewGetTabBehavior a
    self = IO ListTabBehavior -> m ListTabBehavior
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ListTabBehavior -> m ListTabBehavior)
    -> IO ListTabBehavior -> m ListTabBehavior
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_column_view_get_tab_behavior self'
        let result' = (Int -> ListTabBehavior
    forall a. Enum a => Int -> a
    toEnum (Int -> ListTabBehavior)
    -> (CUInt -> Int) -> CUInt -> ListTabBehavior
    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 self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewGetTabBehaviorMethodInfo
    instance (signature ~ (m Gtk.Enums.ListTabBehavior), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetTabBehaviorMethodInfo a signature where
        overloadedMethod = columnViewGetTabBehavior

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

    #endif

    -- method ColumnView::insert_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "position"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the position to insert @column at"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
    --           , argCType = Just "GtkColumnViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the column to insert"
    --                 , 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_column_view_insert_column" gtk_column_view_insert_column ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Word32 ->                               -- position : TBasicType TUInt
        Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
        IO ()

    -- | Inserts a column at the given position in the columns of /@self@/.
    --
    -- If /@column@/ is already a column of /@self@/, it will be repositioned.
    columnViewInsertColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
        a
        -- ^ /@self@/: a columnview
        -> Word32
        -- ^ /@position@/: the position to insert /@column@/ at
        -> b
        -- ^ /@column@/: the column to insert
        -> m ()
    columnViewInsertColumn :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
    a -> Word32 -> b -> m ()
    columnViewInsertColumn a
    self Word32
    position b
    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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        column' <- unsafeManagedPtrCastPtr column
        gtk_column_view_insert_column self' position column'
        touchManagedPtr self
        touchManagedPtr column
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewInsertColumnMethodInfo
    instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewInsertColumnMethodInfo a signature where
        overloadedMethod = columnViewInsertColumn

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

    #endif

    -- method ColumnView::remove_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
    --           , argCType = Just "GtkColumnViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a column that's part of @self"
    --                 , 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_column_view_remove_column" gtk_column_view_remove_column ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
        IO ()

    -- | Removes the /@column@/ from the list of columns of /@self@/.
    columnViewRemoveColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
        a
        -- ^ /@self@/: a columnview
        -> b
        -- ^ /@column@/: a column that\'s part of /@self@/
        -> m ()
    columnViewRemoveColumn :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
    a -> b -> m ()
    columnViewRemoveColumn a
    self b
    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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        column' <- unsafeManagedPtrCastPtr column
        gtk_column_view_remove_column self' column'
        touchManagedPtr self
        touchManagedPtr column
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewRemoveColumnMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewRemoveColumnMethodInfo a signature where
        overloadedMethod = columnViewRemoveColumn

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

    #endif

    -- method ColumnView::scroll_to
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pos"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "position of the item. Must be less than the number of\n  items in the view."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
    --           , argCType = Just "GtkColumnViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The column to scroll to\n  or `NULL` to not scroll columns"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListScrollFlags" }
    --           , argCType = Just "GtkListScrollFlags"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "actions to perform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "scroll"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ScrollInfo" }
    --           , argCType = Just "GtkScrollInfo*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "details of how to perform\n  the scroll operation or %NULL to scroll into view"
    --                 , 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_column_view_scroll_to" gtk_column_view_scroll_to ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Word32 ->                               -- pos : TBasicType TUInt
        Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "ListScrollFlags"})
        Ptr Gtk.ScrollInfo.ScrollInfo ->        -- scroll : TInterface (Name {namespace = "Gtk", name = "ScrollInfo"})
        IO ()

    -- | Scroll to the row at the given position - or cell if a column is
    -- given - and performs the actions specified in /@flags@/.
    --
    -- This function works no matter if the columnview is shown or focused.
    -- If it isn\'t, then the changes will take effect once that happens.
    --
    -- /Since: 4.12/
    columnViewScrollTo ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
        a
        -- ^ /@self@/: The columnview
        -> Word32
        -- ^ /@pos@/: position of the item. Must be less than the number of
        --   items in the view.
        -> Maybe (b)
        -- ^ /@column@/: The column to scroll to
        --   or @NULL@ to not scroll columns
        -> [Gtk.Flags.ListScrollFlags]
        -- ^ /@flags@/: actions to perform
        -> Maybe (Gtk.ScrollInfo.ScrollInfo)
        -- ^ /@scroll@/: details of how to perform
        --   the scroll operation or 'P.Nothing' to scroll into view
        -> m ()
    columnViewScrollTo :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
    a
    -> Word32
    -> Maybe b
    -> [ListScrollFlags]
    -> Maybe ScrollInfo
    -> m ()
    columnViewScrollTo a
    self Word32
    pos Maybe b
    column [ListScrollFlags]
    flags Maybe ScrollInfo
    scroll = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeColumn <- case column of
            Maybe b
    Nothing -> Ptr ColumnViewColumn -> IO (Ptr ColumnViewColumn)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ColumnViewColumn
    forall a. Ptr a
    FP.nullPtr
            Just b
    jColumn -> do
                jColumn' <- b -> IO (Ptr ColumnViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jColumn
                return jColumn'
        let flags' = [ListScrollFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [ListScrollFlags]
    flags
        maybeScroll <- case scroll of
            Maybe ScrollInfo
    Nothing -> Ptr ScrollInfo -> IO (Ptr ScrollInfo)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ScrollInfo
    forall a. Ptr a
    FP.nullPtr
            Just ScrollInfo
    jScroll -> do
                jScroll' <- ScrollInfo -> IO (Ptr ScrollInfo)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed ScrollInfo
    jScroll
                return jScroll'
        gtk_column_view_scroll_to self' pos maybeColumn flags' maybeScroll
        touchManagedPtr self
        whenJust column touchManagedPtr
        whenJust scroll touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewScrollToMethodInfo
    instance (signature ~ (Word32 -> Maybe (b) -> [Gtk.Flags.ListScrollFlags] -> Maybe (Gtk.ScrollInfo.ScrollInfo) -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewScrollToMethodInfo a signature where
        overloadedMethod = columnViewScrollTo

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

    #endif

    -- method ColumnView::set_enable_rubberband
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "enable_rubberband"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to enable rubberband selection"
    --                 , 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_column_view_set_enable_rubberband" gtk_column_view_set_enable_rubberband ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        CInt ->                                 -- enable_rubberband : TBasicType TBoolean
        IO ()

    -- | Sets whether selections can be changed by dragging with the mouse.
    columnViewSetEnableRubberband ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> Bool
        -- ^ /@enableRubberband@/: whether to enable rubberband selection
        -> m ()
    columnViewSetEnableRubberband :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> Bool -> m ()
    columnViewSetEnableRubberband a
    self Bool
    enableRubberband = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let enableRubberband' = (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
    enableRubberband
        gtk_column_view_set_enable_rubberband self' enableRubberband'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetEnableRubberbandMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetEnableRubberbandMethodInfo a signature where
        overloadedMethod = columnViewSetEnableRubberband

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

    #endif

    -- method ColumnView::set_header_factory
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factory"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
    --           , argCType = Just "GtkListItemFactory*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the factory to use" , 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_column_view_set_header_factory" gtk_column_view_set_header_factory ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
        IO ()

    -- | Sets the factory to use for populating the
    -- t'GI.Gtk.Objects.ListHeader.ListHeader' objects used in section headers.
    --
    -- If this factory is set to @NULL@, the list will not show
    -- section headers.
    --
    -- /Since: 4.12/
    columnViewSetHeaderFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ListItemFactory.IsListItemFactory b) =>
        a
        -- ^ /@self@/: a columnview
        -> Maybe (b)
        -- ^ /@factory@/: the factory to use
        -> m ()
    columnViewSetHeaderFactory :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsListItemFactory b) =>
    a -> Maybe b -> m ()
    columnViewSetHeaderFactory a
    self Maybe b
    factory = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeFactory <- case factory of
            Maybe b
    Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ListItemFactory
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFactory -> do
                jFactory' <- b -> IO (Ptr ListItemFactory)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jFactory
                return jFactory'
        gtk_column_view_set_header_factory self' maybeFactory
        touchManagedPtr self
        whenJust factory touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetHeaderFactoryMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsColumnView a, Gtk.ListItemFactory.IsListItemFactory b) => O.OverloadedMethod ColumnViewSetHeaderFactoryMethodInfo a signature where
        overloadedMethod = columnViewSetHeaderFactory

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

    #endif

    -- method ColumnView::set_model
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "model"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
    --           , argCType = Just "GtkSelectionModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the model to use" , 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_column_view_set_model" gtk_column_view_set_model ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Ptr Gtk.SelectionModel.SelectionModel -> -- model : TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
        IO ()

    -- | Sets the model to use.
    --
    -- This must be a t'GI.Gtk.Interfaces.SelectionModel.SelectionModel'.
    columnViewSetModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.SelectionModel.IsSelectionModel b) =>
        a
        -- ^ /@self@/: a columnview
        -> Maybe (b)
        -- ^ /@model@/: the model to use
        -> m ()
    columnViewSetModel :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsSelectionModel b) =>
    a -> Maybe b -> m ()
    columnViewSetModel a
    self Maybe b
    model = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeModel <- case model of
            Maybe b
    Nothing -> Ptr SelectionModel -> IO (Ptr SelectionModel)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr SelectionModel
    forall a. Ptr a
    FP.nullPtr
            Just b
    jModel -> do
                jModel' <- b -> IO (Ptr SelectionModel)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jModel
                return jModel'
        gtk_column_view_set_model self' maybeModel
        touchManagedPtr self
        whenJust model touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetModelMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsColumnView a, Gtk.SelectionModel.IsSelectionModel b) => O.OverloadedMethod ColumnViewSetModelMethodInfo a signature where
        overloadedMethod = columnViewSetModel

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

    #endif

    -- method ColumnView::set_reorderable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , 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 "whether columns should be reorderable"
    --                 , 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_column_view_set_reorderable" gtk_column_view_set_reorderable ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        CInt ->                                 -- reorderable : TBasicType TBoolean
        IO ()

    -- | Sets whether columns should be reorderable by dragging.
    columnViewSetReorderable ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> Bool
        -- ^ /@reorderable@/: whether columns should be reorderable
        -> m ()
    columnViewSetReorderable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> Bool -> m ()
    columnViewSetReorderable a
    self 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        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_column_view_set_reorderable self' reorderable'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetReorderableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetReorderableMethodInfo a signature where
        overloadedMethod = columnViewSetReorderable

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

    #endif

    -- method ColumnView::set_row_factory
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factory"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
    --           , argCType = Just "GtkListItemFactory*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The row factory" , 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_column_view_set_row_factory" gtk_column_view_set_row_factory ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
        IO ()

    -- | Sets the factory used for configuring rows.
    --
    -- The factory must be for configuring t'GI.Gtk.Objects.ColumnViewRow.ColumnViewRow' objects.
    --
    -- If this factory is not set - which is the default - then the defaults
    -- will be used.
    --
    -- This factory is not used to set the widgets displayed in the individual
    -- cells. For that see [method/@gtkColumnViewColumn@/.set_factory] and
    -- [class/@gtkColumnViewCell@/].
    --
    -- /Since: 4.12/
    columnViewSetRowFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ListItemFactory.IsListItemFactory b) =>
        a
        -- ^ /@self@/: a columnview
        -> Maybe (b)
        -- ^ /@factory@/: The row factory
        -> m ()
    columnViewSetRowFactory :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsListItemFactory b) =>
    a -> Maybe b -> m ()
    columnViewSetRowFactory a
    self Maybe b
    factory = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeFactory <- case factory of
            Maybe b
    Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ListItemFactory
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFactory -> do
                jFactory' <- b -> IO (Ptr ListItemFactory)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jFactory
                return jFactory'
        gtk_column_view_set_row_factory self' maybeFactory
        touchManagedPtr self
        whenJust factory touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetRowFactoryMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsColumnView a, Gtk.ListItemFactory.IsListItemFactory b) => O.OverloadedMethod ColumnViewSetRowFactoryMethodInfo a signature where
        overloadedMethod = columnViewSetRowFactory

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

    #endif

    -- method ColumnView::set_show_column_separators
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "show_column_separators"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to show column separators"
    --                 , 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_column_view_set_show_column_separators" gtk_column_view_set_show_column_separators ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        CInt ->                                 -- show_column_separators : TBasicType TBoolean
        IO ()

    -- | Sets whether the list should show separators between columns.
    columnViewSetShowColumnSeparators ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> Bool
        -- ^ /@showColumnSeparators@/: whether to show column separators
        -> m ()
    columnViewSetShowColumnSeparators :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> Bool -> m ()
    columnViewSetShowColumnSeparators a
    self Bool
    showColumnSeparators = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let showColumnSeparators' = (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
    showColumnSeparators
        gtk_column_view_set_show_column_separators self' showColumnSeparators'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetShowColumnSeparatorsMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetShowColumnSeparatorsMethodInfo a signature where
        overloadedMethod = columnViewSetShowColumnSeparators

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

    #endif

    -- method ColumnView::set_show_row_separators
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "show_row_separators"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to show row separators"
    --                 , 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_column_view_set_show_row_separators" gtk_column_view_set_show_row_separators ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        CInt ->                                 -- show_row_separators : TBasicType TBoolean
        IO ()

    -- | Sets whether the list should show separators between rows.
    columnViewSetShowRowSeparators ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> Bool
        -- ^ /@showRowSeparators@/: whether to show row separators
        -> m ()
    columnViewSetShowRowSeparators :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> Bool -> m ()
    columnViewSetShowRowSeparators a
    self Bool
    showRowSeparators = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let showRowSeparators' = (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
    showRowSeparators
        gtk_column_view_set_show_row_separators self' showRowSeparators'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetShowRowSeparatorsMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetShowRowSeparatorsMethodInfo a signature where
        overloadedMethod = columnViewSetShowRowSeparators

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

    #endif

    -- method ColumnView::set_single_click_activate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "single_click_activate"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to activate items on single click"
    --                 , 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_column_view_set_single_click_activate" gtk_column_view_set_single_click_activate ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        CInt ->                                 -- single_click_activate : TBasicType TBoolean
        IO ()

    -- | Sets whether rows should be activated on single click and
    -- selected on hover.
    columnViewSetSingleClickActivate ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> Bool
        -- ^ /@singleClickActivate@/: whether to activate items on single click
        -> m ()
    columnViewSetSingleClickActivate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> Bool -> m ()
    columnViewSetSingleClickActivate a
    self Bool
    singleClickActivate = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let singleClickActivate' = (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
    singleClickActivate
        gtk_column_view_set_single_click_activate self' singleClickActivate'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetSingleClickActivateMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetSingleClickActivateMethodInfo a signature where
        overloadedMethod = columnViewSetSingleClickActivate

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

    #endif

    -- method ColumnView::set_tab_behavior
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "tab_behavior"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListTabBehavior" }
    --           , argCType = Just "GtkListTabBehavior"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The desired tab behavior"
    --                 , 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_column_view_set_tab_behavior" gtk_column_view_set_tab_behavior ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        CUInt ->                                -- tab_behavior : TInterface (Name {namespace = "Gtk", name = "ListTabBehavior"})
        IO ()

    -- | Sets the \<kbd>Tab\<\/kbd> key behavior.
    --
    -- This influences how the \<kbd>Tab\<\/kbd> and
    -- \<kbd>Shift\<\/kbd>+\<kbd>Tab\<\/kbd> keys move the
    -- focus in the columnview.
    --
    -- /Since: 4.12/
    columnViewSetTabBehavior ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
        a
        -- ^ /@self@/: a columnview
        -> Gtk.Enums.ListTabBehavior
        -- ^ /@tabBehavior@/: The desired tab behavior
        -> m ()
    columnViewSetTabBehavior :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsColumnView a) =>
    a -> ListTabBehavior -> m ()
    columnViewSetTabBehavior a
    self ListTabBehavior
    tabBehavior = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let tabBehavior' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (ListTabBehavior -> Int) -> ListTabBehavior -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ListTabBehavior -> Int
    forall a. Enum a => a -> Int
    fromEnum) ListTabBehavior
    tabBehavior
        gtk_column_view_set_tab_behavior self' tabBehavior'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSetTabBehaviorMethodInfo
    instance (signature ~ (Gtk.Enums.ListTabBehavior -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetTabBehaviorMethodInfo a signature where
        overloadedMethod = columnViewSetTabBehavior

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

    #endif

    -- method ColumnView::sort_by_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
    --           , argCType = Just "GtkColumnView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a columnview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
    --           , argCType = Just "GtkColumnViewColumn*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the column to sort by"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "direction"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SortType" }
    --           , argCType = Just "GtkSortType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the direction to sort in"
    --                 , 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_column_view_sort_by_column" gtk_column_view_sort_by_column ::
        Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
        Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
        CUInt ->                                -- direction : TInterface (Name {namespace = "Gtk", name = "SortType"})
        IO ()

    -- | Sets the sorting of the view.
    --
    -- This function should be used to set up the initial sorting.
    -- At runtime, users can change the sorting of a column view
    -- by clicking on the list headers.
    --
    -- This call only has an effect if the sorter returned by
    -- 'GI.Gtk.Objects.ColumnView.columnViewGetSorter' is set on a sort model,
    -- and 'GI.Gtk.Objects.ColumnViewColumn.columnViewColumnSetSorter' has been called
    -- on /@column@/ to associate a sorter with the column.
    --
    -- If /@column@/ is unset, the view will be unsorted.
    columnViewSortByColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
        a
        -- ^ /@self@/: a columnview
        -> Maybe (b)
        -- ^ /@column@/: the column to sort by
        -> Gtk.Enums.SortType
        -- ^ /@direction@/: the direction to sort in
        -> m ()
    columnViewSortByColumn :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
    a -> Maybe b -> SortType -> m ()
    columnViewSortByColumn a
    self Maybe b
    column SortType
    direction = 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
        self' <- a -> IO (Ptr ColumnView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeColumn <- case column of
            Maybe b
    Nothing -> Ptr ColumnViewColumn -> IO (Ptr ColumnViewColumn)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ColumnViewColumn
    forall a. Ptr a
    FP.nullPtr
            Just b
    jColumn -> do
                jColumn' <- b -> IO (Ptr ColumnViewColumn)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jColumn
                return jColumn'
        let direction' = (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
    direction
        gtk_column_view_sort_by_column self' maybeColumn direction'
        touchManagedPtr self
        whenJust column touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ColumnViewSortByColumnMethodInfo
    instance (signature ~ (Maybe (b) -> Gtk.Enums.SortType -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewSortByColumnMethodInfo a signature where
        overloadedMethod = columnViewSortByColumn

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

    #endif