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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Allows to enter or change numeric values.
    --
    -- \<picture>
    --   \<source srcset=\"spinbutton-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"An example GtkSpinButton\" src=\"spinbutton.png\">
    -- \<\/picture>
    --
    -- Rather than having to directly type a number into a @GtkEntry@,
    -- @GtkSpinButton@ allows the user to click on one of two arrows
    -- to increment or decrement the displayed value. A value can still be
    -- typed in, with the bonus that it can be checked to ensure it is in a
    -- given range.
    --
    -- The main properties of a @GtkSpinButton@ are through an adjustment.
    -- See the t'GI.Gtk.Objects.Adjustment.Adjustment' documentation for more details about
    -- an adjustment\'s properties.
    --
    -- Note that @GtkSpinButton@ will by default make its entry large enough
    -- to accommodate the lower and upper bounds of the adjustment. If this
    -- is not desired, the automatic sizing can be turned off by explicitly
    -- setting [Editable:widthChars]("GI.Gtk.Interfaces.Editable#g:attr:widthChars") to a value != -1.
    --
    -- == Using a GtkSpinButton to get an integer
    --
    --
    -- === /c code/
    -- >// Provides a function to retrieve an integer value from a GtkSpinButton
    -- >// and creates a spin button to model percentage values.
    -- >
    -- >int
    -- >grab_int_value (GtkSpinButton *button,
    -- >                gpointer       user_data)
    -- >{
    -- >  return gtk_spin_button_get_value_as_int (button);
    -- >}
    -- >
    -- >void
    -- >create_integer_spin_button (void)
    -- >{
    -- >
    -- >  GtkWidget *window, *button;
    -- >  GtkAdjustment *adjustment;
    -- >
    -- >  adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
    -- >
    -- >  window = gtk_window_new ();
    -- >
    -- >  // creates the spinbutton, with no decimal places
    -- >  button = gtk_spin_button_new (adjustment, 1.0, 0);
    -- >  gtk_window_set_child (GTK_WINDOW (window), button);
    -- >
    -- >  gtk_window_present (GTK_WINDOW (window));
    -- >}
    --
    --
    -- == Using a GtkSpinButton to get a floating point value
    --
    --
    -- === /c code/
    -- >// Provides a function to retrieve a floating point value from a
    -- >// GtkSpinButton, and creates a high precision spin button.
    -- >
    -- >float
    -- >grab_float_value (GtkSpinButton *button,
    -- >                  gpointer       user_data)
    -- >{
    -- >  return gtk_spin_button_get_value (button);
    -- >}
    -- >
    -- >void
    -- >create_floating_spin_button (void)
    -- >{
    -- >  GtkWidget *window, *button;
    -- >  GtkAdjustment *adjustment;
    -- >
    -- >  adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
    -- >
    -- >  window = gtk_window_new ();
    -- >
    -- >  // creates the spinbutton, with three decimal places
    -- >  button = gtk_spin_button_new (adjustment, 0.001, 3);
    -- >  gtk_window_set_child (GTK_WINDOW (window), button);
    -- >
    -- >  gtk_window_present (GTK_WINDOW (window));
    -- >}
    --
    --
    -- = Shortcuts and Gestures
    --
    -- The following signals have default keybindings:
    --
    -- * [SpinButton::changeValue]("GI.Gtk.Objects.SpinButton#g:signal:changeValue")
    --
    --
    -- = CSS nodes
    --
    --
    --
    -- >spinbutton.horizontal
    -- >├── text
    -- >│    ├── undershoot.left
    -- >│    ╰── undershoot.right
    -- >├── button.down
    -- >╰── button.up
    --
    --
    --
    --
    -- >spinbutton.vertical
    -- >├── button.up
    -- >├── text
    -- >│    ├── undershoot.left
    -- >│    ╰── undershoot.right
    -- >╰── button.down
    --
    --
    -- @GtkSpinButton@s main CSS node has the name spinbutton. It creates subnodes
    -- for the entry and the two buttons, with these names. The button nodes have
    -- the style classes .up and .down. The @GtkText@ subnodes (if present) are put
    -- below the text node. The orientation of the spin button is reflected in
    -- the .vertical or .horizontal style class on the main node.
    --
    -- = Accessibility
    --
    -- @GtkSpinButton@ uses the 'GI.Gtk.Enums.AccessibleRoleSpinButton' role.

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

    module GI.Gtk.Objects.SpinButton
        (

    -- * Exported types
        SpinButton(..)                          ,
        IsSpinButton                            ,
        toSpinButton                            ,

     -- * 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"), [configure]("GI.Gtk.Objects.SpinButton#g:method:configure"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [delegateGetAccessiblePlatformState]("GI.Gtk.Interfaces.Editable#g:method:delegateGetAccessiblePlatformState"), [deleteSelection]("GI.Gtk.Interfaces.Editable#g:method:deleteSelection"), [deleteText]("GI.Gtk.Interfaces.Editable#g:method:deleteText"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [editingDone]("GI.Gtk.Interfaces.CellEditable#g:method:editingDone"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [finishDelegate]("GI.Gtk.Interfaces.Editable#g:method:finishDelegate"), [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"), [initDelegate]("GI.Gtk.Interfaces.Editable#g:method:initDelegate"), [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"), [insertText]("GI.Gtk.Interfaces.Editable#g:method:insertText"), [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"), [removeWidget]("GI.Gtk.Interfaces.CellEditable#g:method:removeWidget"), [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"), [selectRegion]("GI.Gtk.Interfaces.Editable#g:method:selectRegion"), [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"), [spin]("GI.Gtk.Objects.SpinButton#g:method:spin"), [startEditing]("GI.Gtk.Interfaces.CellEditable#g:method:startEditing"), [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"), [update]("GI.Gtk.Objects.SpinButton#g:method:update"), [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"), [getActivatesDefault]("GI.Gtk.Objects.SpinButton#g:method:getActivatesDefault"), [getAdjustment]("GI.Gtk.Objects.SpinButton#g:method:getAdjustment"), [getAlignment]("GI.Gtk.Interfaces.Editable#g:method:getAlignment"), [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"), [getChars]("GI.Gtk.Interfaces.Editable#g:method:getChars"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClimbRate]("GI.Gtk.Objects.SpinButton#g:method:getClimbRate"), [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"), [getDelegate]("GI.Gtk.Interfaces.Editable#g:method:getDelegate"), [getDigits]("GI.Gtk.Objects.SpinButton#g:method:getDigits"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEditable]("GI.Gtk.Interfaces.Editable#g:method:getEditable"), [getEnableUndo]("GI.Gtk.Interfaces.Editable#g:method:getEnableUndo"), [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"), [getIncrements]("GI.Gtk.Objects.SpinButton#g:method:getIncrements"), [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"), [getMaxWidthChars]("GI.Gtk.Interfaces.Editable#g:method:getMaxWidthChars"), [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"), [getNumeric]("GI.Gtk.Objects.SpinButton#g:method:getNumeric"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [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"), [getPosition]("GI.Gtk.Interfaces.Editable#g:method:getPosition"), [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"), [getRange]("GI.Gtk.Objects.SpinButton#g:method:getRange"), [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"), [getSelectionBounds]("GI.Gtk.Interfaces.Editable#g:method:getSelectionBounds"), [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"), [getSnapToTicks]("GI.Gtk.Objects.SpinButton#g:method:getSnapToTicks"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getText]("GI.Gtk.Interfaces.Editable#g:method:getText"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getUpdatePolicy]("GI.Gtk.Objects.SpinButton#g:method:getUpdatePolicy"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValue]("GI.Gtk.Objects.SpinButton#g:method:getValue"), [getValueAsInt]("GI.Gtk.Objects.SpinButton#g:method:getValueAsInt"), [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"), [getWidthChars]("GI.Gtk.Interfaces.Editable#g:method:getWidthChars"), [getWrap]("GI.Gtk.Objects.SpinButton#g:method:getWrap").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setActivatesDefault]("GI.Gtk.Objects.SpinButton#g:method:setActivatesDefault"), [setAdjustment]("GI.Gtk.Objects.SpinButton#g:method:setAdjustment"), [setAlignment]("GI.Gtk.Interfaces.Editable#g:method:setAlignment"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClimbRate]("GI.Gtk.Objects.SpinButton#g:method:setClimbRate"), [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"), [setDigits]("GI.Gtk.Objects.SpinButton#g:method:setDigits"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEditable]("GI.Gtk.Interfaces.Editable#g:method:setEditable"), [setEnableUndo]("GI.Gtk.Interfaces.Editable#g:method:setEnableUndo"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setIncrements]("GI.Gtk.Objects.SpinButton#g:method:setIncrements"), [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"), [setMaxWidthChars]("GI.Gtk.Interfaces.Editable#g:method:setMaxWidthChars"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNumeric]("GI.Gtk.Objects.SpinButton#g:method:setNumeric"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPosition]("GI.Gtk.Interfaces.Editable#g:method:setPosition"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRange]("GI.Gtk.Objects.SpinButton#g:method:setRange"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setSnapToTicks]("GI.Gtk.Objects.SpinButton#g:method:setSnapToTicks"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setText]("GI.Gtk.Interfaces.Editable#g:method:setText"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setUpdatePolicy]("GI.Gtk.Objects.SpinButton#g:method:setUpdatePolicy"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setValue]("GI.Gtk.Objects.SpinButton#g:method:setValue"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setWidthChars]("GI.Gtk.Interfaces.Editable#g:method:setWidthChars"), [setWrap]("GI.Gtk.Objects.SpinButton#g:method:setWrap").

    #if defined(ENABLE_OVERLOADING)
        ResolveSpinButtonMethod                 ,
    #endif

    -- ** configure #method:configure#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonConfigureMethodInfo           ,
    #endif
        spinButtonConfigure                     ,

    -- ** getActivatesDefault #method:getActivatesDefault#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetActivatesDefaultMethodInfo ,
    #endif
        spinButtonGetActivatesDefault           ,

    -- ** getAdjustment #method:getAdjustment#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetAdjustmentMethodInfo       ,
    #endif
        spinButtonGetAdjustment                 ,

    -- ** getClimbRate #method:getClimbRate#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetClimbRateMethodInfo        ,
    #endif
        spinButtonGetClimbRate                  ,

    -- ** getDigits #method:getDigits#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetDigitsMethodInfo           ,
    #endif
        spinButtonGetDigits                     ,

    -- ** getIncrements #method:getIncrements#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetIncrementsMethodInfo       ,
    #endif
        spinButtonGetIncrements                 ,

    -- ** getNumeric #method:getNumeric#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetNumericMethodInfo          ,
    #endif
        spinButtonGetNumeric                    ,

    -- ** getRange #method:getRange#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetRangeMethodInfo            ,
    #endif
        spinButtonGetRange                      ,

    -- ** getSnapToTicks #method:getSnapToTicks#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetSnapToTicksMethodInfo      ,
    #endif
        spinButtonGetSnapToTicks                ,

    -- ** getUpdatePolicy #method:getUpdatePolicy#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetUpdatePolicyMethodInfo     ,
    #endif
        spinButtonGetUpdatePolicy               ,

    -- ** getValue #method:getValue#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetValueMethodInfo            ,
    #endif
        spinButtonGetValue                      ,

    -- ** getValueAsInt #method:getValueAsInt#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetValueAsIntMethodInfo       ,
    #endif
        spinButtonGetValueAsInt                 ,

    -- ** getWrap #method:getWrap#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonGetWrapMethodInfo             ,
    #endif
        spinButtonGetWrap                       ,

    -- ** new #method:new#

        spinButtonNew                           ,

    -- ** newWithRange #method:newWithRange#

        spinButtonNewWithRange                  ,

    -- ** setActivatesDefault #method:setActivatesDefault#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetActivatesDefaultMethodInfo ,
    #endif
        spinButtonSetActivatesDefault           ,

    -- ** setAdjustment #method:setAdjustment#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetAdjustmentMethodInfo       ,
    #endif
        spinButtonSetAdjustment                 ,

    -- ** setClimbRate #method:setClimbRate#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetClimbRateMethodInfo        ,
    #endif
        spinButtonSetClimbRate                  ,

    -- ** setDigits #method:setDigits#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetDigitsMethodInfo           ,
    #endif
        spinButtonSetDigits                     ,

    -- ** setIncrements #method:setIncrements#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetIncrementsMethodInfo       ,
    #endif
        spinButtonSetIncrements                 ,

    -- ** setNumeric #method:setNumeric#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetNumericMethodInfo          ,
    #endif
        spinButtonSetNumeric                    ,

    -- ** setRange #method:setRange#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetRangeMethodInfo            ,
    #endif
        spinButtonSetRange                      ,

    -- ** setSnapToTicks #method:setSnapToTicks#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetSnapToTicksMethodInfo      ,
    #endif
        spinButtonSetSnapToTicks                ,

    -- ** setUpdatePolicy #method:setUpdatePolicy#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetUpdatePolicyMethodInfo     ,
    #endif
        spinButtonSetUpdatePolicy               ,

    -- ** setValue #method:setValue#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetValueMethodInfo            ,
    #endif
        spinButtonSetValue                      ,

    -- ** setWrap #method:setWrap#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSetWrapMethodInfo             ,
    #endif
        spinButtonSetWrap                       ,

    -- ** spin #method:spin#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSpinMethodInfo                ,
    #endif
        spinButtonSpin                          ,

    -- ** update #method:update#

    #if defined(ENABLE_OVERLOADING)
        SpinButtonUpdateMethodInfo              ,
    #endif
        spinButtonUpdate                        ,

     -- * Properties

    -- ** activatesDefault #attr:activatesDefault#
    -- | Whether to activate the default widget when the spin button is activated.
    --
    -- See [SpinButton::activate]("GI.Gtk.Objects.SpinButton#g:signal:activate") for what counts as activation.
    --
    -- /Since: 4.14/

    #if defined(ENABLE_OVERLOADING)
        SpinButtonActivatesDefaultPropertyInfo  ,
    #endif
        constructSpinButtonActivatesDefault     ,
        getSpinButtonActivatesDefault           ,
        setSpinButtonActivatesDefault           ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonActivatesDefault              ,
    #endif

    -- ** adjustment #attr:adjustment#
    -- | The adjustment that holds the value of the spin button.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonAdjustmentPropertyInfo        ,
    #endif
        constructSpinButtonAdjustment           ,
        getSpinButtonAdjustment                 ,
        setSpinButtonAdjustment                 ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonAdjustment                    ,
    #endif

    -- ** climbRate #attr:climbRate#
    -- | The acceleration rate when you hold down a button or key.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonClimbRatePropertyInfo         ,
    #endif
        constructSpinButtonClimbRate            ,
        getSpinButtonClimbRate                  ,
        setSpinButtonClimbRate                  ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonClimbRate                     ,
    #endif

    -- ** digits #attr:digits#
    -- | The number of decimal places to display.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonDigitsPropertyInfo            ,
    #endif
        constructSpinButtonDigits               ,
        getSpinButtonDigits                     ,
        setSpinButtonDigits                     ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonDigits                        ,
    #endif

    -- ** numeric #attr:numeric#
    -- | Whether non-numeric characters should be ignored.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonNumericPropertyInfo           ,
    #endif
        constructSpinButtonNumeric              ,
        getSpinButtonNumeric                    ,
        setSpinButtonNumeric                    ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonNumeric                       ,
    #endif

    -- ** snapToTicks #attr:snapToTicks#
    -- | Whether erroneous values are automatically changed to the spin buttons
    -- nearest step increment.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonSnapToTicksPropertyInfo       ,
    #endif
        constructSpinButtonSnapToTicks          ,
        getSpinButtonSnapToTicks                ,
        setSpinButtonSnapToTicks                ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonSnapToTicks                   ,
    #endif

    -- ** updatePolicy #attr:updatePolicy#
    -- | Whether the spin button should update always, or only when the value
    -- is acceptable.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonUpdatePolicyPropertyInfo      ,
    #endif
        constructSpinButtonUpdatePolicy         ,
        getSpinButtonUpdatePolicy               ,
        setSpinButtonUpdatePolicy               ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonUpdatePolicy                  ,
    #endif

    -- ** value #attr:value#
    -- | The current value.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonValuePropertyInfo             ,
    #endif
        constructSpinButtonValue                ,
        getSpinButtonValue                      ,
        setSpinButtonValue                      ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonValue                         ,
    #endif

    -- ** wrap #attr:wrap#
    -- | Whether a spin button should wrap upon reaching its limits.

    #if defined(ENABLE_OVERLOADING)
        SpinButtonWrapPropertyInfo              ,
    #endif
        constructSpinButtonWrap                 ,
        getSpinButtonWrap                       ,
        setSpinButtonWrap                       ,
    #if defined(ENABLE_OVERLOADING)
        spinButtonWrap                          ,
    #endif

     -- * Signals

    -- ** activate #signal:activate#

        SpinButtonActivateCallback              ,
    #if defined(ENABLE_OVERLOADING)
        SpinButtonActivateSignalInfo            ,
    #endif
        afterSpinButtonActivate                 ,
        onSpinButtonActivate                    ,

    -- ** changeValue #signal:changeValue#

        SpinButtonChangeValueCallback           ,
    #if defined(ENABLE_OVERLOADING)
        SpinButtonChangeValueSignalInfo         ,
    #endif
        afterSpinButtonChangeValue              ,
        onSpinButtonChangeValue                 ,

    -- ** input #signal:input#

        SpinButtonInputCallback                 ,
    #if defined(ENABLE_OVERLOADING)
        SpinButtonInputSignalInfo               ,
    #endif
        afterSpinButtonInput                    ,
        onSpinButtonInput                       ,

    -- ** output #signal:output#

        SpinButtonOutputCallback                ,
    #if defined(ENABLE_OVERLOADING)
        SpinButtonOutputSignalInfo              ,
    #endif
        afterSpinButtonOutput                   ,
        onSpinButtonOutput                      ,

    -- ** valueChanged #signal:valueChanged#

        SpinButtonValueChangedCallback          ,
    #if defined(ENABLE_OVERLOADING)
        SpinButtonValueChangedSignalInfo        ,
    #endif
        afterSpinButtonValueChanged             ,
        onSpinButtonValueChanged                ,

    -- ** wrapped #signal:wrapped#

        SpinButtonWrappedCallback               ,
    #if defined(ENABLE_OVERLOADING)
        SpinButtonWrappedSignalInfo             ,
    #endif
        afterSpinButtonWrapped                  ,
        onSpinButtonWrapped                     ,

        ) 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.GObject.Structs.ObjectClass as GObject.ObjectClass
    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.AccessibleRange as Gtk.AccessibleRange
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
    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.Adjustment as Gtk.Adjustment
    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.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.AccessibleRange as Gtk.AccessibleRange
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

    #endif

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

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

    foreign import ccall "gtk_spin_button_get_type"
        c_gtk_spin_button_get_type :: IO B.Types.GType

    instance B.Types.TypedObject SpinButton where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_spin_button_get_type

    instance B.Types.GObject SpinButton

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

    instance O.HasParentTypes SpinButton
    type instance O.ParentTypes SpinButton = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.AccessibleRange.AccessibleRange, Gtk.Buildable.Buildable, Gtk.CellEditable.CellEditable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Editable.Editable, Gtk.Orientable.Orientable]

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSpinButtonMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveSpinButtonMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
        ResolveSpinButtonMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
        ResolveSpinButtonMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
        ResolveSpinButtonMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
        ResolveSpinButtonMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
        ResolveSpinButtonMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
        ResolveSpinButtonMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
        ResolveSpinButtonMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
        ResolveSpinButtonMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
        ResolveSpinButtonMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
        ResolveSpinButtonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSpinButtonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSpinButtonMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
        ResolveSpinButtonMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
        ResolveSpinButtonMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
        ResolveSpinButtonMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
        ResolveSpinButtonMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
        ResolveSpinButtonMethod "configure" o = SpinButtonConfigureMethodInfo
        ResolveSpinButtonMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
        ResolveSpinButtonMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
        ResolveSpinButtonMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
        ResolveSpinButtonMethod "delegateGetAccessiblePlatformState" o = Gtk.Editable.EditableDelegateGetAccessiblePlatformStateMethodInfo
        ResolveSpinButtonMethod "deleteSelection" o = Gtk.Editable.EditableDeleteSelectionMethodInfo
        ResolveSpinButtonMethod "deleteText" o = Gtk.Editable.EditableDeleteTextMethodInfo
        ResolveSpinButtonMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
        ResolveSpinButtonMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
        ResolveSpinButtonMethod "editingDone" o = Gtk.CellEditable.CellEditableEditingDoneMethodInfo
        ResolveSpinButtonMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
        ResolveSpinButtonMethod "finishDelegate" o = Gtk.Editable.EditableFinishDelegateMethodInfo
        ResolveSpinButtonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSpinButtonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSpinButtonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSpinButtonMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
        ResolveSpinButtonMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
        ResolveSpinButtonMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
        ResolveSpinButtonMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
        ResolveSpinButtonMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
        ResolveSpinButtonMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
        ResolveSpinButtonMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
        ResolveSpinButtonMethod "initDelegate" o = Gtk.Editable.EditableInitDelegateMethodInfo
        ResolveSpinButtonMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
        ResolveSpinButtonMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
        ResolveSpinButtonMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
        ResolveSpinButtonMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
        ResolveSpinButtonMethod "insertText" o = Gtk.Editable.EditableInsertTextMethodInfo
        ResolveSpinButtonMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
        ResolveSpinButtonMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
        ResolveSpinButtonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSpinButtonMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
        ResolveSpinButtonMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
        ResolveSpinButtonMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
        ResolveSpinButtonMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
        ResolveSpinButtonMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
        ResolveSpinButtonMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
        ResolveSpinButtonMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
        ResolveSpinButtonMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
        ResolveSpinButtonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSpinButtonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSpinButtonMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
        ResolveSpinButtonMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
        ResolveSpinButtonMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
        ResolveSpinButtonMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
        ResolveSpinButtonMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
        ResolveSpinButtonMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
        ResolveSpinButtonMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
        ResolveSpinButtonMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSpinButtonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSpinButtonMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
        ResolveSpinButtonMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
        ResolveSpinButtonMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
        ResolveSpinButtonMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
        ResolveSpinButtonMethod "removeWidget" o = Gtk.CellEditable.CellEditableRemoveWidgetMethodInfo
        ResolveSpinButtonMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
        ResolveSpinButtonMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
        ResolveSpinButtonMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
        ResolveSpinButtonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSpinButtonMethod "selectRegion" o = Gtk.Editable.EditableSelectRegionMethodInfo
        ResolveSpinButtonMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
        ResolveSpinButtonMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
        ResolveSpinButtonMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
        ResolveSpinButtonMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
        ResolveSpinButtonMethod "spin" o = SpinButtonSpinMethodInfo
        ResolveSpinButtonMethod "startEditing" o = Gtk.CellEditable.CellEditableStartEditingMethodInfo
        ResolveSpinButtonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSpinButtonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSpinButtonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSpinButtonMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
        ResolveSpinButtonMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
        ResolveSpinButtonMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
        ResolveSpinButtonMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
        ResolveSpinButtonMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
        ResolveSpinButtonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSpinButtonMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
        ResolveSpinButtonMethod "update" o = SpinButtonUpdateMethodInfo
        ResolveSpinButtonMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
        ResolveSpinButtonMethod "updatePlatformState" o = Gtk.Accessible.AccessibleUpdatePlatformStateMethodInfo
        ResolveSpinButtonMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
        ResolveSpinButtonMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
        ResolveSpinButtonMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
        ResolveSpinButtonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSpinButtonMethod "getAccessibleId" o = Gtk.Accessible.AccessibleGetAccessibleIdMethodInfo
        ResolveSpinButtonMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
        ResolveSpinButtonMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
        ResolveSpinButtonMethod "getActivatesDefault" o = SpinButtonGetActivatesDefaultMethodInfo
        ResolveSpinButtonMethod "getAdjustment" o = SpinButtonGetAdjustmentMethodInfo
        ResolveSpinButtonMethod "getAlignment" o = Gtk.Editable.EditableGetAlignmentMethodInfo
        ResolveSpinButtonMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
        ResolveSpinButtonMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
        ResolveSpinButtonMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
        ResolveSpinButtonMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
        ResolveSpinButtonMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
        ResolveSpinButtonMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
        ResolveSpinButtonMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
        ResolveSpinButtonMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
        ResolveSpinButtonMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
        ResolveSpinButtonMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
        ResolveSpinButtonMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
        ResolveSpinButtonMethod "getChars" o = Gtk.Editable.EditableGetCharsMethodInfo
        ResolveSpinButtonMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
        ResolveSpinButtonMethod "getClimbRate" o = SpinButtonGetClimbRateMethodInfo
        ResolveSpinButtonMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
        ResolveSpinButtonMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
        ResolveSpinButtonMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
        ResolveSpinButtonMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
        ResolveSpinButtonMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
        ResolveSpinButtonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSpinButtonMethod "getDelegate" o = Gtk.Editable.EditableGetDelegateMethodInfo
        ResolveSpinButtonMethod "getDigits" o = SpinButtonGetDigitsMethodInfo
        ResolveSpinButtonMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
        ResolveSpinButtonMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
        ResolveSpinButtonMethod "getEditable" o = Gtk.Editable.EditableGetEditableMethodInfo
        ResolveSpinButtonMethod "getEnableUndo" o = Gtk.Editable.EditableGetEnableUndoMethodInfo
        ResolveSpinButtonMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
        ResolveSpinButtonMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
        ResolveSpinButtonMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
        ResolveSpinButtonMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
        ResolveSpinButtonMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
        ResolveSpinButtonMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
        ResolveSpinButtonMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
        ResolveSpinButtonMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
        ResolveSpinButtonMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
        ResolveSpinButtonMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
        ResolveSpinButtonMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
        ResolveSpinButtonMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
        ResolveSpinButtonMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
        ResolveSpinButtonMethod "getIncrements" o = SpinButtonGetIncrementsMethodInfo
        ResolveSpinButtonMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
        ResolveSpinButtonMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
        ResolveSpinButtonMethod "getLimitEvents" o = Gtk.Widget.WidgetGetLimitEventsMethodInfo
        ResolveSpinButtonMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
        ResolveSpinButtonMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
        ResolveSpinButtonMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
        ResolveSpinButtonMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
        ResolveSpinButtonMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
        ResolveSpinButtonMethod "getMaxWidthChars" o = Gtk.Editable.EditableGetMaxWidthCharsMethodInfo
        ResolveSpinButtonMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
        ResolveSpinButtonMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
        ResolveSpinButtonMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
        ResolveSpinButtonMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
        ResolveSpinButtonMethod "getNumeric" o = SpinButtonGetNumericMethodInfo
        ResolveSpinButtonMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
        ResolveSpinButtonMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
        ResolveSpinButtonMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
        ResolveSpinButtonMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
        ResolveSpinButtonMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
        ResolveSpinButtonMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
        ResolveSpinButtonMethod "getPosition" o = Gtk.Editable.EditableGetPositionMethodInfo
        ResolveSpinButtonMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
        ResolveSpinButtonMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
        ResolveSpinButtonMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
        ResolveSpinButtonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSpinButtonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSpinButtonMethod "getRange" o = SpinButtonGetRangeMethodInfo
        ResolveSpinButtonMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
        ResolveSpinButtonMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
        ResolveSpinButtonMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
        ResolveSpinButtonMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
        ResolveSpinButtonMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
        ResolveSpinButtonMethod "getSelectionBounds" o = Gtk.Editable.EditableGetSelectionBoundsMethodInfo
        ResolveSpinButtonMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
        ResolveSpinButtonMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
        ResolveSpinButtonMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
        ResolveSpinButtonMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
        ResolveSpinButtonMethod "getSnapToTicks" o = SpinButtonGetSnapToTicksMethodInfo
        ResolveSpinButtonMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
        ResolveSpinButtonMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
        ResolveSpinButtonMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
        ResolveSpinButtonMethod "getText" o = Gtk.Editable.EditableGetTextMethodInfo
        ResolveSpinButtonMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
        ResolveSpinButtonMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
        ResolveSpinButtonMethod "getUpdatePolicy" o = SpinButtonGetUpdatePolicyMethodInfo
        ResolveSpinButtonMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
        ResolveSpinButtonMethod "getValue" o = SpinButtonGetValueMethodInfo
        ResolveSpinButtonMethod "getValueAsInt" o = SpinButtonGetValueAsIntMethodInfo
        ResolveSpinButtonMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
        ResolveSpinButtonMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
        ResolveSpinButtonMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
        ResolveSpinButtonMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
        ResolveSpinButtonMethod "getWidthChars" o = Gtk.Editable.EditableGetWidthCharsMethodInfo
        ResolveSpinButtonMethod "getWrap" o = SpinButtonGetWrapMethodInfo
        ResolveSpinButtonMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
        ResolveSpinButtonMethod "setActivatesDefault" o = SpinButtonSetActivatesDefaultMethodInfo
        ResolveSpinButtonMethod "setAdjustment" o = SpinButtonSetAdjustmentMethodInfo
        ResolveSpinButtonMethod "setAlignment" o = Gtk.Editable.EditableSetAlignmentMethodInfo
        ResolveSpinButtonMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
        ResolveSpinButtonMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
        ResolveSpinButtonMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
        ResolveSpinButtonMethod "setClimbRate" o = SpinButtonSetClimbRateMethodInfo
        ResolveSpinButtonMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
        ResolveSpinButtonMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
        ResolveSpinButtonMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
        ResolveSpinButtonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSpinButtonMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveSpinButtonMethod "setDigits" o = SpinButtonSetDigitsMethodInfo
        ResolveSpinButtonMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
        ResolveSpinButtonMethod "setEditable" o = Gtk.Editable.EditableSetEditableMethodInfo
        ResolveSpinButtonMethod "setEnableUndo" o = Gtk.Editable.EditableSetEnableUndoMethodInfo
        ResolveSpinButtonMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
        ResolveSpinButtonMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
        ResolveSpinButtonMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
        ResolveSpinButtonMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
        ResolveSpinButtonMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
        ResolveSpinButtonMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
        ResolveSpinButtonMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
        ResolveSpinButtonMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
        ResolveSpinButtonMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
        ResolveSpinButtonMethod "setIncrements" o = SpinButtonSetIncrementsMethodInfo
        ResolveSpinButtonMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
        ResolveSpinButtonMethod "setLimitEvents" o = Gtk.Widget.WidgetSetLimitEventsMethodInfo
        ResolveSpinButtonMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
        ResolveSpinButtonMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
        ResolveSpinButtonMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
        ResolveSpinButtonMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
        ResolveSpinButtonMethod "setMaxWidthChars" o = Gtk.Editable.EditableSetMaxWidthCharsMethodInfo
        ResolveSpinButtonMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
        ResolveSpinButtonMethod "setNumeric" o = SpinButtonSetNumericMethodInfo
        ResolveSpinButtonMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
        ResolveSpinButtonMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
        ResolveSpinButtonMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
        ResolveSpinButtonMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
        ResolveSpinButtonMethod "setPosition" o = Gtk.Editable.EditableSetPositionMethodInfo
        ResolveSpinButtonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSpinButtonMethod "setRange" o = SpinButtonSetRangeMethodInfo
        ResolveSpinButtonMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
        ResolveSpinButtonMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
        ResolveSpinButtonMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
        ResolveSpinButtonMethod "setSnapToTicks" o = SpinButtonSetSnapToTicksMethodInfo
        ResolveSpinButtonMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
        ResolveSpinButtonMethod "setText" o = Gtk.Editable.EditableSetTextMethodInfo
        ResolveSpinButtonMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
        ResolveSpinButtonMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
        ResolveSpinButtonMethod "setUpdatePolicy" o = SpinButtonSetUpdatePolicyMethodInfo
        ResolveSpinButtonMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
        ResolveSpinButtonMethod "setValue" o = SpinButtonSetValueMethodInfo
        ResolveSpinButtonMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
        ResolveSpinButtonMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
        ResolveSpinButtonMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
        ResolveSpinButtonMethod "setWidthChars" o = Gtk.Editable.EditableSetWidthCharsMethodInfo
        ResolveSpinButtonMethod "setWrap" o = SpinButtonSetWrapMethodInfo
        ResolveSpinButtonMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- signal SpinButton::activate
    -- | Emitted when the spin button is activated.
    --
    -- The keybindings for this signal are all forms of the \<kbd>Enter\<\/kbd> key.
    --
    -- If the \<kbd>Enter\<\/kbd> key results in the value being committed to the
    -- spin button, then activation does not occur until \<kbd>Enter\<\/kbd> is
    -- pressed again.
    --
    -- /Since: 4.14/
    type SpinButtonActivateCallback =
        IO ()

    type C_SpinButtonActivateCallback =
        Ptr SpinButton ->                       -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_SpinButtonActivateCallback ::
        GObject a => (a -> SpinButtonActivateCallback) ->
        C_SpinButtonActivateCallback
    wrap_SpinButtonActivateCallback :: forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonActivateCallback a -> IO ()
    gi'cb Ptr SpinButton
    gi'selfPtr Ptr ()
    _ = do
        Ptr SpinButton -> (SpinButton -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr SpinButton
    gi'selfPtr ((SpinButton -> IO ()) -> IO ()) -> (SpinButton -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \SpinButton
    gi'self -> a -> IO ()
    gi'cb (SpinButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SpinButton
    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' spinButton #activate callback
    -- @
    --
    --
    onSpinButtonActivate :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonActivateCallback) -> m SignalHandlerId
    onSpinButtonActivate :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onSpinButtonActivate 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_SpinButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_SpinButtonActivateCallback
    forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonActivateCallback a -> IO ()
    wrapped
        wrapped'' <- C_SpinButtonActivateCallback
    -> IO (FunPtr C_SpinButtonActivateCallback)
    mk_SpinButtonActivateCallback C_SpinButtonActivateCallback
    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' spinButton #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.
    --
    afterSpinButtonActivate :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonActivateCallback) -> m SignalHandlerId
    afterSpinButtonActivate :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterSpinButtonActivate 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_SpinButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_SpinButtonActivateCallback
    forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonActivateCallback a -> IO ()
    wrapped
        wrapped'' <- C_SpinButtonActivateCallback
    -> IO (FunPtr C_SpinButtonActivateCallback)
    mk_SpinButtonActivateCallback C_SpinButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectAfter Nothing

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

    #endif

    -- signal SpinButton::change-value
    -- | Emitted when the user initiates a value change.
    --
    -- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control the cursor
    -- programmatically.
    --
    -- The default bindings for this signal are Up\/Down and PageUp\/PageDown.
    type SpinButtonChangeValueCallback =
        Gtk.Enums.ScrollType
        -- ^ /@scroll@/: a @GtkScrollType@ to specify the speed and amount of change
        -> IO ()

    type C_SpinButtonChangeValueCallback =
        Ptr SpinButton ->                       -- object
        CUInt ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_SpinButtonChangeValueCallback ::
        GObject a => (a -> SpinButtonChangeValueCallback) ->
        C_SpinButtonChangeValueCallback
    wrap_SpinButtonChangeValueCallback :: forall a.
    GObject a =>
    (a -> SpinButtonChangeValueCallback)
    -> C_SpinButtonChangeValueCallback
    wrap_SpinButtonChangeValueCallback a -> SpinButtonChangeValueCallback
    gi'cb Ptr SpinButton
    gi'selfPtr CUInt
    scroll Ptr ()
    _ = do
        let scroll' :: ScrollType
    scroll' = (Int -> ScrollType
    forall a. Enum a => Int -> a
    toEnum (Int -> ScrollType) -> (CUInt -> Int) -> CUInt -> ScrollType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    scroll
        Ptr SpinButton -> (SpinButton -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr SpinButton
    gi'selfPtr ((SpinButton -> IO ()) -> IO ()) -> (SpinButton -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \SpinButton
    gi'self -> a -> SpinButtonChangeValueCallback
    gi'cb (SpinButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SpinButton
    gi'self)  ScrollType
    scroll'

    -- | Connect a signal handler for the [changeValue](#signal:changeValue) 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' spinButton #changeValue callback
    -- @
    --
    --
    onSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId
    onSpinButtonChangeValue :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a
    -> ((?self::a) => SpinButtonChangeValueCallback)
    -> m SignalHandlerId
    onSpinButtonChangeValue a
    obj (?self::a) => SpinButtonChangeValueCallback
    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 -> SpinButtonChangeValueCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SpinButtonChangeValueCallback
    SpinButtonChangeValueCallback
    cb
        let wrapped' :: C_SpinButtonChangeValueCallback
    wrapped' = (a -> SpinButtonChangeValueCallback)
    -> C_SpinButtonChangeValueCallback
    forall a.
    GObject a =>
    (a -> SpinButtonChangeValueCallback)
    -> C_SpinButtonChangeValueCallback
    wrap_SpinButtonChangeValueCallback a -> SpinButtonChangeValueCallback
    wrapped
        wrapped'' <- C_SpinButtonChangeValueCallback
    -> IO (FunPtr C_SpinButtonChangeValueCallback)
    mk_SpinButtonChangeValueCallback C_SpinButtonChangeValueCallback
    wrapped'
        connectSignalFunPtr obj "change-value" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [changeValue](#signal:changeValue) 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' spinButton #changeValue 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.
    --
    afterSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId
    afterSpinButtonChangeValue :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a
    -> ((?self::a) => SpinButtonChangeValueCallback)
    -> m SignalHandlerId
    afterSpinButtonChangeValue a
    obj (?self::a) => SpinButtonChangeValueCallback
    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 -> SpinButtonChangeValueCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SpinButtonChangeValueCallback
    SpinButtonChangeValueCallback
    cb
        let wrapped' :: C_SpinButtonChangeValueCallback
    wrapped' = (a -> SpinButtonChangeValueCallback)
    -> C_SpinButtonChangeValueCallback
    forall a.
    GObject a =>
    (a -> SpinButtonChangeValueCallback)
    -> C_SpinButtonChangeValueCallback
    wrap_SpinButtonChangeValueCallback a -> SpinButtonChangeValueCallback
    wrapped
        wrapped'' <- C_SpinButtonChangeValueCallback
    -> IO (FunPtr C_SpinButtonChangeValueCallback)
    mk_SpinButtonChangeValueCallback C_SpinButtonChangeValueCallback
    wrapped'
        connectSignalFunPtr obj "change-value" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonChangeValueSignalInfo
    instance SignalInfo SpinButtonChangeValueSignalInfo where
        type HaskellCallbackType SpinButtonChangeValueSignalInfo = SpinButtonChangeValueCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SpinButtonChangeValueCallback cb
            cb'' <- mk_SpinButtonChangeValueCallback cb'
            connectSignalFunPtr obj "change-value" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SpinButton::change-value"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SpinButton.html#g:signal:changeValue"})

    #endif

    -- signal SpinButton::input
    -- | Emitted to convert the users input into a double value.
    --
    -- The signal handler is expected to use 'GI.Gtk.Interfaces.Editable.editableGetText'
    -- to retrieve the text of the spinbutton and set /@newValue@/ to the
    -- new value.
    --
    -- The default conversion uses 'GI.GLib.Functions.strtod'.
    type SpinButtonInputCallback =
        IO ((Int32, Double))
        -- ^ __Returns:__ 'P.True' for a successful conversion, 'P.False' if the input
        --   was not handled, and 'GI.Gtk.Constants.INPUT_ERROR' if the conversion failed.

    type C_SpinButtonInputCallback =
        Ptr SpinButton ->                       -- object
        Ptr CDouble ->
        Ptr () ->                               -- user_data
        IO Int32

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

    wrap_SpinButtonInputCallback ::
        GObject a => (a -> SpinButtonInputCallback) ->
        C_SpinButtonInputCallback
    wrap_SpinButtonInputCallback :: forall a.
    GObject a =>
    (a -> SpinButtonInputCallback) -> C_SpinButtonInputCallback
    wrap_SpinButtonInputCallback a -> SpinButtonInputCallback
    gi'cb Ptr SpinButton
    gi'selfPtr Ptr CDouble
    newValue Ptr ()
    _ = do
        (result, outnewValue) <- Ptr SpinButton
    -> (SpinButton -> SpinButtonInputCallback)
    -> SpinButtonInputCallback
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr SpinButton
    gi'selfPtr ((SpinButton -> SpinButtonInputCallback)
     -> SpinButtonInputCallback)
    -> (SpinButton -> SpinButtonInputCallback)
    -> SpinButtonInputCallback
    forall a b. (a -> b) -> a -> b
    $ \SpinButton
    gi'self -> a -> SpinButtonInputCallback
    gi'cb (SpinButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SpinButton
    gi'self)
        let outnewValue' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    outnewValue
        poke newValue outnewValue'
        return result

    -- | Connect a signal handler for the [input](#signal:input) 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' spinButton #input callback
    -- @
    --
    --
    onSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId
    onSpinButtonInput :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => SpinButtonInputCallback) -> m SignalHandlerId
    onSpinButtonInput a
    obj (?self::a) => SpinButtonInputCallback
    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 -> SpinButtonInputCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in SpinButtonInputCallback
    (?self::a) => SpinButtonInputCallback
    cb
        let wrapped' :: C_SpinButtonInputCallback
    wrapped' = (a -> SpinButtonInputCallback) -> C_SpinButtonInputCallback
    forall a.
    GObject a =>
    (a -> SpinButtonInputCallback) -> C_SpinButtonInputCallback
    wrap_SpinButtonInputCallback a -> SpinButtonInputCallback
    wrapped
        wrapped'' <- C_SpinButtonInputCallback -> IO (FunPtr C_SpinButtonInputCallback)
    mk_SpinButtonInputCallback C_SpinButtonInputCallback
    wrapped'
        connectSignalFunPtr obj "input" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [input](#signal:input) 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' spinButton #input 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.
    --
    afterSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId
    afterSpinButtonInput :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => SpinButtonInputCallback) -> m SignalHandlerId
    afterSpinButtonInput a
    obj (?self::a) => SpinButtonInputCallback
    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 -> SpinButtonInputCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in SpinButtonInputCallback
    (?self::a) => SpinButtonInputCallback
    cb
        let wrapped' :: C_SpinButtonInputCallback
    wrapped' = (a -> SpinButtonInputCallback) -> C_SpinButtonInputCallback
    forall a.
    GObject a =>
    (a -> SpinButtonInputCallback) -> C_SpinButtonInputCallback
    wrap_SpinButtonInputCallback a -> SpinButtonInputCallback
    wrapped
        wrapped'' <- C_SpinButtonInputCallback -> IO (FunPtr C_SpinButtonInputCallback)
    mk_SpinButtonInputCallback C_SpinButtonInputCallback
    wrapped'
        connectSignalFunPtr obj "input" wrapped'' SignalConnectAfter Nothing

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

    #endif

    -- signal SpinButton::output
    -- | Emitted to tweak the formatting of the value for display.
    --
    --
    -- === /c code/
    -- >// show leading zeros
    -- >static gboolean
    -- >on_output (GtkSpinButton *spin,
    -- >           gpointer       data)
    -- >{
    -- >   char *text;
    -- >   int value;
    -- >
    -- >   value = gtk_spin_button_get_value_as_int (spin);
    -- >   text = g_strdup_printf ("%02d", value);
    -- >   gtk_editable_set_text (GTK_EDITABLE (spin), text):
    -- >   g_free (text);
    -- >
    -- >   return TRUE;
    -- >}
    type SpinButtonOutputCallback =
        IO Bool
        -- ^ __Returns:__ 'P.True' if the value has been displayed

    type C_SpinButtonOutputCallback =
        Ptr SpinButton ->                       -- object
        Ptr () ->                               -- user_data
        IO CInt

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

    wrap_SpinButtonOutputCallback ::
        GObject a => (a -> SpinButtonOutputCallback) ->
        C_SpinButtonOutputCallback
    wrap_SpinButtonOutputCallback :: forall a.
    GObject a =>
    (a -> SpinButtonOutputCallback) -> C_SpinButtonOutputCallback
    wrap_SpinButtonOutputCallback a -> SpinButtonOutputCallback
    gi'cb Ptr SpinButton
    gi'selfPtr Ptr ()
    _ = do
        result <- Ptr SpinButton
    -> (SpinButton -> SpinButtonOutputCallback)
    -> SpinButtonOutputCallback
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr SpinButton
    gi'selfPtr ((SpinButton -> SpinButtonOutputCallback)
     -> SpinButtonOutputCallback)
    -> (SpinButton -> SpinButtonOutputCallback)
    -> SpinButtonOutputCallback
    forall a b. (a -> b) -> a -> b
    $ \SpinButton
    gi'self -> a -> SpinButtonOutputCallback
    gi'cb (SpinButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SpinButton
    gi'self)
        let result' = (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
    result
        return result'

    -- | Connect a signal handler for the [output](#signal:output) 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' spinButton #output callback
    -- @
    --
    --
    onSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId
    onSpinButtonOutput :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => SpinButtonOutputCallback) -> m SignalHandlerId
    onSpinButtonOutput a
    obj (?self::a) => SpinButtonOutputCallback
    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 -> SpinButtonOutputCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in SpinButtonOutputCallback
    (?self::a) => SpinButtonOutputCallback
    cb
        let wrapped' :: C_SpinButtonOutputCallback
    wrapped' = (a -> SpinButtonOutputCallback) -> C_SpinButtonOutputCallback
    forall a.
    GObject a =>
    (a -> SpinButtonOutputCallback) -> C_SpinButtonOutputCallback
    wrap_SpinButtonOutputCallback a -> SpinButtonOutputCallback
    wrapped
        wrapped'' <- C_SpinButtonOutputCallback
    -> IO (FunPtr C_SpinButtonOutputCallback)
    mk_SpinButtonOutputCallback C_SpinButtonOutputCallback
    wrapped'
        connectSignalFunPtr obj "output" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [output](#signal:output) 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' spinButton #output 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.
    --
    afterSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId
    afterSpinButtonOutput :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => SpinButtonOutputCallback) -> m SignalHandlerId
    afterSpinButtonOutput a
    obj (?self::a) => SpinButtonOutputCallback
    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 -> SpinButtonOutputCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in SpinButtonOutputCallback
    (?self::a) => SpinButtonOutputCallback
    cb
        let wrapped' :: C_SpinButtonOutputCallback
    wrapped' = (a -> SpinButtonOutputCallback) -> C_SpinButtonOutputCallback
    forall a.
    GObject a =>
    (a -> SpinButtonOutputCallback) -> C_SpinButtonOutputCallback
    wrap_SpinButtonOutputCallback a -> SpinButtonOutputCallback
    wrapped
        wrapped'' <- C_SpinButtonOutputCallback
    -> IO (FunPtr C_SpinButtonOutputCallback)
    mk_SpinButtonOutputCallback C_SpinButtonOutputCallback
    wrapped'
        connectSignalFunPtr obj "output" wrapped'' SignalConnectAfter Nothing

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

    #endif

    -- signal SpinButton::value-changed
    -- | Emitted when the value is changed.
    --
    -- Also see the [SpinButton::output]("GI.Gtk.Objects.SpinButton#g:signal:output") signal.
    type SpinButtonValueChangedCallback =
        IO ()

    type C_SpinButtonValueChangedCallback =
        Ptr SpinButton ->                       -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_SpinButtonValueChangedCallback ::
        GObject a => (a -> SpinButtonValueChangedCallback) ->
        C_SpinButtonValueChangedCallback
    wrap_SpinButtonValueChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonValueChangedCallback a -> IO ()
    gi'cb Ptr SpinButton
    gi'selfPtr Ptr ()
    _ = do
        Ptr SpinButton -> (SpinButton -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr SpinButton
    gi'selfPtr ((SpinButton -> IO ()) -> IO ()) -> (SpinButton -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \SpinButton
    gi'self -> a -> IO ()
    gi'cb (SpinButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SpinButton
    gi'self)

    -- | Connect a signal handler for the [valueChanged](#signal:valueChanged) 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' spinButton #valueChanged callback
    -- @
    --
    --
    onSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId
    onSpinButtonValueChanged :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onSpinButtonValueChanged 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_SpinButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_SpinButtonActivateCallback
    forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonValueChangedCallback a -> IO ()
    wrapped
        wrapped'' <- C_SpinButtonActivateCallback
    -> IO (FunPtr C_SpinButtonActivateCallback)
    mk_SpinButtonValueChangedCallback C_SpinButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "value-changed" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [valueChanged](#signal:valueChanged) 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' spinButton #valueChanged 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.
    --
    afterSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId
    afterSpinButtonValueChanged :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterSpinButtonValueChanged 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_SpinButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_SpinButtonActivateCallback
    forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonValueChangedCallback a -> IO ()
    wrapped
        wrapped'' <- C_SpinButtonActivateCallback
    -> IO (FunPtr C_SpinButtonActivateCallback)
    mk_SpinButtonValueChangedCallback C_SpinButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "value-changed" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonValueChangedSignalInfo
    instance SignalInfo SpinButtonValueChangedSignalInfo where
        type HaskellCallbackType SpinButtonValueChangedSignalInfo = SpinButtonValueChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SpinButtonValueChangedCallback cb
            cb'' <- mk_SpinButtonValueChangedCallback cb'
            connectSignalFunPtr obj "value-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SpinButton::value-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SpinButton.html#g:signal:valueChanged"})

    #endif

    -- signal SpinButton::wrapped
    -- | Emitted right after the spinbutton wraps from its maximum
    -- to its minimum value or vice-versa.
    type SpinButtonWrappedCallback =
        IO ()

    type C_SpinButtonWrappedCallback =
        Ptr SpinButton ->                       -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_SpinButtonWrappedCallback ::
        GObject a => (a -> SpinButtonWrappedCallback) ->
        C_SpinButtonWrappedCallback
    wrap_SpinButtonWrappedCallback :: forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonWrappedCallback a -> IO ()
    gi'cb Ptr SpinButton
    gi'selfPtr Ptr ()
    _ = do
        Ptr SpinButton -> (SpinButton -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr SpinButton
    gi'selfPtr ((SpinButton -> IO ()) -> IO ()) -> (SpinButton -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \SpinButton
    gi'self -> a -> IO ()
    gi'cb (SpinButton -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce SpinButton
    gi'self)

    -- | Connect a signal handler for the [wrapped](#signal:wrapped) 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' spinButton #wrapped callback
    -- @
    --
    --
    onSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId
    onSpinButtonWrapped :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onSpinButtonWrapped 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_SpinButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_SpinButtonActivateCallback
    forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonWrappedCallback a -> IO ()
    wrapped
        wrapped'' <- C_SpinButtonActivateCallback
    -> IO (FunPtr C_SpinButtonActivateCallback)
    mk_SpinButtonWrappedCallback C_SpinButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "wrapped" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [wrapped](#signal:wrapped) 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' spinButton #wrapped 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.
    --
    afterSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId
    afterSpinButtonWrapped :: forall a (m :: * -> *).
    (IsSpinButton a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterSpinButtonWrapped 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_SpinButtonActivateCallback
    wrapped' = (a -> IO ()) -> C_SpinButtonActivateCallback
    forall a. GObject a => (a -> IO ()) -> C_SpinButtonActivateCallback
    wrap_SpinButtonWrappedCallback a -> IO ()
    wrapped
        wrapped'' <- C_SpinButtonActivateCallback
    -> IO (FunPtr C_SpinButtonActivateCallback)
    mk_SpinButtonWrappedCallback C_SpinButtonActivateCallback
    wrapped'
        connectSignalFunPtr obj "wrapped" wrapped'' SignalConnectAfter Nothing

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

    #endif

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonAdjustmentPropertyInfo
    instance AttrInfo SpinButtonAdjustmentPropertyInfo where
        type AttrAllowedOps SpinButtonAdjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint SpinButtonAdjustmentPropertyInfo = IsSpinButton
        type AttrSetTypeConstraint SpinButtonAdjustmentPropertyInfo = Gtk.Adjustment.IsAdjustment
        type AttrTransferTypeConstraint SpinButtonAdjustmentPropertyInfo = Gtk.Adjustment.IsAdjustment
        type AttrTransferType SpinButtonAdjustmentPropertyInfo = Gtk.Adjustment.Adjustment
        type AttrGetType SpinButtonAdjustmentPropertyInfo = Gtk.Adjustment.Adjustment
        type AttrLabel SpinButtonAdjustmentPropertyInfo = "adjustment"
        type AttrOrigin SpinButtonAdjustmentPropertyInfo = SpinButton
        attrGet = getSpinButtonAdjustment
        attrSet = setSpinButtonAdjustment
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Adjustment.Adjustment v
        attrConstruct = constructSpinButtonAdjustment
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SpinButton.adjustment"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SpinButton.html#g:attr:adjustment"
            })
    #endif

    -- VVV Prop "climb-rate"
       -- Type: TBasicType TDouble
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    -- | Set the value of the “@climb-rate@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' spinButton [ #climbRate 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()
    setSpinButtonClimbRate :: forall (m :: * -> *) o.
    (MonadIO m, IsSpinButton o) =>
    o -> Double -> m ()
    setSpinButtonClimbRate o
    obj Double
    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 -> Double -> IO ()
    forall a. GObject a => a -> String -> Double -> IO ()
    B.Properties.setObjectPropertyDouble o
    obj String
    "climb-rate" Double
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@climb-rate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSpinButtonClimbRate :: (IsSpinButton o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
    constructSpinButtonClimbRate :: forall o (m :: * -> *).
    (IsSpinButton o, MonadIO m) =>
    Double -> m (GValueConstruct o)
    constructSpinButtonClimbRate Double
    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 -> Double -> IO (GValueConstruct o)
    forall o. String -> Double -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyDouble String
    "climb-rate" Double
    val

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonClimbRatePropertyInfo
    instance AttrInfo SpinButtonClimbRatePropertyInfo where
        type AttrAllowedOps SpinButtonClimbRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SpinButtonClimbRatePropertyInfo = IsSpinButton
        type AttrSetTypeConstraint SpinButtonClimbRatePropertyInfo = (~) Double
        type AttrTransferTypeConstraint SpinButtonClimbRatePropertyInfo = (~) Double
        type AttrTransferType SpinButtonClimbRatePropertyInfo = Double
        type AttrGetType SpinButtonClimbRatePropertyInfo = Double
        type AttrLabel SpinButtonClimbRatePropertyInfo = "climb-rate"
        type AttrOrigin SpinButtonClimbRatePropertyInfo = SpinButton
        attrGet = getSpinButtonClimbRate
        attrSet = setSpinButtonClimbRate
        attrPut = setSpinButtonClimbRate
        attrTransfer _ v = do
            return v
        attrConstruct = constructSpinButtonClimbRate
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SpinButton.climbRate"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SpinButton.html#g:attr:climbRate"
            })
    #endif

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

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

    -- | Set the value of the “@digits@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' spinButton [ #digits 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> Word32 -> m ()
    setSpinButtonDigits :: forall (m :: * -> *) o.
    (MonadIO m, IsSpinButton o) =>
    o -> Word32 -> m ()
    setSpinButtonDigits o
    obj Word32
    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 -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "digits" Word32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@digits@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSpinButtonDigits :: (IsSpinButton o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
    constructSpinButtonDigits :: forall o (m :: * -> *).
    (IsSpinButton o, MonadIO m) =>
    Word32 -> m (GValueConstruct o)
    constructSpinButtonDigits Word32
    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 -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "digits" Word32
    val

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonUpdatePolicyPropertyInfo
    instance AttrInfo SpinButtonUpdatePolicyPropertyInfo where
        type AttrAllowedOps SpinButtonUpdatePolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SpinButtonUpdatePolicyPropertyInfo = IsSpinButton
        type AttrSetTypeConstraint SpinButtonUpdatePolicyPropertyInfo = (~) Gtk.Enums.SpinButtonUpdatePolicy
        type AttrTransferTypeConstraint SpinButtonUpdatePolicyPropertyInfo = (~) Gtk.Enums.SpinButtonUpdatePolicy
        type AttrTransferType SpinButtonUpdatePolicyPropertyInfo = Gtk.Enums.SpinButtonUpdatePolicy
        type AttrGetType SpinButtonUpdatePolicyPropertyInfo = Gtk.Enums.SpinButtonUpdatePolicy
        type AttrLabel SpinButtonUpdatePolicyPropertyInfo = "update-policy"
        type AttrOrigin SpinButtonUpdatePolicyPropertyInfo = SpinButton
        attrGet = getSpinButtonUpdatePolicy
        attrSet = setSpinButtonUpdatePolicy
        attrPut = setSpinButtonUpdatePolicy
        attrTransfer _ v = do
            return v
        attrConstruct = constructSpinButtonUpdatePolicy
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.SpinButton.updatePolicy"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-SpinButton.html#g:attr:updatePolicy"
            })
    #endif

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

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

    -- | Set the value of the “@value@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' spinButton [ #value 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()
    setSpinButtonValue :: forall (m :: * -> *) o.
    (MonadIO m, IsSpinButton o) =>
    o -> Double -> m ()
    setSpinButtonValue o
    obj Double
    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 -> Double -> IO ()
    forall a. GObject a => a -> String -> Double -> IO ()
    B.Properties.setObjectPropertyDouble o
    obj String
    "value" Double
    val

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList SpinButton
    type instance O.AttributeList SpinButton = SpinButtonAttributeList
    type SpinButtonAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("activatesDefault", SpinButtonActivatesDefaultPropertyInfo), '("adjustment", SpinButtonAdjustmentPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("climbRate", SpinButtonClimbRatePropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("cursorPosition", Gtk.Editable.EditableCursorPositionPropertyInfo), '("digits", SpinButtonDigitsPropertyInfo), '("editable", Gtk.Editable.EditableEditablePropertyInfo), '("editingCanceled", Gtk.CellEditable.CellEditableEditingCanceledPropertyInfo), '("enableUndo", Gtk.Editable.EditableEnableUndoPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maxWidthChars", Gtk.Editable.EditableMaxWidthCharsPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("numeric", SpinButtonNumericPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectionBound", Gtk.Editable.EditableSelectionBoundPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("snapToTicks", SpinButtonSnapToTicksPropertyInfo), '("text", Gtk.Editable.EditableTextPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("updatePolicy", SpinButtonUpdatePolicyPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("value", SpinButtonValuePropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthChars", Gtk.Editable.EditableWidthCharsPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("wrap", SpinButtonWrapPropertyInfo), '("xalign", Gtk.Editable.EditableXalignPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    spinButtonActivatesDefault :: AttrLabelProxy "activatesDefault"
    spinButtonActivatesDefault = AttrLabelProxy

    spinButtonAdjustment :: AttrLabelProxy "adjustment"
    spinButtonAdjustment = AttrLabelProxy

    spinButtonClimbRate :: AttrLabelProxy "climbRate"
    spinButtonClimbRate = AttrLabelProxy

    spinButtonDigits :: AttrLabelProxy "digits"
    spinButtonDigits = AttrLabelProxy

    spinButtonNumeric :: AttrLabelProxy "numeric"
    spinButtonNumeric = AttrLabelProxy

    spinButtonSnapToTicks :: AttrLabelProxy "snapToTicks"
    spinButtonSnapToTicks = AttrLabelProxy

    spinButtonUpdatePolicy :: AttrLabelProxy "updatePolicy"
    spinButtonUpdatePolicy = AttrLabelProxy

    spinButtonValue :: AttrLabelProxy "value"
    spinButtonValue = AttrLabelProxy

    spinButtonWrap :: AttrLabelProxy "wrap"
    spinButtonWrap = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList SpinButton = SpinButtonSignalList
    type SpinButtonSignalList = ('[ '("activate", SpinButtonActivateSignalInfo), '("changeValue", SpinButtonChangeValueSignalInfo), '("changed", Gtk.Editable.EditableChangedSignalInfo), '("deleteText", Gtk.Editable.EditableDeleteTextSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("editingDone", Gtk.CellEditable.CellEditableEditingDoneSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("input", SpinButtonInputSignalInfo), '("insertText", Gtk.Editable.EditableInsertTextSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("output", SpinButtonOutputSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("removeWidget", Gtk.CellEditable.CellEditableRemoveWidgetSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("valueChanged", SpinButtonValueChangedSignalInfo), '("wrapped", SpinButtonWrappedSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method SpinButton::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "adjustment"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Adjustment" }
    --           , argCType = Just "GtkAdjustment*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the `GtkAdjustment` that this spin button should use"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "climb_rate"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "specifies by how much the rate of change in the value will\n  accelerate if you continue to hold down an up/down button or arrow key"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "digits"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of decimal places to display"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "SpinButton" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_spin_button_new" gtk_spin_button_new ::
        Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
        CDouble ->                              -- climb_rate : TBasicType TDouble
        Word32 ->                               -- digits : TBasicType TUInt
        IO (Ptr SpinButton)

    -- | Creates a new @GtkSpinButton@.
    spinButtonNew ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.Adjustment.IsAdjustment a) =>
        Maybe (a)
        -- ^ /@adjustment@/: the @GtkAdjustment@ that this spin button should use
        -> Double
        -- ^ /@climbRate@/: specifies by how much the rate of change in the value will
        --   accelerate if you continue to hold down an up\/down button or arrow key
        -> Word32
        -- ^ /@digits@/: the number of decimal places to display
        -> m SpinButton
        -- ^ __Returns:__ The new @GtkSpinButton@
    spinButtonNew :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsAdjustment a) =>
    Maybe a -> Double -> Word32 -> m SpinButton
    spinButtonNew Maybe a
    adjustment Double
    climbRate Word32
    digits = IO SpinButton -> m SpinButton
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SpinButton -> m SpinButton) -> IO SpinButton -> m SpinButton
    forall a b. (a -> b) -> a -> b
    $ do
        maybeAdjustment <- case Maybe a
    adjustment of
            Maybe a
    Nothing -> Ptr Adjustment -> IO (Ptr Adjustment)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Adjustment
    forall a. Ptr a
    FP.nullPtr
            Just a
    jAdjustment -> do
                jAdjustment' <- a -> IO (Ptr Adjustment)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jAdjustment
                return jAdjustment'
        let climbRate' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    climbRate
        result <- gtk_spin_button_new maybeAdjustment climbRate' digits
        checkUnexpectedReturnNULL "spinButtonNew" result
        result' <- (newObject SpinButton) result
        whenJust adjustment touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method SpinButton::new_with_range
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "min"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Minimum allowable value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "max"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Maximum allowable value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "step"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "Increment added or subtracted by spinning the widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "SpinButton" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_spin_button_new_with_range" gtk_spin_button_new_with_range ::
        CDouble ->                              -- min : TBasicType TDouble
        CDouble ->                              -- max : TBasicType TDouble
        CDouble ->                              -- step : TBasicType TDouble
        IO (Ptr SpinButton)

    -- | Creates a new @GtkSpinButton@ with the given properties.
    --
    -- This is a convenience constructor that allows creation
    -- of a numeric @GtkSpinButton@ without manually creating
    -- an adjustment. The value is initially set to the minimum
    -- value and a page increment of 10 * /@step@/ is the default.
    -- The precision of the spin button is equivalent to the
    -- precision of /@step@/.
    --
    -- Note that the way in which the precision is derived works
    -- best if /@step@/ is a power of ten. If the resulting precision
    -- is not suitable for your needs, use
    -- 'GI.Gtk.Objects.SpinButton.spinButtonSetDigits' to correct it.
    spinButtonNewWithRange ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Double
        -- ^ /@min@/: Minimum allowable value
        -> Double
        -- ^ /@max@/: Maximum allowable value
        -> Double
        -- ^ /@step@/: Increment added or subtracted by spinning the widget
        -> m SpinButton
        -- ^ __Returns:__ The new @GtkSpinButton@
    spinButtonNewWithRange :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Double -> Double -> Double -> m SpinButton
    spinButtonNewWithRange Double
    min Double
    max Double
    step = IO SpinButton -> m SpinButton
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SpinButton -> m SpinButton) -> IO SpinButton -> m SpinButton
    forall a b. (a -> b) -> a -> b
    $ do
        let min' :: CDouble
    min' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    min
        let max' :: CDouble
    max' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    max
        let step' :: CDouble
    step' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    step
        result <- CDouble -> CDouble -> CDouble -> IO (Ptr SpinButton)
    gtk_spin_button_new_with_range CDouble
    min' CDouble
    max' CDouble
    step'
        checkUnexpectedReturnNULL "spinButtonNewWithRange" result
        result' <- (newObject SpinButton) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method SpinButton::configure
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "adjustment"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Adjustment" }
    --           , argCType = Just "GtkAdjustment*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a `GtkAdjustment` to replace the spin button\8217s\n  existing adjustment, or %NULL to leave its current adjustment unchanged"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "climb_rate"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new climb rate" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "digits"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the number of decimal places to display in the spin button"
    --                 , 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_spin_button_configure" gtk_spin_button_configure ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
        CDouble ->                              -- climb_rate : TBasicType TDouble
        Word32 ->                               -- digits : TBasicType TUInt
        IO ()

    -- | Changes the properties of an existing spin button.
    --
    -- The adjustment, climb rate, and number of decimal places
    -- are updated accordingly.
    spinButtonConfigure ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a, Gtk.Adjustment.IsAdjustment b) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Maybe (b)
        -- ^ /@adjustment@/: a @GtkAdjustment@ to replace the spin button’s
        --   existing adjustment, or 'P.Nothing' to leave its current adjustment unchanged
        -> Double
        -- ^ /@climbRate@/: the new climb rate
        -> Word32
        -- ^ /@digits@/: the number of decimal places to display in the spin button
        -> m ()
    spinButtonConfigure :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) =>
    a -> Maybe b -> Double -> Word32 -> m ()
    spinButtonConfigure a
    spinButton Maybe b
    adjustment Double
    climbRate Word32
    digits = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        maybeAdjustment <- case adjustment of
            Maybe b
    Nothing -> Ptr Adjustment -> IO (Ptr Adjustment)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Adjustment
    forall a. Ptr a
    FP.nullPtr
            Just b
    jAdjustment -> do
                jAdjustment' <- b -> IO (Ptr Adjustment)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jAdjustment
                return jAdjustment'
        let climbRate' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    climbRate
        gtk_spin_button_configure spinButton' maybeAdjustment climbRate' digits
        touchManagedPtr spinButton
        whenJust adjustment touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonConfigureMethodInfo
    instance (signature ~ (Maybe (b) -> Double -> Word32 -> m ()), MonadIO m, IsSpinButton a, Gtk.Adjustment.IsAdjustment b) => O.OverloadedMethod SpinButtonConfigureMethodInfo a signature where
        overloadedMethod = spinButtonConfigure

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

    #endif

    -- method SpinButton::get_activates_default
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , 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_spin_button_get_activates_default" gtk_spin_button_get_activates_default ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CInt

    -- | Retrieves the value set by 'GI.Gtk.Objects.SpinButton.spinButtonSetActivatesDefault'.
    --
    -- /Since: 4.14/
    spinButtonGetActivatesDefault ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the spin button will activate the default widget
    spinButtonGetActivatesDefault :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Bool
    spinButtonGetActivatesDefault a
    spinButton = SpinButtonOutputCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (SpinButtonOutputCallback -> m Bool)
    -> SpinButtonOutputCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_activates_default spinButton'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetActivatesDefaultMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetActivatesDefaultMethodInfo a signature where
        overloadedMethod = spinButtonGetActivatesDefault

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

    #endif

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

    foreign import ccall "gtk_spin_button_get_adjustment" gtk_spin_button_get_adjustment ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO (Ptr Gtk.Adjustment.Adjustment)

    -- | Get the adjustment associated with a @GtkSpinButton@.
    spinButtonGetAdjustment ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Gtk.Adjustment.Adjustment
        -- ^ __Returns:__ the @GtkAdjustment@ of /@spinButton@/
    spinButtonGetAdjustment :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Adjustment
    spinButtonGetAdjustment a
    spinButton = IO Adjustment -> m Adjustment
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Adjustment -> m Adjustment) -> IO Adjustment -> m Adjustment
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_adjustment spinButton'
        checkUnexpectedReturnNULL "spinButtonGetAdjustment" result
        result' <- (newObject Gtk.Adjustment.Adjustment) result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetAdjustmentMethodInfo
    instance (signature ~ (m Gtk.Adjustment.Adjustment), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetAdjustmentMethodInfo a signature where
        overloadedMethod = spinButtonGetAdjustment

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

    #endif

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

    foreign import ccall "gtk_spin_button_get_climb_rate" gtk_spin_button_get_climb_rate ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CDouble

    -- | Returns the acceleration rate for repeated changes.
    spinButtonGetClimbRate ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Double
        -- ^ __Returns:__ the acceleration rate
    spinButtonGetClimbRate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Double
    spinButtonGetClimbRate a
    spinButton = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_climb_rate spinButton'
        let result' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetClimbRateMethodInfo
    instance (signature ~ (m Double), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetClimbRateMethodInfo a signature where
        overloadedMethod = spinButtonGetClimbRate

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

    #endif

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

    foreign import ccall "gtk_spin_button_get_digits" gtk_spin_button_get_digits ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO Word32

    -- | Fetches the precision of /@spinButton@/.
    spinButtonGetDigits ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Word32
        -- ^ __Returns:__ the current precision
    spinButtonGetDigits :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Word32
    spinButtonGetDigits a
    spinButton = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_digits spinButton'
        touchManagedPtr spinButton
        return result

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetDigitsMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetDigitsMethodInfo a signature where
        overloadedMethod = spinButtonGetDigits

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

    #endif

    -- method SpinButton::get_increments
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "step"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store step increment"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "page"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store page increment"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_spin_button_get_increments" gtk_spin_button_get_increments ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        Ptr CDouble ->                          -- step : TBasicType TDouble
        Ptr CDouble ->                          -- page : TBasicType TDouble
        IO ()

    -- | Gets the current step and page the increments
    -- used by /@spinButton@/.
    --
    -- See 'GI.Gtk.Objects.SpinButton.spinButtonSetIncrements'.
    spinButtonGetIncrements ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m ((Double, Double))
    spinButtonGetIncrements :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m (Double, Double)
    spinButtonGetIncrements a
    spinButton = IO (Double, Double) -> m (Double, Double)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Double, Double) -> m (Double, Double))
    -> IO (Double, Double) -> m (Double, Double)
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        step <- allocMem :: IO (Ptr CDouble)
        page <- allocMem :: IO (Ptr CDouble)
        gtk_spin_button_get_increments spinButton' step page
        step' <- peek step
        let step'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    step'
        page' <- peek page
        let page'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    page'
        touchManagedPtr spinButton
        freeMem step
        freeMem page
        return (step'', page'')

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetIncrementsMethodInfo
    instance (signature ~ (m ((Double, Double))), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetIncrementsMethodInfo a signature where
        overloadedMethod = spinButtonGetIncrements

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

    #endif

    -- method SpinButton::get_numeric
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , 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_spin_button_get_numeric" gtk_spin_button_get_numeric ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CInt

    -- | Returns whether non-numeric text can be typed into the spin button.
    spinButtonGetNumeric ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if only numeric text can be entered
    spinButtonGetNumeric :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Bool
    spinButtonGetNumeric a
    spinButton = SpinButtonOutputCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (SpinButtonOutputCallback -> m Bool)
    -> SpinButtonOutputCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_numeric spinButton'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetNumericMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetNumericMethodInfo a signature where
        overloadedMethod = spinButtonGetNumeric

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

    #endif

    -- method SpinButton::get_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store minimum allowed value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "max"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store maximum allowed value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_spin_button_get_range" gtk_spin_button_get_range ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        Ptr CDouble ->                          -- min : TBasicType TDouble
        Ptr CDouble ->                          -- max : TBasicType TDouble
        IO ()

    -- | Gets the range allowed for /@spinButton@/.
    --
    -- See 'GI.Gtk.Objects.SpinButton.spinButtonSetRange'.
    spinButtonGetRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m ((Double, Double))
    spinButtonGetRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m (Double, Double)
    spinButtonGetRange a
    spinButton = IO (Double, Double) -> m (Double, Double)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Double, Double) -> m (Double, Double))
    -> IO (Double, Double) -> m (Double, Double)
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        min <- allocMem :: IO (Ptr CDouble)
        max <- allocMem :: IO (Ptr CDouble)
        gtk_spin_button_get_range spinButton' min max
        min' <- peek min
        let min'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    min'
        max' <- peek max
        let max'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    max'
        touchManagedPtr spinButton
        freeMem min
        freeMem max
        return (min'', max'')

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetRangeMethodInfo
    instance (signature ~ (m ((Double, Double))), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetRangeMethodInfo a signature where
        overloadedMethod = spinButtonGetRange

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

    #endif

    -- method SpinButton::get_snap_to_ticks
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , 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_spin_button_get_snap_to_ticks" gtk_spin_button_get_snap_to_ticks ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CInt

    -- | Returns whether the values are corrected to the nearest step.
    spinButtonGetSnapToTicks ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if values are snapped to the nearest step
    spinButtonGetSnapToTicks :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Bool
    spinButtonGetSnapToTicks a
    spinButton = SpinButtonOutputCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (SpinButtonOutputCallback -> m Bool)
    -> SpinButtonOutputCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_snap_to_ticks spinButton'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetSnapToTicksMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetSnapToTicksMethodInfo a signature where
        overloadedMethod = spinButtonGetSnapToTicks

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

    #endif

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

    foreign import ccall "gtk_spin_button_get_update_policy" gtk_spin_button_get_update_policy ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CUInt

    -- | Gets the update behavior of a spin button.
    --
    -- See 'GI.Gtk.Objects.SpinButton.spinButtonSetUpdatePolicy'.
    spinButtonGetUpdatePolicy ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Gtk.Enums.SpinButtonUpdatePolicy
        -- ^ __Returns:__ the current update policy
    spinButtonGetUpdatePolicy :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m SpinButtonUpdatePolicy
    spinButtonGetUpdatePolicy a
    spinButton = IO SpinButtonUpdatePolicy -> m SpinButtonUpdatePolicy
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SpinButtonUpdatePolicy -> m SpinButtonUpdatePolicy)
    -> IO SpinButtonUpdatePolicy -> m SpinButtonUpdatePolicy
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_update_policy spinButton'
        let result' = (Int -> SpinButtonUpdatePolicy
    forall a. Enum a => Int -> a
    toEnum (Int -> SpinButtonUpdatePolicy)
    -> (CUInt -> Int) -> CUInt -> SpinButtonUpdatePolicy
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetUpdatePolicyMethodInfo
    instance (signature ~ (m Gtk.Enums.SpinButtonUpdatePolicy), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetUpdatePolicyMethodInfo a signature where
        overloadedMethod = spinButtonGetUpdatePolicy

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

    #endif

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

    foreign import ccall "gtk_spin_button_get_value" gtk_spin_button_get_value ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CDouble

    -- | Get the value in the /@spinButton@/.
    spinButtonGetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Double
        -- ^ __Returns:__ the value of /@spinButton@/
    spinButtonGetValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Double
    spinButtonGetValue a
    spinButton = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_value spinButton'
        let result' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetValueMethodInfo
    instance (signature ~ (m Double), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetValueMethodInfo a signature where
        overloadedMethod = spinButtonGetValue

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

    #endif

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

    foreign import ccall "gtk_spin_button_get_value_as_int" gtk_spin_button_get_value_as_int ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO Int32

    -- | Get the value /@spinButton@/ represented as an integer.
    spinButtonGetValueAsInt ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Int32
        -- ^ __Returns:__ the value of /@spinButton@/
    spinButtonGetValueAsInt :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Int32
    spinButtonGetValueAsInt a
    spinButton = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_value_as_int spinButton'
        touchManagedPtr spinButton
        return result

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetValueAsIntMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetValueAsIntMethodInfo a signature where
        overloadedMethod = spinButtonGetValueAsInt

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

    #endif

    -- method SpinButton::get_wrap
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , 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_spin_button_get_wrap" gtk_spin_button_get_wrap ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO CInt

    -- | Returns whether the spin button’s value wraps around to the
    -- opposite limit when the upper or lower limit of the range is
    -- exceeded.
    spinButtonGetWrap ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the spin button wraps around
    spinButtonGetWrap :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m Bool
    spinButtonGetWrap a
    spinButton = SpinButtonOutputCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (SpinButtonOutputCallback -> m Bool)
    -> SpinButtonOutputCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        result <- gtk_spin_button_get_wrap spinButton'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr spinButton
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonGetWrapMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonGetWrapMethodInfo a signature where
        overloadedMethod = spinButtonGetWrap

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

    #endif

    -- method SpinButton::set_activates_default
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "activates_default"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE to activate window\8217s default widget on activation"
    --                 , 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_spin_button_set_activates_default" gtk_spin_button_set_activates_default ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CInt ->                                 -- activates_default : TBasicType TBoolean
        IO ()

    -- | Sets whether activating the spin button will activate the default
    -- widget for the window containing the spin button.
    --
    -- See [SpinButton::activate]("GI.Gtk.Objects.SpinButton#g:signal:activate") for what counts as activation.
    --
    -- /Since: 4.14/
    spinButtonSetActivatesDefault ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Bool
        -- ^ /@activatesDefault@/: 'P.True' to activate window’s default widget on activation
        -> m ()
    spinButtonSetActivatesDefault :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Bool -> m ()
    spinButtonSetActivatesDefault a
    spinButton Bool
    activatesDefault = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let activatesDefault' = (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
    activatesDefault
        gtk_spin_button_set_activates_default spinButton' activatesDefault'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetActivatesDefaultMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetActivatesDefaultMethodInfo a signature where
        overloadedMethod = spinButtonSetActivatesDefault

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

    #endif

    -- method SpinButton::set_adjustment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "adjustment"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Adjustment" }
    --           , argCType = Just "GtkAdjustment*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a `GtkAdjustment` to replace the existing adjustment"
    --                 , 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_spin_button_set_adjustment" gtk_spin_button_set_adjustment ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
        IO ()

    -- | Replaces the @GtkAdjustment@ associated with /@spinButton@/.
    spinButtonSetAdjustment ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a, Gtk.Adjustment.IsAdjustment b) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> b
        -- ^ /@adjustment@/: a @GtkAdjustment@ to replace the existing adjustment
        -> m ()
    spinButtonSetAdjustment :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) =>
    a -> b -> m ()
    spinButtonSetAdjustment a
    spinButton b
    adjustment = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        adjustment' <- unsafeManagedPtrCastPtr adjustment
        gtk_spin_button_set_adjustment spinButton' adjustment'
        touchManagedPtr spinButton
        touchManagedPtr adjustment
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetAdjustmentMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsSpinButton a, Gtk.Adjustment.IsAdjustment b) => O.OverloadedMethod SpinButtonSetAdjustmentMethodInfo a signature where
        overloadedMethod = spinButtonSetAdjustment

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

    #endif

    -- method SpinButton::set_climb_rate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "climb_rate"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the rate of acceleration, must be >= 0"
    --                 , 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_spin_button_set_climb_rate" gtk_spin_button_set_climb_rate ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CDouble ->                              -- climb_rate : TBasicType TDouble
        IO ()

    -- | Sets the acceleration rate for repeated changes when you
    -- hold down a button or key.
    spinButtonSetClimbRate ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Double
        -- ^ /@climbRate@/: the rate of acceleration, must be >= 0
        -> m ()
    spinButtonSetClimbRate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Double -> m ()
    spinButtonSetClimbRate a
    spinButton Double
    climbRate = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let climbRate' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    climbRate
        gtk_spin_button_set_climb_rate spinButton' climbRate'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetClimbRateMethodInfo
    instance (signature ~ (Double -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetClimbRateMethodInfo a signature where
        overloadedMethod = spinButtonSetClimbRate

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

    #endif

    -- method SpinButton::set_digits
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "digits"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the number of digits after the decimal point to be\n  displayed for the spin button\8217s value"
    --                 , 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_spin_button_set_digits" gtk_spin_button_set_digits ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        Word32 ->                               -- digits : TBasicType TUInt
        IO ()

    -- | Set the precision to be displayed by /@spinButton@/.
    --
    -- Up to 20 digit precision is allowed.
    spinButtonSetDigits ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Word32
        -- ^ /@digits@/: the number of digits after the decimal point to be
        --   displayed for the spin button’s value
        -> m ()
    spinButtonSetDigits :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Word32 -> m ()
    spinButtonSetDigits a
    spinButton Word32
    digits = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        gtk_spin_button_set_digits spinButton' digits
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetDigitsMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetDigitsMethodInfo a signature where
        overloadedMethod = spinButtonSetDigits

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

    #endif

    -- method SpinButton::set_increments
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "step"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "increment applied for a button 1 press."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "page"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "increment applied for a button 2 press."
    --                 , 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_spin_button_set_increments" gtk_spin_button_set_increments ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CDouble ->                              -- step : TBasicType TDouble
        CDouble ->                              -- page : TBasicType TDouble
        IO ()

    -- | Sets the step and page increments for spin_button.
    --
    -- This affects how quickly the value changes when
    -- the spin button’s arrows are activated.
    spinButtonSetIncrements ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Double
        -- ^ /@step@/: increment applied for a button 1 press.
        -> Double
        -- ^ /@page@/: increment applied for a button 2 press.
        -> m ()
    spinButtonSetIncrements :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Double -> Double -> m ()
    spinButtonSetIncrements a
    spinButton Double
    step Double
    page = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let step' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    step
        let page' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    page
        gtk_spin_button_set_increments spinButton' step' page'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetIncrementsMethodInfo
    instance (signature ~ (Double -> Double -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetIncrementsMethodInfo a signature where
        overloadedMethod = spinButtonSetIncrements

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

    #endif

    -- method SpinButton::set_numeric
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "numeric"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "flag indicating if only numeric entry is allowed"
    --                 , 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_spin_button_set_numeric" gtk_spin_button_set_numeric ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CInt ->                                 -- numeric : TBasicType TBoolean
        IO ()

    -- | Sets the flag that determines if non-numeric text can be typed
    -- into the spin button.
    spinButtonSetNumeric ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Bool
        -- ^ /@numeric@/: flag indicating if only numeric entry is allowed
        -> m ()
    spinButtonSetNumeric :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Bool -> m ()
    spinButtonSetNumeric a
    spinButton Bool
    numeric = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let numeric' = (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
    numeric
        gtk_spin_button_set_numeric spinButton' numeric'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetNumericMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetNumericMethodInfo a signature where
        overloadedMethod = spinButtonSetNumeric

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

    #endif

    -- method SpinButton::set_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "minimum allowable value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "max"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "maximum allowable value"
    --                 , 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_spin_button_set_range" gtk_spin_button_set_range ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CDouble ->                              -- min : TBasicType TDouble
        CDouble ->                              -- max : TBasicType TDouble
        IO ()

    -- | Sets the minimum and maximum allowable values for /@spinButton@/.
    --
    -- If the current value is outside this range, it will be adjusted
    -- to fit within the range, otherwise it will remain unchanged.
    spinButtonSetRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Double
        -- ^ /@min@/: minimum allowable value
        -> Double
        -- ^ /@max@/: maximum allowable value
        -> m ()
    spinButtonSetRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Double -> Double -> m ()
    spinButtonSetRange a
    spinButton Double
    min Double
    max = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let min' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    min
        let max' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    max
        gtk_spin_button_set_range spinButton' min' max'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetRangeMethodInfo
    instance (signature ~ (Double -> Double -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetRangeMethodInfo a signature where
        overloadedMethod = spinButtonSetRange

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

    #endif

    -- method SpinButton::set_snap_to_ticks
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "snap_to_ticks"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a flag indicating if invalid values should be corrected"
    --                 , 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_spin_button_set_snap_to_ticks" gtk_spin_button_set_snap_to_ticks ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CInt ->                                 -- snap_to_ticks : TBasicType TBoolean
        IO ()

    -- | Sets the policy as to whether values are corrected to the
    -- nearest step increment when a spin button is activated after
    -- providing an invalid value.
    spinButtonSetSnapToTicks ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Bool
        -- ^ /@snapToTicks@/: a flag indicating if invalid values should be corrected
        -> m ()
    spinButtonSetSnapToTicks :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Bool -> m ()
    spinButtonSetSnapToTicks a
    spinButton Bool
    snapToTicks = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let snapToTicks' = (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
    snapToTicks
        gtk_spin_button_set_snap_to_ticks spinButton' snapToTicks'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetSnapToTicksMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetSnapToTicksMethodInfo a signature where
        overloadedMethod = spinButtonSetSnapToTicks

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

    #endif

    -- method SpinButton::set_update_policy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "policy"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "SpinButtonUpdatePolicy" }
    --           , argCType = Just "GtkSpinButtonUpdatePolicy"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButtonUpdatePolicy` value"
    --                 , 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_spin_button_set_update_policy" gtk_spin_button_set_update_policy ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CUInt ->                                -- policy : TInterface (Name {namespace = "Gtk", name = "SpinButtonUpdatePolicy"})
        IO ()

    -- | Sets the update behavior of a spin button.
    --
    -- This determines whether the spin button is always
    -- updated or only when a valid value is set.
    spinButtonSetUpdatePolicy ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Gtk.Enums.SpinButtonUpdatePolicy
        -- ^ /@policy@/: a @GtkSpinButtonUpdatePolicy@ value
        -> m ()
    spinButtonSetUpdatePolicy :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> SpinButtonUpdatePolicy -> m ()
    spinButtonSetUpdatePolicy a
    spinButton SpinButtonUpdatePolicy
    policy = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let policy' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (SpinButtonUpdatePolicy -> Int)
    -> SpinButtonUpdatePolicy
    -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SpinButtonUpdatePolicy -> Int
    forall a. Enum a => a -> Int
    fromEnum) SpinButtonUpdatePolicy
    policy
        gtk_spin_button_set_update_policy spinButton' policy'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetUpdatePolicyMethodInfo
    instance (signature ~ (Gtk.Enums.SpinButtonUpdatePolicy -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetUpdatePolicyMethodInfo a signature where
        overloadedMethod = spinButtonSetUpdatePolicy

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

    #endif

    -- method SpinButton::set_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new value" , 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_spin_button_set_value" gtk_spin_button_set_value ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CDouble ->                              -- value : TBasicType TDouble
        IO ()

    -- | Sets the value of /@spinButton@/.
    spinButtonSetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Double
        -- ^ /@value@/: the new value
        -> m ()
    spinButtonSetValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Double -> m ()
    spinButtonSetValue a
    spinButton Double
    value = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let value' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    value
        gtk_spin_button_set_value spinButton' value'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetValueMethodInfo
    instance (signature ~ (Double -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetValueMethodInfo a signature where
        overloadedMethod = spinButtonSetValue

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

    #endif

    -- method SpinButton::set_wrap
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "wrap"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a flag indicating if wrapping behavior is performed"
    --                 , 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_spin_button_set_wrap" gtk_spin_button_set_wrap ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CInt ->                                 -- wrap : TBasicType TBoolean
        IO ()

    -- | Sets the flag that determines if a spin button value wraps
    -- around to the opposite limit when the upper or lower limit
    -- of the range is exceeded.
    spinButtonSetWrap ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Bool
        -- ^ /@wrap@/: a flag indicating if wrapping behavior is performed
        -> m ()
    spinButtonSetWrap :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> Bool -> m ()
    spinButtonSetWrap a
    spinButton Bool
    wrap = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let wrap' = (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
    wrap
        gtk_spin_button_set_wrap spinButton' wrap'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSetWrapMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSetWrapMethodInfo a signature where
        overloadedMethod = spinButtonSetWrap

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

    #endif

    -- method SpinButton::spin
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "direction"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinType" }
    --           , argCType = Just "GtkSpinType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a `GtkSpinType` indicating the direction to spin"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "increment"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "step increment to apply in the specified direction"
    --                 , 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_spin_button_spin" gtk_spin_button_spin ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        CUInt ->                                -- direction : TInterface (Name {namespace = "Gtk", name = "SpinType"})
        CDouble ->                              -- increment : TBasicType TDouble
        IO ()

    -- | Increment or decrement a spin button’s value in a specified
    -- direction by a specified amount.
    spinButtonSpin ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> Gtk.Enums.SpinType
        -- ^ /@direction@/: a @GtkSpinType@ indicating the direction to spin
        -> Double
        -- ^ /@increment@/: step increment to apply in the specified direction
        -> m ()
    spinButtonSpin :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> SpinType -> Double -> m ()
    spinButtonSpin a
    spinButton SpinType
    direction Double
    increment = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        let direction' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (SpinType -> Int) -> SpinType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SpinType -> Int
    forall a. Enum a => a -> Int
    fromEnum) SpinType
    direction
        let increment' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    increment
        gtk_spin_button_spin spinButton' direction' increment'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonSpinMethodInfo
    instance (signature ~ (Gtk.Enums.SpinType -> Double -> m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonSpinMethodInfo a signature where
        overloadedMethod = spinButtonSpin

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

    #endif

    -- method SpinButton::update
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "spin_button"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SpinButton" }
    --           , argCType = Just "GtkSpinButton*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkSpinButton`" , 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_spin_button_update" gtk_spin_button_update ::
        Ptr SpinButton ->                       -- spin_button : TInterface (Name {namespace = "Gtk", name = "SpinButton"})
        IO ()

    -- | Manually force an update of the spin button.
    spinButtonUpdate ::
        (B.CallStack.HasCallStack, MonadIO m, IsSpinButton a) =>
        a
        -- ^ /@spinButton@/: a @GtkSpinButton@
        -> m ()
    spinButtonUpdate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSpinButton a) =>
    a -> m ()
    spinButtonUpdate a
    spinButton = 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
        spinButton' <- a -> IO (Ptr SpinButton)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    spinButton
        gtk_spin_button_update spinButton'
        touchManagedPtr spinButton
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SpinButtonUpdateMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSpinButton a) => O.OverloadedMethod SpinButtonUpdateMethodInfo a signature where
        overloadedMethod = spinButtonUpdate

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

    #endif