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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Places a label next to an indicator.
    --
    -- \<picture>
    --   \<source srcset=\"check-button-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"Example GtkCheckButtons\" src=\"check-button.png\">
    -- \<\/picture>
    --
    -- A @GtkCheckButton@ is created by calling either 'GI.Gtk.Objects.CheckButton.checkButtonNew'
    -- or 'GI.Gtk.Objects.CheckButton.checkButtonNewWithLabel'.
    --
    -- The state of a @GtkCheckButton@ can be set specifically using
    -- 'GI.Gtk.Objects.CheckButton.checkButtonSetActive', and retrieved using
    -- 'GI.Gtk.Objects.CheckButton.checkButtonGetActive'.
    --
    -- = Inconsistent state
    --
    -- In addition to \"on\" and \"off\", check buttons can be an
    -- \"in between\" state that is neither on nor off. This can be used
    -- e.g. when the user has selected a range of elements (such as some
    -- text or spreadsheet cells) that are affected by a check button,
    -- and the current values in that range are inconsistent.
    --
    -- To set a @GtkCheckButton@ to inconsistent state, use
    -- 'GI.Gtk.Objects.CheckButton.checkButtonSetInconsistent'.
    --
    -- = Grouping
    --
    -- Check buttons can be grouped together, to form mutually exclusive
    -- groups - only one of the buttons can be toggled at a time, and toggling
    -- another one will switch the currently toggled one off.
    --
    -- Grouped check buttons use a different indicator, and are commonly referred
    -- to as *radio buttons*.
    --
    -- \<picture>
    --   \<source srcset=\"radio-button-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"Example GtkRadioButtons\" src=\"radio-button.png\">
    -- \<\/picture>
    --
    -- To add a @GtkCheckButton@ to a group, use 'GI.Gtk.Objects.CheckButton.checkButtonSetGroup'.
    --
    -- When the code must keep track of the state of a group of radio buttons, it
    -- is recommended to keep track of such state through a stateful
    -- @GAction@ with a target for each button. Using the @toggled@ signals to keep
    -- track of the group changes and state is discouraged.
    --
    -- = Shortcuts and Gestures
    --
    -- @GtkCheckButton@ supports the following keyboard shortcuts:
    --
    -- * \<kbd>␣\<\/kbd> or \<kbd>Enter\<\/kbd> activates the button.
    --
    --
    -- = CSS nodes
    --
    --
    --
    -- >checkbutton[.text-button][.grouped]
    -- >├── check
    -- >╰── [label]
    --
    --
    -- A @GtkCheckButton@ has a main node with name checkbutton. If the
    -- [CheckButton:label]("GI.Gtk.Objects.CheckButton#g:attr:label") or [CheckButton:child]("GI.Gtk.Objects.CheckButton#g:attr:child")
    -- properties are set, it contains a child widget. The indicator node
    -- is named check when no group is set, and radio if the checkbutton
    -- is grouped together with other checkbuttons.
    --
    -- = Accessibility
    --
    -- @GtkCheckButton@ uses the 'GI.Gtk.Enums.AccessibleRoleCheckbox' role.

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

    module GI.Gtk.Objects.CheckButton
        (

    -- * Exported types
        CheckButton(..)                         ,
        IsCheckButton                           ,
        toCheckButton                           ,

     -- * 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"), [getActionName]("GI.Gtk.Interfaces.Actionable#g:method:getActionName"), [getActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:getActionTargetValue"), [getActive]("GI.Gtk.Objects.CheckButton#g:method:getActive"), [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.CheckButton#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"), [getInconsistent]("GI.Gtk.Objects.CheckButton#g:method:getInconsistent"), [getLabel]("GI.Gtk.Objects.CheckButton#g:method:getLabel"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [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"), [getUseUnderline]("GI.Gtk.Objects.CheckButton#g:method:getUseUnderline"), [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"), [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setActive]("GI.Gtk.Objects.CheckButton#g:method:setActive"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.CheckButton#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"), [setDetailedActionName]("GI.Gtk.Interfaces.Actionable#g:method:setDetailedActionName"), [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"), [setGroup]("GI.Gtk.Objects.CheckButton#g:method:setGroup"), [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"), [setInconsistent]("GI.Gtk.Objects.CheckButton#g:method:setInconsistent"), [setLabel]("GI.Gtk.Objects.CheckButton#g:method:setLabel"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [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"), [setUseUnderline]("GI.Gtk.Objects.CheckButton#g:method:setUseUnderline"), [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)
        ResolveCheckButtonMethod                ,
    #endif

    -- ** getActive #method:getActive#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonGetActiveMethodInfo          ,
    #endif
        checkButtonGetActive                    ,

    -- ** getChild #method:getChild#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonGetChildMethodInfo           ,
    #endif
        checkButtonGetChild                     ,

    -- ** getInconsistent #method:getInconsistent#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonGetInconsistentMethodInfo    ,
    #endif
        checkButtonGetInconsistent              ,

    -- ** getLabel #method:getLabel#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonGetLabelMethodInfo           ,
    #endif
        checkButtonGetLabel                     ,

    -- ** getUseUnderline #method:getUseUnderline#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonGetUseUnderlineMethodInfo    ,
    #endif
        checkButtonGetUseUnderline              ,

    -- ** new #method:new#

        checkButtonNew                          ,

    -- ** newWithLabel #method:newWithLabel#

        checkButtonNewWithLabel                 ,

    -- ** newWithMnemonic #method:newWithMnemonic#

        checkButtonNewWithMnemonic              ,

    -- ** setActive #method:setActive#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonSetActiveMethodInfo          ,
    #endif
        checkButtonSetActive                    ,

    -- ** setChild #method:setChild#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonSetChildMethodInfo           ,
    #endif
        checkButtonSetChild                     ,

    -- ** setGroup #method:setGroup#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonSetGroupMethodInfo           ,
    #endif
        checkButtonSetGroup                     ,

    -- ** setInconsistent #method:setInconsistent#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonSetInconsistentMethodInfo    ,
    #endif
        checkButtonSetInconsistent              ,

    -- ** setLabel #method:setLabel#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonSetLabelMethodInfo           ,
    #endif
        checkButtonSetLabel                     ,

    -- ** setUseUnderline #method:setUseUnderline#

    #if defined(ENABLE_OVERLOADING)
        CheckButtonSetUseUnderlineMethodInfo    ,
    #endif
        checkButtonSetUseUnderline              ,

     -- * Properties

    -- ** active #attr:active#
    -- | If the check button is active.
    --
    -- Setting @active@ to 'P.True' will add the @:checked:@ state to both
    -- the check button and the indicator CSS node.

    #if defined(ENABLE_OVERLOADING)
        CheckButtonActivePropertyInfo           ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkButtonActive                       ,
    #endif
        constructCheckButtonActive              ,
        getCheckButtonActive                    ,
        setCheckButtonActive                    ,

    -- ** child #attr:child#
    -- | The child widget.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        CheckButtonChildPropertyInfo            ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkButtonChild                        ,
    #endif
        clearCheckButtonChild                   ,
        constructCheckButtonChild               ,
        getCheckButtonChild                     ,
        setCheckButtonChild                     ,

    -- ** group #attr:group#
    -- | The check button whose group this widget belongs to.

    #if defined(ENABLE_OVERLOADING)
        CheckButtonGroupPropertyInfo            ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkButtonGroup                        ,
    #endif
        clearCheckButtonGroup                   ,
        constructCheckButtonGroup               ,
        setCheckButtonGroup                     ,

    -- ** inconsistent #attr:inconsistent#
    -- | If the check button is in an “in between” state.
    --
    -- The inconsistent state only affects visual appearance,
    -- not the semantics of the button.

    #if defined(ENABLE_OVERLOADING)
        CheckButtonInconsistentPropertyInfo     ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkButtonInconsistent                 ,
    #endif
        constructCheckButtonInconsistent        ,
        getCheckButtonInconsistent              ,
        setCheckButtonInconsistent              ,

    -- ** label #attr:label#
    -- | Text of the label inside the check button, if it contains a label widget.

    #if defined(ENABLE_OVERLOADING)
        CheckButtonLabelPropertyInfo            ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkButtonLabel                        ,
    #endif
        clearCheckButtonLabel                   ,
        constructCheckButtonLabel               ,
        getCheckButtonLabel                     ,
        setCheckButtonLabel                     ,

    -- ** useUnderline #attr:useUnderline#
    -- | If set, an underline in the text indicates that the following
    -- character is to be used as mnemonic.

    #if defined(ENABLE_OVERLOADING)
        CheckButtonUseUnderlinePropertyInfo     ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkButtonUseUnderline                 ,
    #endif
        constructCheckButtonUseUnderline        ,
        getCheckButtonUseUnderline              ,
        setCheckButtonUseUnderline              ,

     -- * Signals

    -- ** activate #signal:activate#

        CheckButtonActivateCallback             ,
    #if defined(ENABLE_OVERLOADING)
        CheckButtonActivateSignalInfo           ,
    #endif
        afterCheckButtonActivate                ,
        onCheckButtonActivate                   ,

    -- ** toggled #signal:toggled#

        CheckButtonToggledCallback              ,
    #if defined(ENABLE_OVERLOADING)
        CheckButtonToggledSignalInfo            ,
    #endif
        afterCheckButtonToggled                 ,
        onCheckButtonToggled                    ,

        ) 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.Actionable as Gtk.Actionable
    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.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.Actionable as Gtk.Actionable
    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.Widget as Gtk.Widget

    #endif

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

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

    foreign import ccall "gtk_check_button_get_type"
        c_gtk_check_button_get_type :: IO B.Types.GType

    instance B.Types.TypedObject CheckButton where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_check_button_get_type

    instance B.Types.GObject CheckButton

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

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

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

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

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

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

    #endif

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

    #endif

    -- signal CheckButton::activate
    -- | Emitted to when the check button is activated.
    --
    -- The @::activate@ signal on @GtkCheckButton@ is an action signal and
    -- emitting it causes the button to animate press then release.
    --
    -- Applications should never connect to this signal, but use the
    -- [CheckButton::toggled]("GI.Gtk.Objects.CheckButton#g:signal:toggled") signal.
    --
    -- The default bindings for this signal are all forms of the
    -- \<kbd>␣\<\/kbd> and \<kbd>Enter\<\/kbd> keys.
    --
    -- /Since: 4.2/
    type CheckButtonActivateCallback =
        IO ()

    type C_CheckButtonActivateCallback =
        Ptr CheckButton ->                      -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_CheckButtonActivateCallback ::
        GObject a => (a -> CheckButtonActivateCallback) ->
        C_CheckButtonActivateCallback
    wrap_CheckButtonActivateCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckButtonActivateCallback
    wrap_CheckButtonActivateCallback a -> IO ()
    gi'cb Ptr CheckButton
    gi'selfPtr Ptr ()
    _ = do
        Ptr CheckButton -> (CheckButton -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr CheckButton
    gi'selfPtr ((CheckButton -> IO ()) -> IO ())
    -> (CheckButton -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CheckButton
    gi'self -> a -> IO ()
    gi'cb (CheckButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce CheckButton
    gi'self)

    -- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' checkButton #activate callback
    -- @
    --
    --
    onCheckButtonActivate :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonActivateCallback) -> m SignalHandlerId
    onCheckButtonActivate :: forall a (m :: * -> *).
    (IsCheckButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onCheckButtonActivate a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CheckButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_CheckButtonActivateCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckButtonActivateCallback
    wrap_CheckButtonActivateCallback a -> IO ()
    wrapped
        wrapped'' <- C_CheckButtonActivateCallback
    -> IO (FunPtr C_CheckButtonActivateCallback)
    mk_CheckButtonActivateCallback C_CheckButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' checkButton #activate callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterCheckButtonActivate :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonActivateCallback) -> m SignalHandlerId
    afterCheckButtonActivate :: forall a (m :: * -> *).
    (IsCheckButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterCheckButtonActivate a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CheckButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_CheckButtonActivateCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckButtonActivateCallback
    wrap_CheckButtonActivateCallback a -> IO ()
    wrapped
        wrapped'' <- C_CheckButtonActivateCallback
    -> IO (FunPtr C_CheckButtonActivateCallback)
    mk_CheckButtonActivateCallback C_CheckButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectAfter Nothing

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

    #endif

    -- signal CheckButton::toggled
    -- | Emitted when the buttons\'s [CheckButton:active]("GI.Gtk.Objects.CheckButton#g:attr:active")
    -- property changes.
    type CheckButtonToggledCallback =
        IO ()

    type C_CheckButtonToggledCallback =
        Ptr CheckButton ->                      -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_CheckButtonToggledCallback ::
        GObject a => (a -> CheckButtonToggledCallback) ->
        C_CheckButtonToggledCallback
    wrap_CheckButtonToggledCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckButtonActivateCallback
    wrap_CheckButtonToggledCallback a -> IO ()
    gi'cb Ptr CheckButton
    gi'selfPtr Ptr ()
    _ = do
        Ptr CheckButton -> (CheckButton -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr CheckButton
    gi'selfPtr ((CheckButton -> IO ()) -> IO ())
    -> (CheckButton -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CheckButton
    gi'self -> a -> IO ()
    gi'cb (CheckButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce CheckButton
    gi'self)

    -- | Connect a signal handler for the [toggled](#signal:toggled) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' checkButton #toggled callback
    -- @
    --
    --
    onCheckButtonToggled :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonToggledCallback) -> m SignalHandlerId
    onCheckButtonToggled :: forall a (m :: * -> *).
    (IsCheckButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onCheckButtonToggled a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CheckButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_CheckButtonActivateCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckButtonActivateCallback
    wrap_CheckButtonToggledCallback a -> IO ()
    wrapped
        wrapped'' <- C_CheckButtonActivateCallback
    -> IO (FunPtr C_CheckButtonActivateCallback)
    mk_CheckButtonToggledCallback C_CheckButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "toggled" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [toggled](#signal:toggled) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' checkButton #toggled callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterCheckButtonToggled :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonToggledCallback) -> m SignalHandlerId
    afterCheckButtonToggled :: forall a (m :: * -> *).
    (IsCheckButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterCheckButtonToggled a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CheckButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_CheckButtonActivateCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckButtonActivateCallback
    wrap_CheckButtonToggledCallback a -> IO ()
    wrapped
        wrapped'' <- C_CheckButtonActivateCallback
    -> IO (FunPtr C_CheckButtonActivateCallback)
    mk_CheckButtonToggledCallback C_CheckButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "toggled" wrapped'' SignalConnectAfter Nothing

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

    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonActivePropertyInfo
    instance AttrInfo CheckButtonActivePropertyInfo where
        type AttrAllowedOps CheckButtonActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CheckButtonActivePropertyInfo = IsCheckButton
        type AttrSetTypeConstraint CheckButtonActivePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint CheckButtonActivePropertyInfo = (~) Bool
        type AttrTransferType CheckButtonActivePropertyInfo = Bool
        type AttrGetType CheckButtonActivePropertyInfo = Bool
        type AttrLabel CheckButtonActivePropertyInfo = "active"
        type AttrOrigin CheckButtonActivePropertyInfo = CheckButton
        attrGet = getCheckButtonActive
        attrSet = setCheckButtonActive
        attrPut = setCheckButtonActive
        attrTransfer _ v = do
            return v
        attrConstruct = constructCheckButtonActive
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckButton.active"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-CheckButton.html#g:attr:active"
            })
    #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' checkButton #child
    -- @
    getCheckButtonChild :: (MonadIO m, IsCheckButton o) => o -> m (Maybe Gtk.Widget.Widget)
    getCheckButtonChild :: forall (m :: * -> *) o.
    (MonadIO m, IsCheckButton o) =>
    o -> m (Maybe Widget)
    getCheckButtonChild 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' checkButton [ #child 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCheckButtonChild :: (MonadIO m, IsCheckButton o, Gtk.Widget.IsWidget a) => o -> a -> m ()
    setCheckButtonChild :: forall (m :: * -> *) o a.
    (MonadIO m, IsCheckButton o, IsWidget a) =>
    o -> a -> m ()
    setCheckButtonChild 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`.
    constructCheckButtonChild :: (IsCheckButton o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
    constructCheckButtonChild :: forall o (m :: * -> *) a.
    (IsCheckButton o, MonadIO m, IsWidget a) =>
    a -> m (GValueConstruct o)
    constructCheckButtonChild 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
    -- @
    clearCheckButtonChild :: (MonadIO m, IsCheckButton o) => o -> m ()
    clearCheckButtonChild :: forall (m :: * -> *) o. (MonadIO m, IsCheckButton o) => o -> m ()
    clearCheckButtonChild 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 CheckButtonChildPropertyInfo
    instance AttrInfo CheckButtonChildPropertyInfo where
        type AttrAllowedOps CheckButtonChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint CheckButtonChildPropertyInfo = IsCheckButton
        type AttrSetTypeConstraint CheckButtonChildPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint CheckButtonChildPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType CheckButtonChildPropertyInfo = Gtk.Widget.Widget
        type AttrGetType CheckButtonChildPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel CheckButtonChildPropertyInfo = "child"
        type AttrOrigin CheckButtonChildPropertyInfo = CheckButton
        attrGet = getCheckButtonChild
        attrSet = setCheckButtonChild
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructCheckButtonChild
        attrClear = clearCheckButtonChild
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckButton.child"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-CheckButton.html#g:attr:child"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonGroupPropertyInfo
    instance AttrInfo CheckButtonGroupPropertyInfo where
        type AttrAllowedOps CheckButtonGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
        type AttrBaseTypeConstraint CheckButtonGroupPropertyInfo = IsCheckButton
        type AttrSetTypeConstraint CheckButtonGroupPropertyInfo = IsCheckButton
        type AttrTransferTypeConstraint CheckButtonGroupPropertyInfo = IsCheckButton
        type AttrTransferType CheckButtonGroupPropertyInfo = CheckButton
        type AttrGetType CheckButtonGroupPropertyInfo = ()
        type AttrLabel CheckButtonGroupPropertyInfo = "group"
        type AttrOrigin CheckButtonGroupPropertyInfo = CheckButton
        attrGet = undefined
        attrSet = setCheckButtonGroup
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo CheckButton v
        attrConstruct = constructCheckButtonGroup
        attrClear = clearCheckButtonGroup
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckButton.group"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-CheckButton.html#g:attr:group"
            })
    #endif

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

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonLabelPropertyInfo
    instance AttrInfo CheckButtonLabelPropertyInfo where
        type AttrAllowedOps CheckButtonLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint CheckButtonLabelPropertyInfo = IsCheckButton
        type AttrSetTypeConstraint CheckButtonLabelPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint CheckButtonLabelPropertyInfo = (~) T.Text
        type AttrTransferType CheckButtonLabelPropertyInfo = T.Text
        type AttrGetType CheckButtonLabelPropertyInfo = (Maybe T.Text)
        type AttrLabel CheckButtonLabelPropertyInfo = "label"
        type AttrOrigin CheckButtonLabelPropertyInfo = CheckButton
        attrGet = getCheckButtonLabel
        attrSet = setCheckButtonLabel
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructCheckButtonLabel
        attrClear = clearCheckButtonLabel
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckButton.label"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-CheckButton.html#g:attr:label"
            })
    #endif

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList CheckButton
    type instance O.AttributeList CheckButton = CheckButtonAttributeList
    type CheckButtonAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("active", CheckButtonActivePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", CheckButtonChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("group", CheckButtonGroupPropertyInfo), '("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), '("inconsistent", CheckButtonInconsistentPropertyInfo), '("label", CheckButtonLabelPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("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), '("useUnderline", CheckButtonUseUnderlinePropertyInfo), '("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)
    checkButtonActive :: AttrLabelProxy "active"
    checkButtonActive = AttrLabelProxy

    checkButtonChild :: AttrLabelProxy "child"
    checkButtonChild = AttrLabelProxy

    checkButtonGroup :: AttrLabelProxy "group"
    checkButtonGroup = AttrLabelProxy

    checkButtonInconsistent :: AttrLabelProxy "inconsistent"
    checkButtonInconsistent = AttrLabelProxy

    checkButtonLabel :: AttrLabelProxy "label"
    checkButtonLabel = AttrLabelProxy

    checkButtonUseUnderline :: AttrLabelProxy "useUnderline"
    checkButtonUseUnderline = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList CheckButton = CheckButtonSignalList
    type CheckButtonSignalList = ('[ '("activate", CheckButtonActivateSignalInfo), '("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), '("toggled", CheckButtonToggledSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

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

    foreign import ccall "gtk_check_button_new" gtk_check_button_new ::
        IO (Ptr CheckButton)

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

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CheckButton::new_with_label
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "label"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the text for the check button."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "CheckButton" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_button_new_with_label" gtk_check_button_new_with_label ::
        CString ->                              -- label : TBasicType TUTF8
        IO (Ptr CheckButton)

    -- | Creates a new @GtkCheckButton@ with the given text.
    checkButtonNewWithLabel ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (T.Text)
        -- ^ /@label@/: the text for the check button.
        -> m CheckButton
        -- ^ __Returns:__ a new @GtkCheckButton@
    checkButtonNewWithLabel :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Text -> m CheckButton
    checkButtonNewWithLabel Maybe Text
    label = IO CheckButton -> m CheckButton
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CheckButton -> m CheckButton)
    -> IO CheckButton -> m CheckButton
    forall a b. (a -> b) -> a -> b
    $ do
        maybeLabel <- case Maybe Text
    label of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jLabel -> do
                jLabel' <- Text -> IO (Ptr CChar)
    textToCString Text
    jLabel
                return jLabel'
        result <- gtk_check_button_new_with_label maybeLabel
        checkUnexpectedReturnNULL "checkButtonNewWithLabel" result
        result' <- (newObject CheckButton) result
        freeMem maybeLabel
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CheckButton::new_with_mnemonic
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "label"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "The text of the button, with an underscore\n  in front of the mnemonic character"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "CheckButton" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_button_new_with_mnemonic" gtk_check_button_new_with_mnemonic ::
        CString ->                              -- label : TBasicType TUTF8
        IO (Ptr CheckButton)

    -- | Creates a new @GtkCheckButton@ with the given text and a mnemonic.
    checkButtonNewWithMnemonic ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (T.Text)
        -- ^ /@label@/: The text of the button, with an underscore
        --   in front of the mnemonic character
        -> m CheckButton
        -- ^ __Returns:__ a new @GtkCheckButton@
    checkButtonNewWithMnemonic :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Text -> m CheckButton
    checkButtonNewWithMnemonic Maybe Text
    label = IO CheckButton -> m CheckButton
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CheckButton -> m CheckButton)
    -> IO CheckButton -> m CheckButton
    forall a b. (a -> b) -> a -> b
    $ do
        maybeLabel <- case Maybe Text
    label of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jLabel -> do
                jLabel' <- Text -> IO (Ptr CChar)
    textToCString Text
    jLabel
                return jLabel'
        result <- gtk_check_button_new_with_mnemonic maybeLabel
        checkUnexpectedReturnNULL "checkButtonNewWithMnemonic" result
        result' <- (newObject CheckButton) result
        freeMem maybeLabel
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CheckButton::get_active
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , 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_check_button_get_active" gtk_check_button_get_active ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        IO CInt

    -- | Returns whether the check button is active.
    checkButtonGetActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> m Bool
        -- ^ __Returns:__ whether the check button is active
    checkButtonGetActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> m Bool
    checkButtonGetActive 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 CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_check_button_get_active 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 CheckButtonGetActiveMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonGetActiveMethodInfo a signature where
        overloadedMethod = checkButtonGetActive

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

    #endif

    -- method CheckButton::get_child
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , 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_check_button_get_child" gtk_check_button_get_child ::
        Ptr CheckButton ->                      -- button : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Gets the child widget of /@button@/ or @NULL@ if [property/@checkButton@/:label] is set.
    --
    -- /Since: 4.8/
    checkButtonGetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@button@/: a @GtkCheckButton@
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ the child widget of /@button@/
    checkButtonGetChild :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> m (Maybe Widget)
    checkButtonGetChild a
    button = 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
        button' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    button
        result <- gtk_check_button_get_child button'
        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 button
        return maybeResult

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

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

    #endif

    -- method CheckButton::get_inconsistent
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "check_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , 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_check_button_get_inconsistent" gtk_check_button_get_inconsistent ::
        Ptr CheckButton ->                      -- check_button : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        IO CInt

    -- | Returns whether the check button is in an inconsistent state.
    checkButtonGetInconsistent ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@checkButton@/: a @GtkCheckButton@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@checkButton@/ is currently in an inconsistent state
    checkButtonGetInconsistent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> m Bool
    checkButtonGetInconsistent a
    checkButton = 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
        checkButton' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkButton
        result <- gtk_check_button_get_inconsistent checkButton'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr checkButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonGetInconsistentMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonGetInconsistentMethodInfo a signature where
        overloadedMethod = checkButtonGetInconsistent

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

    #endif

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

    foreign import ccall "gtk_check_button_get_label" gtk_check_button_get_label ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        IO CString

    -- | Returns the label of the check button or @NULL@ if [property/@checkButton@/:child] is set.
    checkButtonGetLabel ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> m (Maybe T.Text)
        -- ^ __Returns:__ The label /@self@/ shows next
        --   to the indicator. If no label is shown, 'P.Nothing' will be returned.
    checkButtonGetLabel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> m (Maybe Text)
    checkButtonGetLabel a
    self = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_check_button_get_label self'
        maybeResult <- convertIfNonNull result $ \Ptr CChar
    result' -> do
            result'' <- HasCallStack => Ptr CChar -> IO Text
    Ptr CChar -> IO Text
    cstringToText Ptr CChar
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonGetLabelMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonGetLabelMethodInfo a signature where
        overloadedMethod = checkButtonGetLabel

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

    #endif

    -- method CheckButton::get_use_underline
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , 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_check_button_get_use_underline" gtk_check_button_get_use_underline ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        IO CInt

    -- | Returns whether underlines in the label indicate mnemonics.
    checkButtonGetUseUnderline ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> m Bool
        -- ^ __Returns:__ The value of the [CheckButton:useUnderline]("GI.Gtk.Objects.CheckButton#g:attr:useUnderline") property.
        --   See 'GI.Gtk.Objects.CheckButton.checkButtonSetUseUnderline' for details on how to set
        --   a new value.
    checkButtonGetUseUnderline :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> m Bool
    checkButtonGetUseUnderline 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 CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_check_button_get_use_underline 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 CheckButtonGetUseUnderlineMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonGetUseUnderlineMethodInfo a signature where
        overloadedMethod = checkButtonGetUseUnderline

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

    #endif

    -- method CheckButton::set_active
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new value to set"
    --                 , 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_check_button_set_active" gtk_check_button_set_active ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Changes the check buttons active state.
    checkButtonSetActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> Bool
        -- ^ /@setting@/: the new value to set
        -> m ()
    checkButtonSetActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> Bool -> m ()
    checkButtonSetActive a
    self Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_check_button_set_active self' setting'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonSetActiveMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonSetActiveMethodInfo a signature where
        overloadedMethod = checkButtonSetActive

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

    #endif

    -- method CheckButton::set_child
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , 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 "the child widget" , 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_check_button_set_child" gtk_check_button_set_child ::
        Ptr CheckButton ->                      -- button : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets the child widget of /@button@/.
    --
    -- Note that by using this API, you take full responsibility for setting
    -- up the proper accessibility label and description information for /@button@/.
    -- Most likely, you\'ll either set the accessibility label or description
    -- for /@button@/ explicitly, or you\'ll set a labelled-by or described-by
    -- relations from /@child@/ to /@button@/.
    --
    -- /Since: 4.8/
    checkButtonSetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@button@/: a @GtkCheckButton@
        -> Maybe (b)
        -- ^ /@child@/: the child widget
        -> m ()
    checkButtonSetChild :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsCheckButton a, IsWidget b) =>
    a -> Maybe b -> m ()
    checkButtonSetChild a
    button 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
        button' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    button
        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_check_button_set_child button' maybeChild
        touchManagedPtr button
        whenJust child touchManagedPtr
        return ()

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

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

    #endif

    -- method CheckButton::set_group
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "group"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "another `GtkCheckButton` to\n  form a group with"
    --                 , 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_check_button_set_group" gtk_check_button_set_group ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        Ptr CheckButton ->                      -- group : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        IO ()

    -- | Adds /@self@/ to the group of /@group@/.
    --
    -- In a group of multiple check buttons, only one button can be active
    -- at a time. The behavior of a checkbutton in a group is also commonly
    -- known as a *radio button*.
    --
    -- Setting the group of a check button also changes the css name of the
    -- indicator widget\'s CSS node to \'radio\'.
    --
    -- Setting up groups in a cycle leads to undefined behavior.
    --
    -- Note that the same effect can be achieved via the t'GI.Gtk.Interfaces.Actionable.Actionable'
    -- API, by using the same action with parameter type and state type \'s\'
    -- for all buttons in the group, and giving each button its own target
    -- value.
    checkButtonSetGroup ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a, IsCheckButton b) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> Maybe (b)
        -- ^ /@group@/: another @GtkCheckButton@ to
        --   form a group with
        -> m ()
    checkButtonSetGroup :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsCheckButton a, IsCheckButton b) =>
    a -> Maybe b -> m ()
    checkButtonSetGroup a
    self Maybe b
    group = 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 CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeGroup <- case group of
            Maybe b
    Nothing -> Ptr CheckButton -> IO (Ptr CheckButton)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CheckButton
    forall a. Ptr a
    FP.nullPtr
            Just b
    jGroup -> do
                jGroup' <- b -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jGroup
                return jGroup'
        gtk_check_button_set_group self' maybeGroup
        touchManagedPtr self
        whenJust group touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonSetGroupMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCheckButton a, IsCheckButton b) => O.OverloadedMethod CheckButtonSetGroupMethodInfo a signature where
        overloadedMethod = checkButtonSetGroup

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

    #endif

    -- method CheckButton::set_inconsistent
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "check_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "inconsistent"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE if state is inconsistent"
    --                 , 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_check_button_set_inconsistent" gtk_check_button_set_inconsistent ::
        Ptr CheckButton ->                      -- check_button : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        CInt ->                                 -- inconsistent : TBasicType TBoolean
        IO ()

    -- | Sets the @GtkCheckButton@ to inconsistent state.
    --
    -- You should turn off the inconsistent state again if the user checks
    -- the check button. This has to be done manually.
    checkButtonSetInconsistent ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@checkButton@/: a @GtkCheckButton@
        -> Bool
        -- ^ /@inconsistent@/: 'P.True' if state is inconsistent
        -> m ()
    checkButtonSetInconsistent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> Bool -> m ()
    checkButtonSetInconsistent a
    checkButton Bool
    inconsistent = 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
        checkButton' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkButton
        let inconsistent' = (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
    inconsistent
        gtk_check_button_set_inconsistent checkButton' inconsistent'
        touchManagedPtr checkButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonSetInconsistentMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonSetInconsistentMethodInfo a signature where
        overloadedMethod = checkButtonSetInconsistent

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

    #endif

    -- method CheckButton::set_label
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "label"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "The text shown next to the indicator, or %NULL\n  to show no text"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_button_set_label" gtk_check_button_set_label ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        CString ->                              -- label : TBasicType TUTF8
        IO ()

    -- | Sets the text of /@self@/.
    --
    -- If [CheckButton:useUnderline]("GI.Gtk.Objects.CheckButton#g:attr:useUnderline") is 'P.True', an underscore
    -- in /@label@/ is interpreted as mnemonic indicator, see
    -- 'GI.Gtk.Objects.CheckButton.checkButtonSetUseUnderline' for details on this behavior.
    checkButtonSetLabel ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> Maybe (T.Text)
        -- ^ /@label@/: The text shown next to the indicator, or 'P.Nothing'
        --   to show no text
        -> m ()
    checkButtonSetLabel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> Maybe Text -> m ()
    checkButtonSetLabel a
    self Maybe Text
    label = 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 CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeLabel <- case label of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jLabel -> do
                jLabel' <- Text -> IO (Ptr CChar)
    textToCString Text
    jLabel
                return jLabel'
        gtk_check_button_set_label self' maybeLabel
        touchManagedPtr self
        freeMem maybeLabel
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonSetLabelMethodInfo
    instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonSetLabelMethodInfo a signature where
        overloadedMethod = checkButtonSetLabel

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

    #endif

    -- method CheckButton::set_use_underline
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckButton" }
    --           , argCType = Just "GtkCheckButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCheckButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new value to set"
    --                 , 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_check_button_set_use_underline" gtk_check_button_set_use_underline ::
        Ptr CheckButton ->                      -- self : TInterface (Name {namespace = "Gtk", name = "CheckButton"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether underlines in the label indicate mnemonics.
    --
    -- If /@setting@/ is 'P.True', an underscore character in /@self@/\'s label
    -- indicates a mnemonic accelerator key. This behavior is similar
    -- to [Label:useUnderline]("GI.Gtk.Objects.Label#g:attr:useUnderline").
    checkButtonSetUseUnderline ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckButton a) =>
        a
        -- ^ /@self@/: a @GtkCheckButton@
        -> Bool
        -- ^ /@setting@/: the new value to set
        -> m ()
    checkButtonSetUseUnderline :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckButton a) =>
    a -> Bool -> m ()
    checkButtonSetUseUnderline a
    self Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CheckButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_check_button_set_use_underline self' setting'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckButtonSetUseUnderlineMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckButton a) => O.OverloadedMethod CheckButtonSetUseUnderlineMethodInfo a signature where
        overloadedMethod = checkButtonSetUseUnderline

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

    #endif