    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Provides an expander for a tree-like list.
    --
    -- It is typically placed as a bottommost child into a @GtkListView@
    -- to allow users to expand and collapse children in a list with a
    -- t'GI.Gtk.Objects.TreeListModel.TreeListModel'. @GtkTreeExpander@ provides the common UI
    -- elements, gestures and keybindings for this purpose.
    --
    -- On top of this, the \"listitem.expand\", \"listitem.collapse\" and
    -- \"listitem.toggle-expand\" actions are provided to allow adding custom
    -- UI for managing expanded state.
    --
    -- It is important to mention that you want to set the
    -- [ListItem:focusable]("GI.Gtk.Objects.ListItem#g:attr:focusable") property to FALSE when using this
    -- widget, as you want the keyboard focus to be in the treexpander, and not
    -- inside the list to make use of the keybindings.
    --
    -- The @GtkTreeListModel@ must be set to not be passthrough. Then it
    -- will provide t'GI.Gtk.Objects.TreeListRow.TreeListRow' items which can be set via
    -- 'GI.Gtk.Objects.TreeExpander.treeExpanderSetListRow' on the expander.
    -- The expander will then watch that row item automatically.
    -- 'GI.Gtk.Objects.TreeExpander.treeExpanderSetChild' sets the widget that displays
    -- the actual row contents.
    --
    -- @GtkTreeExpander@ can be modified with properties such as
    -- [TreeExpander:indentForIcon]("GI.Gtk.Objects.TreeExpander#g:attr:indentForIcon"),
    -- [TreeExpander:indentForDepth]("GI.Gtk.Objects.TreeExpander#g:attr:indentForDepth"), and
    -- [TreeExpander:hideExpander]("GI.Gtk.Objects.TreeExpander#g:attr:hideExpander") to achieve a different appearance.
    -- This can even be done to influence individual rows, for example by binding
    -- the [TreeExpander:hideExpander]("GI.Gtk.Objects.TreeExpander#g:attr:hideExpander") property to the item count of
    -- the model of the treelistrow, to hide the expander for rows without children,
    -- even if the row is expandable.
    --
    -- == Shortcuts and Gestures
    --
    -- @GtkTreeExpander@ supports the following keyboard shortcuts:
    --
    -- * \<kbd>+\<\/kbd> or \<kbd>*\<\/kbd> expands the expander.
    -- * \<kbd>-\<\/kbd> or \<kbd>\/\<\/kbd> collapses the expander.
    -- * Left and right arrow keys, when combined with \<kbd>Shift\<\/kbd> or
    --   \<kbd>Ctrl\<\/kbd>+\<kbd>Shift\<\/kbd>, will expand or collapse, depending on
    --   the locale\'s text direction.
    -- * \<kbd>Ctrl\<\/kbd>+\<kbd>␣\<\/kbd> toggles the expander state.
    --
    --
    -- The row can also expand on drag gestures.
    --
    -- == Actions
    --
    -- @GtkTreeExpander@ defines a set of built-in actions:
    --
    -- * @listitem.expand@ expands the expander if it can be expanded.
    -- * @listitem.collapse@ collapses the expander.
    -- * @listitem.toggle-expand@ tries to expand the expander if it was collapsed
    --   or collapses it if it was expanded.
    --
    --
    -- == CSS nodes
    --
    --
    --
    -- >treeexpander
    -- >├── [indent]*
    -- >├── [expander]
    -- >╰── <child>
    --
    --
    -- @GtkTreeExpander@ has zero or one CSS nodes with the name \"expander\" that
    -- should display the expander icon. The node will be @:checked@ when it
    -- is expanded. If the node is not expandable, an \"indent\" node will be
    -- displayed instead.
    --
    -- For every level of depth, another \"indent\" node is prepended.
    --
    -- == Accessibility
    --
    -- Until GTK 4.10, @GtkTreeExpander@ used the 'GI.Gtk.Enums.AccessibleRoleGroup' role.
    --
    -- Since GTK 4.12, @GtkTreeExpander@ uses the 'GI.Gtk.Enums.AccessibleRoleButton' role.
    -- Toggling it will change the @GTK_ACCESSIBLE_STATE_EXPANDED@ state.

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

    module GI.Gtk.Objects.TreeExpander
        (

    -- * Exported types
        TreeExpander(..)                        ,
        IsTreeExpander                          ,
        toTreeExpander                          ,

     -- * 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"), [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"), [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"), [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"), [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"), [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"), [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"), [getChild]("GI.Gtk.Objects.TreeExpander#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [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"), [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"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHideExpander]("GI.Gtk.Objects.TreeExpander#g:method:getHideExpander"), [getIndentForDepth]("GI.Gtk.Objects.TreeExpander#g:method:getIndentForDepth"), [getIndentForIcon]("GI.Gtk.Objects.TreeExpander#g:method:getIndentForIcon"), [getItem]("GI.Gtk.Objects.TreeExpander#g:method:getItem"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getListRow]("GI.Gtk.Objects.TreeExpander#g:method:getListRow"), [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"), [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"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [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"), [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"), [setChild]("GI.Gtk.Objects.TreeExpander#g:method:setChild"), [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"), [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"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHideExpander]("GI.Gtk.Objects.TreeExpander#g:method:setHideExpander"), [setIndentForDepth]("GI.Gtk.Objects.TreeExpander#g:method:setIndentForDepth"), [setIndentForIcon]("GI.Gtk.Objects.TreeExpander#g:method:setIndentForIcon"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setListRow]("GI.Gtk.Objects.TreeExpander#g:method:setListRow"), [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"), [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"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [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").

    #if defined(ENABLE_OVERLOADING)
        ResolveTreeExpanderMethod               ,
    #endif

    -- ** getChild #method:getChild#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderGetChildMethodInfo          ,
    #endif
        treeExpanderGetChild                    ,

    -- ** getHideExpander #method:getHideExpander#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderGetHideExpanderMethodInfo   ,
    #endif
        treeExpanderGetHideExpander             ,

    -- ** getIndentForDepth #method:getIndentForDepth#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderGetIndentForDepthMethodInfo ,
    #endif
        treeExpanderGetIndentForDepth           ,

    -- ** getIndentForIcon #method:getIndentForIcon#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderGetIndentForIconMethodInfo  ,
    #endif
        treeExpanderGetIndentForIcon            ,

    -- ** getItem #method:getItem#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderGetItemMethodInfo           ,
    #endif
        treeExpanderGetItem                     ,

    -- ** getListRow #method:getListRow#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderGetListRowMethodInfo        ,
    #endif
        treeExpanderGetListRow                  ,

    -- ** new #method:new#

        treeExpanderNew                         ,

    -- ** setChild #method:setChild#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderSetChildMethodInfo          ,
    #endif
        treeExpanderSetChild                    ,

    -- ** setHideExpander #method:setHideExpander#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderSetHideExpanderMethodInfo   ,
    #endif
        treeExpanderSetHideExpander             ,

    -- ** setIndentForDepth #method:setIndentForDepth#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderSetIndentForDepthMethodInfo ,
    #endif
        treeExpanderSetIndentForDepth           ,

    -- ** setIndentForIcon #method:setIndentForIcon#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderSetIndentForIconMethodInfo  ,
    #endif
        treeExpanderSetIndentForIcon            ,

    -- ** setListRow #method:setListRow#

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderSetListRowMethodInfo        ,
    #endif
        treeExpanderSetListRow                  ,

     -- * Properties

    -- ** child #attr:child#
    -- | The child widget with the actual contents.

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderChildPropertyInfo           ,
    #endif
        clearTreeExpanderChild                  ,
        constructTreeExpanderChild              ,
        getTreeExpanderChild                    ,
        setTreeExpanderChild                    ,
    #if defined(ENABLE_OVERLOADING)
        treeExpanderChild                       ,
    #endif

    -- ** hideExpander #attr:hideExpander#
    -- | Whether the expander icon should be hidden in a GtkTreeListRow.
    -- Note that this property simply hides the icon.  The actions and keybinding
    -- (i.e. collapse and expand) are not affected by this property.
    --
    -- A common use for this property would be to bind to the number of children in a
    -- GtkTreeListRow\'s model in order to hide the expander when a row has no children.
    --
    -- /Since: 4.10/

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderHideExpanderPropertyInfo    ,
    #endif
        constructTreeExpanderHideExpander       ,
        getTreeExpanderHideExpander             ,
        setTreeExpanderHideExpander             ,
    #if defined(ENABLE_OVERLOADING)
        treeExpanderHideExpander                ,
    #endif

    -- ** indentForDepth #attr:indentForDepth#
    -- | TreeExpander indents the child according to its depth.
    --
    -- /Since: 4.10/

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderIndentForDepthPropertyInfo  ,
    #endif
        constructTreeExpanderIndentForDepth     ,
        getTreeExpanderIndentForDepth           ,
        setTreeExpanderIndentForDepth           ,
    #if defined(ENABLE_OVERLOADING)
        treeExpanderIndentForDepth              ,
    #endif

    -- ** indentForIcon #attr:indentForIcon#
    -- | TreeExpander indents the child by the width of an expander-icon if it is not expandable.
    --
    -- /Since: 4.6/

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderIndentForIconPropertyInfo   ,
    #endif
        constructTreeExpanderIndentForIcon      ,
        getTreeExpanderIndentForIcon            ,
        setTreeExpanderIndentForIcon            ,
    #if defined(ENABLE_OVERLOADING)
        treeExpanderIndentForIcon               ,
    #endif

    -- ** item #attr:item#
    -- | The item held by this expander\'s row.

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderItemPropertyInfo            ,
    #endif
        getTreeExpanderItem                     ,
    #if defined(ENABLE_OVERLOADING)
        treeExpanderItem                        ,
    #endif

    -- ** listRow #attr:listRow#
    -- | The list row to track for expander state.

    #if defined(ENABLE_OVERLOADING)
        TreeExpanderListRowPropertyInfo         ,
    #endif
        clearTreeExpanderListRow                ,
        constructTreeExpanderListRow            ,
        getTreeExpanderListRow                  ,
        setTreeExpanderListRow                  ,
    #if defined(ENABLE_OVERLOADING)
        treeExpanderListRow                     ,
    #endif

        ) where

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

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

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

    #endif

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

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

    foreign import ccall "gtk_tree_expander_get_type"
        c_gtk_tree_expander_get_type :: IO B.Types.GType

    instance B.Types.TypedObject TreeExpander where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tree_expander_get_type

    instance B.Types.GObject TreeExpander

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

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

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

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

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

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

    #endif

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

    #endif

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

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

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

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

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

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

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

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

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

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

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

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

    -- | Get the value of the “@indent-for-depth@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeExpander #indentForDepth
    -- @
    getTreeExpanderIndentForDepth :: (MonadIO m, IsTreeExpander o) => o -> m Bool
    getTreeExpanderIndentForDepth :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeExpander o) =>
    o -> m Bool
    getTreeExpanderIndentForDepth 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
    "indent-for-depth"

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

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

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

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

    -- | Get the value of the “@indent-for-icon@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' treeExpander #indentForIcon
    -- @
    getTreeExpanderIndentForIcon :: (MonadIO m, IsTreeExpander o) => o -> m Bool
    getTreeExpanderIndentForIcon :: forall (m :: * -> *) o.
    (MonadIO m, IsTreeExpander o) =>
    o -> m Bool
    getTreeExpanderIndentForIcon 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
    "indent-for-icon"

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

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

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

    -- VVV Prop "item"
       -- Type: TInterface (Name {namespace = "GObject", name = "Object"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderListRowPropertyInfo
    instance AttrInfo TreeExpanderListRowPropertyInfo where
        type AttrAllowedOps TreeExpanderListRowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint TreeExpanderListRowPropertyInfo = IsTreeExpander
        type AttrSetTypeConstraint TreeExpanderListRowPropertyInfo = Gtk.TreeListRow.IsTreeListRow
        type AttrTransferTypeConstraint TreeExpanderListRowPropertyInfo = Gtk.TreeListRow.IsTreeListRow
        type AttrTransferType TreeExpanderListRowPropertyInfo = Gtk.TreeListRow.TreeListRow
        type AttrGetType TreeExpanderListRowPropertyInfo = (Maybe Gtk.TreeListRow.TreeListRow)
        type AttrLabel TreeExpanderListRowPropertyInfo = "list-row"
        type AttrOrigin TreeExpanderListRowPropertyInfo = TreeExpander
        attrGet = getTreeExpanderListRow
        attrSet = setTreeExpanderListRow
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.TreeListRow.TreeListRow v
        attrConstruct = constructTreeExpanderListRow
        attrClear = clearTreeExpanderListRow
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.TreeExpander.listRow"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-TreeExpander.html#g:attr:listRow"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList TreeExpander
    type instance O.AttributeList TreeExpander = TreeExpanderAttributeList
    type TreeExpanderAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", TreeExpanderChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hideExpander", TreeExpanderHideExpanderPropertyInfo), '("indentForDepth", TreeExpanderIndentForDepthPropertyInfo), '("indentForIcon", TreeExpanderIndentForIconPropertyInfo), '("item", TreeExpanderItemPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("listRow", TreeExpanderListRowPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    treeExpanderChild :: AttrLabelProxy "child"
    treeExpanderChild = AttrLabelProxy

    treeExpanderHideExpander :: AttrLabelProxy "hideExpander"
    treeExpanderHideExpander = AttrLabelProxy

    treeExpanderIndentForDepth :: AttrLabelProxy "indentForDepth"
    treeExpanderIndentForDepth = AttrLabelProxy

    treeExpanderIndentForIcon :: AttrLabelProxy "indentForIcon"
    treeExpanderIndentForIcon = AttrLabelProxy

    treeExpanderItem :: AttrLabelProxy "item"
    treeExpanderItem = AttrLabelProxy

    treeExpanderListRow :: AttrLabelProxy "listRow"
    treeExpanderListRow = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList TreeExpander = TreeExpanderSignalList
    type TreeExpanderSignalList = ('[ '("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 TreeExpander::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "TreeExpander" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_expander_new" gtk_tree_expander_new ::
        IO (Ptr TreeExpander)

    -- | Creates a new @GtkTreeExpander@
    treeExpanderNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m TreeExpander
        -- ^ __Returns:__ a new @GtkTreeExpander@
    treeExpanderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TreeExpander
    treeExpanderNew  = IO TreeExpander -> m TreeExpander
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TreeExpander -> m TreeExpander)
    -> IO TreeExpander -> m TreeExpander
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr TreeExpander)
    gtk_tree_expander_new
        checkUnexpectedReturnNULL "treeExpanderNew" result
        result' <- (newObject TreeExpander) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "gtk_tree_expander_get_child" gtk_tree_expander_get_child ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Gets the child widget displayed by /@self@/.
    treeExpanderGetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ The child displayed by /@self@/
    treeExpanderGetChild :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> m (Maybe Widget)
    treeExpanderGetChild a
    self = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_tree_expander_get_child self'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr self
        return maybeResult

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

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

    #endif

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

    foreign import ccall "gtk_tree_expander_get_hide_expander" gtk_tree_expander_get_hide_expander ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        IO CInt

    -- | Gets whether the TreeExpander should be hidden in a GtkTreeListRow.
    --
    -- /Since: 4.10/
    treeExpanderGetHideExpander ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> m Bool
        -- ^ __Returns:__ TRUE if the expander icon should be hidden. Otherwise FALSE.
    treeExpanderGetHideExpander :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> m Bool
    treeExpanderGetHideExpander 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_tree_expander_get_hide_expander 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 TreeExpanderGetHideExpanderMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderGetHideExpanderMethodInfo a signature where
        overloadedMethod = treeExpanderGetHideExpander

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

    #endif

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

    foreign import ccall "gtk_tree_expander_get_indent_for_depth" gtk_tree_expander_get_indent_for_depth ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        IO CInt

    -- | TreeExpander indents each level of depth with an additional indent.
    --
    -- /Since: 4.10/
    treeExpanderGetIndentForDepth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> m Bool
        -- ^ __Returns:__ TRUE if the child should be indented . Otherwise FALSE.
    treeExpanderGetIndentForDepth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> m Bool
    treeExpanderGetIndentForDepth 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_tree_expander_get_indent_for_depth 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 TreeExpanderGetIndentForDepthMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderGetIndentForDepthMethodInfo a signature where
        overloadedMethod = treeExpanderGetIndentForDepth

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

    #endif

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

    foreign import ccall "gtk_tree_expander_get_indent_for_icon" gtk_tree_expander_get_indent_for_icon ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        IO CInt

    -- | TreeExpander indents the child by the width of an expander-icon if it is not expandable.
    --
    -- /Since: 4.6/
    treeExpanderGetIndentForIcon ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> m Bool
        -- ^ __Returns:__ TRUE if the child should be indented when not expandable. Otherwise FALSE.
    treeExpanderGetIndentForIcon :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> m Bool
    treeExpanderGetIndentForIcon 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_tree_expander_get_indent_for_icon 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 TreeExpanderGetIndentForIconMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderGetIndentForIconMethodInfo a signature where
        overloadedMethod = treeExpanderGetIndentForIcon

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

    #endif

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

    foreign import ccall "gtk_tree_expander_get_item" gtk_tree_expander_get_item ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        IO (Ptr GObject.Object.Object)

    -- | Forwards the item set on the @GtkTreeListRow@ that /@self@/ is managing.
    --
    -- This call is essentially equivalent to calling:
    --
    --
    -- === /c code/
    -- >gtk_tree_list_row_get_item (gtk_tree_expander_get_list_row (@self));
    treeExpanderGetItem ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> m (Maybe GObject.Object.Object)
        -- ^ __Returns:__ The item of the row
    treeExpanderGetItem :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> m (Maybe Object)
    treeExpanderGetItem a
    self = IO (Maybe Object) -> m (Maybe Object)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Object) -> m (Maybe Object))
    -> IO (Maybe Object) -> m (Maybe Object)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_tree_expander_get_item self'
        maybeResult <- convertIfNonNull result $ \Ptr Object
    result' -> do
            result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Object -> Object
    GObject.Object.Object) Ptr Object
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderGetItemMethodInfo
    instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderGetItemMethodInfo a signature where
        overloadedMethod = treeExpanderGetItem

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

    #endif

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

    foreign import ccall "gtk_tree_expander_get_list_row" gtk_tree_expander_get_list_row ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        IO (Ptr Gtk.TreeListRow.TreeListRow)

    -- | Gets the list row managed by /@self@/.
    treeExpanderGetListRow ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> m (Maybe Gtk.TreeListRow.TreeListRow)
        -- ^ __Returns:__ The list row displayed by /@self@/
    treeExpanderGetListRow :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> m (Maybe TreeListRow)
    treeExpanderGetListRow a
    self = IO (Maybe TreeListRow) -> m (Maybe TreeListRow)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe TreeListRow) -> m (Maybe TreeListRow))
    -> IO (Maybe TreeListRow) -> m (Maybe TreeListRow)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_tree_expander_get_list_row self'
        maybeResult <- convertIfNonNull result $ \Ptr TreeListRow
    result' -> do
            result'' <- ((ManagedPtr TreeListRow -> TreeListRow)
    -> Ptr TreeListRow -> IO TreeListRow
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr TreeListRow -> TreeListRow
    Gtk.TreeListRow.TreeListRow) Ptr TreeListRow
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderGetListRowMethodInfo
    instance (signature ~ (m (Maybe Gtk.TreeListRow.TreeListRow)), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderGetListRowMethodInfo a signature where
        overloadedMethod = treeExpanderGetListRow

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

    #endif

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

    foreign import ccall "gtk_tree_expander_set_child" gtk_tree_expander_set_child ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets the content widget to display.
    treeExpanderSetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@
        -> Maybe (b)
        -- ^ /@child@/: a @GtkWidget@
        -> m ()
    treeExpanderSetChild :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeExpander a, IsWidget b) =>
    a -> Maybe b -> m ()
    treeExpanderSetChild a
    self Maybe b
    child = 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeChild <- case child of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jChild -> do
                jChild' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jChild
                return jChild'
        gtk_tree_expander_set_child self' maybeChild
        touchManagedPtr self
        whenJust child touchManagedPtr
        return ()

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

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

    #endif

    -- method TreeExpander::set_hide_expander
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeExpander" }
    --           , argCType = Just "GtkTreeExpander*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeExpander` widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "hide_expander"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "TRUE if the expander should be hidden. Otherwise FALSE."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_expander_set_hide_expander" gtk_tree_expander_set_hide_expander ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        CInt ->                                 -- hide_expander : TBasicType TBoolean
        IO ()

    -- | Sets whether the expander icon should be visible in a GtkTreeListRow.
    --
    -- /Since: 4.10/
    treeExpanderSetHideExpander ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@ widget
        -> Bool
        -- ^ /@hideExpander@/: TRUE if the expander should be hidden. Otherwise FALSE.
        -> m ()
    treeExpanderSetHideExpander :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> Bool -> m ()
    treeExpanderSetHideExpander a
    self Bool
    hideExpander = 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let hideExpander' = (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
    hideExpander
        gtk_tree_expander_set_hide_expander self' hideExpander'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderSetHideExpanderMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderSetHideExpanderMethodInfo a signature where
        overloadedMethod = treeExpanderSetHideExpander

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

    #endif

    -- method TreeExpander::set_indent_for_depth
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeExpander" }
    --           , argCType = Just "GtkTreeExpander*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeExpander` widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "indent_for_depth"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "TRUE if the child should be indented. Otherwise FALSE."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_expander_set_indent_for_depth" gtk_tree_expander_set_indent_for_depth ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        CInt ->                                 -- indent_for_depth : TBasicType TBoolean
        IO ()

    -- | Sets if the TreeExpander should indent the child according to its depth.
    --
    -- /Since: 4.10/
    treeExpanderSetIndentForDepth ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@ widget
        -> Bool
        -- ^ /@indentForDepth@/: TRUE if the child should be indented. Otherwise FALSE.
        -> m ()
    treeExpanderSetIndentForDepth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> Bool -> m ()
    treeExpanderSetIndentForDepth a
    self Bool
    indentForDepth = 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let indentForDepth' = (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
    indentForDepth
        gtk_tree_expander_set_indent_for_depth self' indentForDepth'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderSetIndentForDepthMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderSetIndentForDepthMethodInfo a signature where
        overloadedMethod = treeExpanderSetIndentForDepth

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

    #endif

    -- method TreeExpander::set_indent_for_icon
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeExpander" }
    --           , argCType = Just "GtkTreeExpander*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeExpander` widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "indent_for_icon"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "TRUE if the child should be indented without expander. Otherwise FALSE."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_expander_set_indent_for_icon" gtk_tree_expander_set_indent_for_icon ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        CInt ->                                 -- indent_for_icon : TBasicType TBoolean
        IO ()

    -- | Sets if the TreeExpander should indent the child by the width of an expander-icon when it is not expandable.
    --
    -- /Since: 4.6/
    treeExpanderSetIndentForIcon ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@ widget
        -> Bool
        -- ^ /@indentForIcon@/: TRUE if the child should be indented without expander. Otherwise FALSE.
        -> m ()
    treeExpanderSetIndentForIcon :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeExpander a) =>
    a -> Bool -> m ()
    treeExpanderSetIndentForIcon a
    self Bool
    indentForIcon = 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let indentForIcon' = (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
    indentForIcon
        gtk_tree_expander_set_indent_for_icon self' indentForIcon'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderSetIndentForIconMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeExpander a) => O.OverloadedMethod TreeExpanderSetIndentForIconMethodInfo a signature where
        overloadedMethod = treeExpanderSetIndentForIcon

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

    #endif

    -- method TreeExpander::set_list_row
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeExpander" }
    --           , argCType = Just "GtkTreeExpander*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeExpander` widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "list_row"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeListRow" }
    --           , argCType = Just "GtkTreeListRow*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreeListRow`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_tree_expander_set_list_row" gtk_tree_expander_set_list_row ::
        Ptr TreeExpander ->                     -- self : TInterface (Name {namespace = "Gtk", name = "TreeExpander"})
        Ptr Gtk.TreeListRow.TreeListRow ->      -- list_row : TInterface (Name {namespace = "Gtk", name = "TreeListRow"})
        IO ()

    -- | Sets the tree list row that this expander should manage.
    treeExpanderSetListRow ::
        (B.CallStack.HasCallStack, MonadIO m, IsTreeExpander a, Gtk.TreeListRow.IsTreeListRow b) =>
        a
        -- ^ /@self@/: a @GtkTreeExpander@ widget
        -> Maybe (b)
        -- ^ /@listRow@/: a @GtkTreeListRow@
        -> m ()
    treeExpanderSetListRow :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsTreeExpander a, IsTreeListRow b) =>
    a -> Maybe b -> m ()
    treeExpanderSetListRow a
    self Maybe b
    listRow = 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 TreeExpander)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeListRow <- case listRow of
            Maybe b
    Nothing -> Ptr TreeListRow -> IO (Ptr TreeListRow)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr TreeListRow
    forall a. Ptr a
    FP.nullPtr
            Just b
    jListRow -> do
                jListRow' <- b -> IO (Ptr TreeListRow)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jListRow
                return jListRow'
        gtk_tree_expander_set_list_row self' maybeListRow
        touchManagedPtr self
        whenJust listRow touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TreeExpanderSetListRowMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeExpander a, Gtk.TreeListRow.IsTreeListRow b) => O.OverloadedMethod TreeExpanderSetListRowMethodInfo a signature where
        overloadedMethod = treeExpanderSetListRow

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

    #endif