    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Shows text in a predefined area.
    --
    -- You likely want to use @GtkLabel@ instead as this widget is intended only
    -- for a small subset of use cases. The main scenario envisaged is inside lists
    -- such as @GtkColumnView@.
    --
    -- While a @GtkLabel@ sizes itself depending on the text that is displayed,
    -- @GtkInscription@ is given a size and inscribes the given text into that
    -- space as well as it can.
    --
    -- Users of this widget should take care to plan behaviour for the common case
    -- where the text doesn\'t fit exactly in the allocated space.
    --
    -- == CSS nodes
    --
    -- @GtkInscription@ has a single CSS node with the name label.
    --
    -- /Since: 4.8/

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

    module GI.Gtk.Objects.Inscription
        (

    -- * Exported types
        Inscription(..)                         ,
        IsInscription                           ,
        toInscription                           ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateCaretPosition]("GI.Gtk.Interfaces.AccessibleText#g:method:updateCaretPosition"), [updateContents]("GI.Gtk.Interfaces.AccessibleText#g:method:updateContents"), [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"), [updateSelectionBound]("GI.Gtk.Interfaces.AccessibleText#g:method:updateSelectionBound"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAccessibleId]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleId"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getAttributes]("GI.Gtk.Objects.Inscription#g:method:getAttributes"), [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"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [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"), [getMinChars]("GI.Gtk.Objects.Inscription#g:method:getMinChars"), [getMinLines]("GI.Gtk.Objects.Inscription#g:method:getMinLines"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNatChars]("GI.Gtk.Objects.Inscription#g:method:getNatChars"), [getNatLines]("GI.Gtk.Objects.Inscription#g:method:getNatLines"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getText]("GI.Gtk.Objects.Inscription#g:method:getText"), [getTextOverflow]("GI.Gtk.Objects.Inscription#g:method:getTextOverflow"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getWrapMode]("GI.Gtk.Objects.Inscription#g:method:getWrapMode"), [getXalign]("GI.Gtk.Objects.Inscription#g:method:getXalign"), [getYalign]("GI.Gtk.Objects.Inscription#g:method:getYalign").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setAttributes]("GI.Gtk.Objects.Inscription#g:method:setAttributes"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [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"), [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"), [setMarkup]("GI.Gtk.Objects.Inscription#g:method:setMarkup"), [setMinChars]("GI.Gtk.Objects.Inscription#g:method:setMinChars"), [setMinLines]("GI.Gtk.Objects.Inscription#g:method:setMinLines"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNatChars]("GI.Gtk.Objects.Inscription#g:method:setNatChars"), [setNatLines]("GI.Gtk.Objects.Inscription#g:method:setNatLines"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setText]("GI.Gtk.Objects.Inscription#g:method:setText"), [setTextOverflow]("GI.Gtk.Objects.Inscription#g:method:setTextOverflow"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setWrapMode]("GI.Gtk.Objects.Inscription#g:method:setWrapMode"), [setXalign]("GI.Gtk.Objects.Inscription#g:method:setXalign"), [setYalign]("GI.Gtk.Objects.Inscription#g:method:setYalign").

    #if defined(ENABLE_OVERLOADING)
        ResolveInscriptionMethod                ,
    #endif

    -- ** getAttributes #method:getAttributes#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetAttributesMethodInfo      ,
    #endif
        inscriptionGetAttributes                ,

    -- ** getMinChars #method:getMinChars#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetMinCharsMethodInfo        ,
    #endif
        inscriptionGetMinChars                  ,

    -- ** getMinLines #method:getMinLines#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetMinLinesMethodInfo        ,
    #endif
        inscriptionGetMinLines                  ,

    -- ** getNatChars #method:getNatChars#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetNatCharsMethodInfo        ,
    #endif
        inscriptionGetNatChars                  ,

    -- ** getNatLines #method:getNatLines#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetNatLinesMethodInfo        ,
    #endif
        inscriptionGetNatLines                  ,

    -- ** getText #method:getText#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetTextMethodInfo            ,
    #endif
        inscriptionGetText                      ,

    -- ** getTextOverflow #method:getTextOverflow#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetTextOverflowMethodInfo    ,
    #endif
        inscriptionGetTextOverflow              ,

    -- ** getWrapMode #method:getWrapMode#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetWrapModeMethodInfo        ,
    #endif
        inscriptionGetWrapMode                  ,

    -- ** getXalign #method:getXalign#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetXalignMethodInfo          ,
    #endif
        inscriptionGetXalign                    ,

    -- ** getYalign #method:getYalign#

    #if defined(ENABLE_OVERLOADING)
        InscriptionGetYalignMethodInfo          ,
    #endif
        inscriptionGetYalign                    ,

    -- ** new #method:new#

        inscriptionNew                          ,

    -- ** setAttributes #method:setAttributes#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetAttributesMethodInfo      ,
    #endif
        inscriptionSetAttributes                ,

    -- ** setMarkup #method:setMarkup#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetMarkupMethodInfo          ,
    #endif
        inscriptionSetMarkup                    ,

    -- ** setMinChars #method:setMinChars#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetMinCharsMethodInfo        ,
    #endif
        inscriptionSetMinChars                  ,

    -- ** setMinLines #method:setMinLines#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetMinLinesMethodInfo        ,
    #endif
        inscriptionSetMinLines                  ,

    -- ** setNatChars #method:setNatChars#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetNatCharsMethodInfo        ,
    #endif
        inscriptionSetNatChars                  ,

    -- ** setNatLines #method:setNatLines#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetNatLinesMethodInfo        ,
    #endif
        inscriptionSetNatLines                  ,

    -- ** setText #method:setText#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetTextMethodInfo            ,
    #endif
        inscriptionSetText                      ,

    -- ** setTextOverflow #method:setTextOverflow#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetTextOverflowMethodInfo    ,
    #endif
        inscriptionSetTextOverflow              ,

    -- ** setWrapMode #method:setWrapMode#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetWrapModeMethodInfo        ,
    #endif
        inscriptionSetWrapMode                  ,

    -- ** setXalign #method:setXalign#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetXalignMethodInfo          ,
    #endif
        inscriptionSetXalign                    ,

    -- ** setYalign #method:setYalign#

    #if defined(ENABLE_OVERLOADING)
        InscriptionSetYalignMethodInfo          ,
    #endif
        inscriptionSetYalign                    ,

     -- * Properties

    -- ** attributes #attr:attributes#
    -- | A list of style attributes to apply to the text of the inscription.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionAttributesPropertyInfo       ,
    #endif
        clearInscriptionAttributes              ,
        constructInscriptionAttributes          ,
        getInscriptionAttributes                ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionAttributes                   ,
    #endif
        setInscriptionAttributes                ,

    -- ** markup #attr:markup#
    -- | Utility property that sets both the [Inscription:text]("GI.Gtk.Objects.Inscription#g:attr:text") and
    -- [Inscription:attributes]("GI.Gtk.Objects.Inscription#g:attr:attributes") properties, mainly intended for use in
    -- GtkBuilder ui files to ease translation support and bindings.
    --
    -- This function uses 'GI.Pango.Functions.parseMarkup' to parse the markup into text and
    -- attributes. The markup must be valid. If you cannot ensure that, consider using
    -- 'GI.Pango.Functions.parseMarkup' and setting the two properties yourself.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionMarkupPropertyInfo           ,
    #endif
        clearInscriptionMarkup                  ,
        constructInscriptionMarkup              ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionMarkup                       ,
    #endif
        setInscriptionMarkup                    ,

    -- ** minChars #attr:minChars#
    -- | The number of characters that should fit into the inscription at minimum.
    --
    -- This influences the requested width, not the width actually given to the widget,
    -- which might turn out to be larger.
    --
    -- Note that this is an approximate character width, so some characters might be
    -- wider and some might be thinner, so do not expect the number of characters to
    -- exactly match.
    --
    -- If you set this property to 0, the inscription will not request any width at all
    -- and its width will be determined entirely by its surroundings.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionMinCharsPropertyInfo         ,
    #endif
        constructInscriptionMinChars            ,
        getInscriptionMinChars                  ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionMinChars                     ,
    #endif
        setInscriptionMinChars                  ,

    -- ** minLines #attr:minLines#
    -- | The number of lines that should fit into the inscription at minimum.
    --
    -- This influences the requested height, not the height actually given to the widget,
    -- which might turn out to be larger.
    --
    -- Note that this is an approximate line height, so if the text uses things like fancy
    -- Unicode or attribute that influence the height, the text might not fit.
    --
    -- If you set this property to 0, the inscription will not request any height at all
    -- and its height will be determined entirely by its surroundings.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionMinLinesPropertyInfo         ,
    #endif
        constructInscriptionMinLines            ,
        getInscriptionMinLines                  ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionMinLines                     ,
    #endif
        setInscriptionMinLines                  ,

    -- ** natChars #attr:natChars#
    -- | The number of characters that should ideally fit into the inscription.
    --
    -- This influences the requested width, not the width actually given to the widget.
    -- The widget might turn out larger as well as smaller.
    --
    -- If this property is set to a value smaller than [Inscription:minChars]("GI.Gtk.Objects.Inscription#g:attr:minChars"),
    -- that value will be used. In particular, for the default value of 0, this will always
    -- be the case.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionNatCharsPropertyInfo         ,
    #endif
        constructInscriptionNatChars            ,
        getInscriptionNatChars                  ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionNatChars                     ,
    #endif
        setInscriptionNatChars                  ,

    -- ** natLines #attr:natLines#
    -- | The number of lines that should ideally fit into the inscription.
    --
    -- This influences the requested height, not the height actually given to the widget.
    -- The widget might turn out larger as well as smaller.
    --
    -- If this property is set to a value smaller than [Inscription:minLines]("GI.Gtk.Objects.Inscription#g:attr:minLines"),
    -- that value will be used. In particular, for the default value of 0, this will always
    -- be the case.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionNatLinesPropertyInfo         ,
    #endif
        constructInscriptionNatLines            ,
        getInscriptionNatLines                  ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionNatLines                     ,
    #endif
        setInscriptionNatLines                  ,

    -- ** text #attr:text#
    -- | The displayed text.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionTextPropertyInfo             ,
    #endif
        clearInscriptionText                    ,
        constructInscriptionText                ,
        getInscriptionText                      ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionText                         ,
    #endif
        setInscriptionText                      ,

    -- ** textOverflow #attr:textOverflow#
    -- | The overflow method to use for the text.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionTextOverflowPropertyInfo     ,
    #endif
        constructInscriptionTextOverflow        ,
        getInscriptionTextOverflow              ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionTextOverflow                 ,
    #endif
        setInscriptionTextOverflow              ,

    -- ** wrapMode #attr:wrapMode#
    -- | Controls how the line wrapping is done.
    --
    -- Note that unlike @GtkLabel@, the default here is 'GI.Pango.Enums.WrapModeWordChar'.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionWrapModePropertyInfo         ,
    #endif
        constructInscriptionWrapMode            ,
        getInscriptionWrapMode                  ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionWrapMode                     ,
    #endif
        setInscriptionWrapMode                  ,

    -- ** xalign #attr:xalign#
    -- | The horizontal alignment of the text inside the allocated size.
    --
    -- Compare this to [Widget:halign]("GI.Gtk.Objects.Widget#g:attr:halign"), which determines how the
    -- inscription\'s size allocation is positioned in the available space.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionXalignPropertyInfo           ,
    #endif
        constructInscriptionXalign              ,
        getInscriptionXalign                    ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionXalign                       ,
    #endif
        setInscriptionXalign                    ,

    -- ** yalign #attr:yalign#
    -- | The vertical alignment of the text inside the allocated size.
    --
    -- Compare this to [Widget:valign]("GI.Gtk.Objects.Widget#g:attr:valign"), which determines how the
    -- inscription\'s size allocation is positioned in the available space.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        InscriptionYalignPropertyInfo           ,
    #endif
        constructInscriptionYalign              ,
        getInscriptionYalign                    ,
    #if defined(ENABLE_OVERLOADING)
        inscriptionYalign                       ,
    #endif
        setInscriptionYalign                    ,

        ) where

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

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

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

    #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.AccessibleText as Gtk.AccessibleText
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Structs.AttrList as Pango.AttrList

    #endif

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

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

    foreign import ccall "gtk_inscription_get_type"
        c_gtk_inscription_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Inscription where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_inscription_get_type

    instance B.Types.GObject Inscription

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

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

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

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

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

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

    #endif

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

    #endif

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

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

    -- | Set the value of the “@attributes@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inscription [ #attributes 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> Pango.AttrList.AttrList -> m ()
    setInscriptionAttributes :: forall (m :: * -> *) o.
    (MonadIO m, IsInscription o) =>
    o -> AttrList -> m ()
    setInscriptionAttributes o
    obj AttrList
    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 AttrList -> IO ()
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyBoxed o
    obj String
    "attributes" (AttrList -> Maybe AttrList
    forall a. a -> Maybe a
    Just AttrList
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@attributes@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructInscriptionAttributes :: (IsInscription o, MIO.MonadIO m) => Pango.AttrList.AttrList -> m (GValueConstruct o)
    constructInscriptionAttributes :: forall o (m :: * -> *).
    (IsInscription o, MonadIO m) =>
    AttrList -> m (GValueConstruct o)
    constructInscriptionAttributes AttrList
    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 AttrList -> IO (GValueConstruct o)
    forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBoxed String
    "attributes" (AttrList -> Maybe AttrList
    forall a. a -> Maybe a
    P.Just AttrList
    val)

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

    #if defined(ENABLE_OVERLOADING)
    data InscriptionAttributesPropertyInfo
    instance AttrInfo InscriptionAttributesPropertyInfo where
        type AttrAllowedOps InscriptionAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint InscriptionAttributesPropertyInfo = IsInscription
        type AttrSetTypeConstraint InscriptionAttributesPropertyInfo = (~) Pango.AttrList.AttrList
        type AttrTransferTypeConstraint InscriptionAttributesPropertyInfo = (~) Pango.AttrList.AttrList
        type AttrTransferType InscriptionAttributesPropertyInfo = Pango.AttrList.AttrList
        type AttrGetType InscriptionAttributesPropertyInfo = (Maybe Pango.AttrList.AttrList)
        type AttrLabel InscriptionAttributesPropertyInfo = "attributes"
        type AttrOrigin InscriptionAttributesPropertyInfo = Inscription
        attrGet = getInscriptionAttributes
        attrSet = setInscriptionAttributes
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructInscriptionAttributes
        attrClear = clearInscriptionAttributes
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.attributes"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Inscription.html#g:attr:attributes"
            })
    #endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data InscriptionTextOverflowPropertyInfo
    instance AttrInfo InscriptionTextOverflowPropertyInfo where
        type AttrAllowedOps InscriptionTextOverflowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint InscriptionTextOverflowPropertyInfo = IsInscription
        type AttrSetTypeConstraint InscriptionTextOverflowPropertyInfo = (~) Gtk.Enums.InscriptionOverflow
        type AttrTransferTypeConstraint InscriptionTextOverflowPropertyInfo = (~) Gtk.Enums.InscriptionOverflow
        type AttrTransferType InscriptionTextOverflowPropertyInfo = Gtk.Enums.InscriptionOverflow
        type AttrGetType InscriptionTextOverflowPropertyInfo = Gtk.Enums.InscriptionOverflow
        type AttrLabel InscriptionTextOverflowPropertyInfo = "text-overflow"
        type AttrOrigin InscriptionTextOverflowPropertyInfo = Inscription
        attrGet = getInscriptionTextOverflow
        attrSet = setInscriptionTextOverflow
        attrPut = setInscriptionTextOverflow
        attrTransfer _ v = do
            return v
        attrConstruct = constructInscriptionTextOverflow
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.textOverflow"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Inscription.html#g:attr:textOverflow"
            })
    #endif

    -- VVV Prop "wrap-mode"
       -- Type: TInterface (Name {namespace = "Pango", name = "WrapMode"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data InscriptionWrapModePropertyInfo
    instance AttrInfo InscriptionWrapModePropertyInfo where
        type AttrAllowedOps InscriptionWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint InscriptionWrapModePropertyInfo = IsInscription
        type AttrSetTypeConstraint InscriptionWrapModePropertyInfo = (~) Pango.Enums.WrapMode
        type AttrTransferTypeConstraint InscriptionWrapModePropertyInfo = (~) Pango.Enums.WrapMode
        type AttrTransferType InscriptionWrapModePropertyInfo = Pango.Enums.WrapMode
        type AttrGetType InscriptionWrapModePropertyInfo = Pango.Enums.WrapMode
        type AttrLabel InscriptionWrapModePropertyInfo = "wrap-mode"
        type AttrOrigin InscriptionWrapModePropertyInfo = Inscription
        attrGet = getInscriptionWrapMode
        attrSet = setInscriptionWrapMode
        attrPut = setInscriptionWrapMode
        attrTransfer _ v = do
            return v
        attrConstruct = constructInscriptionWrapMode
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.wrapMode"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Inscription.html#g:attr:wrapMode"
            })
    #endif

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

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Inscription
    type instance O.AttributeList Inscription = InscriptionAttributeList
    type InscriptionAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("attributes", InscriptionAttributesPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("markup", InscriptionMarkupPropertyInfo), '("minChars", InscriptionMinCharsPropertyInfo), '("minLines", InscriptionMinLinesPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("natChars", InscriptionNatCharsPropertyInfo), '("natLines", InscriptionNatLinesPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("text", InscriptionTextPropertyInfo), '("textOverflow", InscriptionTextOverflowPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("wrapMode", InscriptionWrapModePropertyInfo), '("xalign", InscriptionXalignPropertyInfo), '("yalign", InscriptionYalignPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    inscriptionAttributes :: AttrLabelProxy "attributes"
    inscriptionAttributes = AttrLabelProxy

    inscriptionMarkup :: AttrLabelProxy "markup"
    inscriptionMarkup = AttrLabelProxy

    inscriptionMinChars :: AttrLabelProxy "minChars"
    inscriptionMinChars = AttrLabelProxy

    inscriptionMinLines :: AttrLabelProxy "minLines"
    inscriptionMinLines = AttrLabelProxy

    inscriptionNatChars :: AttrLabelProxy "natChars"
    inscriptionNatChars = AttrLabelProxy

    inscriptionNatLines :: AttrLabelProxy "natLines"
    inscriptionNatLines = AttrLabelProxy

    inscriptionText :: AttrLabelProxy "text"
    inscriptionText = AttrLabelProxy

    inscriptionTextOverflow :: AttrLabelProxy "textOverflow"
    inscriptionTextOverflow = AttrLabelProxy

    inscriptionWrapMode :: AttrLabelProxy "wrapMode"
    inscriptionWrapMode = AttrLabelProxy

    inscriptionXalign :: AttrLabelProxy "xalign"
    inscriptionXalign = AttrLabelProxy

    inscriptionYalign :: AttrLabelProxy "yalign"
    inscriptionYalign = AttrLabelProxy

    #endif

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

    #endif

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

    foreign import ccall "gtk_inscription_new" gtk_inscription_new ::
        CString ->                              -- text : TBasicType TUTF8
        IO (Ptr Inscription)

    -- | Creates a new @GtkInscription@ with the given text.
    --
    -- /Since: 4.8/
    inscriptionNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (T.Text)
        -- ^ /@text@/: The text to display.
        -> m Inscription
        -- ^ __Returns:__ a new @GtkInscription@
    inscriptionNew :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Text -> m Inscription
    inscriptionNew Maybe Text
    text = IO Inscription -> m Inscription
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Inscription -> m Inscription)
    -> IO Inscription -> m Inscription
    forall a b. (a -> b) -> a -> b
    $ do
        maybeText <- case Maybe Text
    text of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jText -> do
                jText' <- Text -> IO (Ptr CChar)
    textToCString Text
    jText
                return jText'
        result <- gtk_inscription_new maybeText
        checkUnexpectedReturnNULL "inscriptionNew" result
        result' <- (newObject Inscription) result
        freeMem maybeText
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "gtk_inscription_get_attributes" gtk_inscription_get_attributes ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO (Ptr Pango.AttrList.AttrList)

    -- | Gets the inscription\'s attribute list.
    --
    -- /Since: 4.8/
    inscriptionGetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m (Maybe Pango.AttrList.AttrList)
        -- ^ __Returns:__ the attribute list
    inscriptionGetAttributes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m (Maybe AttrList)
    inscriptionGetAttributes a
    self = IO (Maybe AttrList) -> m (Maybe AttrList)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrList) -> m (Maybe AttrList))
    -> IO (Maybe AttrList) -> m (Maybe AttrList)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_attributes self'
        maybeResult <- convertIfNonNull result $ \Ptr AttrList
    result' -> do
            result'' <- ((ManagedPtr AttrList -> AttrList) -> Ptr AttrList -> IO AttrList
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr AttrList -> AttrList
    Pango.AttrList.AttrList) Ptr AttrList
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetAttributesMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrList.AttrList)), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetAttributesMethodInfo a signature where
        overloadedMethod = inscriptionGetAttributes

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

    #endif

    -- method Inscription::get_min_chars
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_min_chars" gtk_inscription_get_min_chars ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO Word32

    -- | Gets the @min-chars@ of the inscription.
    --
    -- See the [Inscription:minChars]("GI.Gtk.Objects.Inscription#g:attr:minChars") property.
    --
    -- /Since: 4.8/
    inscriptionGetMinChars ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Word32
        -- ^ __Returns:__ the min-chars property
    inscriptionGetMinChars :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m Word32
    inscriptionGetMinChars a
    self = 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
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_min_chars self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetMinCharsMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetMinCharsMethodInfo a signature where
        overloadedMethod = inscriptionGetMinChars

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

    #endif

    -- method Inscription::get_min_lines
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_min_lines" gtk_inscription_get_min_lines ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO Word32

    -- | Gets the @min-lines@ of the inscription.
    --
    -- See the [Inscription:minLines]("GI.Gtk.Objects.Inscription#g:attr:minLines") property.
    --
    -- /Since: 4.8/
    inscriptionGetMinLines ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Word32
        -- ^ __Returns:__ the min-lines property
    inscriptionGetMinLines :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m Word32
    inscriptionGetMinLines a
    self = 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
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_min_lines self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetMinLinesMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetMinLinesMethodInfo a signature where
        overloadedMethod = inscriptionGetMinLines

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

    #endif

    -- method Inscription::get_nat_chars
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_nat_chars" gtk_inscription_get_nat_chars ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO Word32

    -- | Gets the @nat-chars@ of the inscription.
    --
    -- See the [Inscription:natChars]("GI.Gtk.Objects.Inscription#g:attr:natChars") property.
    --
    -- /Since: 4.8/
    inscriptionGetNatChars ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Word32
        -- ^ __Returns:__ the nat-chars property
    inscriptionGetNatChars :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m Word32
    inscriptionGetNatChars a
    self = 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
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_nat_chars self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetNatCharsMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetNatCharsMethodInfo a signature where
        overloadedMethod = inscriptionGetNatChars

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

    #endif

    -- method Inscription::get_nat_lines
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_nat_lines" gtk_inscription_get_nat_lines ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO Word32

    -- | Gets the @nat-lines@ of the inscription.
    --
    -- See the [Inscription:natLines]("GI.Gtk.Objects.Inscription#g:attr:natLines") property.
    --
    -- /Since: 4.8/
    inscriptionGetNatLines ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Word32
        -- ^ __Returns:__ the nat-lines property
    inscriptionGetNatLines :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m Word32
    inscriptionGetNatLines a
    self = 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
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_nat_lines self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetNatLinesMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetNatLinesMethodInfo a signature where
        overloadedMethod = inscriptionGetNatLines

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

    #endif

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

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

    -- | Gets the text that is displayed.
    --
    -- /Since: 4.8/
    inscriptionGetText ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m (Maybe T.Text)
        -- ^ __Returns:__ The displayed text
    inscriptionGetText :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m (Maybe Text)
    inscriptionGetText a
    self = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_text self'
        maybeResult <- convertIfNonNull result $ \Ptr CChar
    result' -> do
            result'' <- HasCallStack => Ptr CChar -> IO Text
    Ptr CChar -> IO Text
    cstringToText Ptr CChar
    result'
            return result''
        touchManagedPtr self
        return maybeResult

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

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

    #endif

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

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

    -- | Gets the inscription\'s overflow method.
    --
    -- /Since: 4.8/
    inscriptionGetTextOverflow ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Gtk.Enums.InscriptionOverflow
        -- ^ __Returns:__ the overflow method
    inscriptionGetTextOverflow :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m InscriptionOverflow
    inscriptionGetTextOverflow a
    self = IO InscriptionOverflow -> m InscriptionOverflow
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO InscriptionOverflow -> m InscriptionOverflow)
    -> IO InscriptionOverflow -> m InscriptionOverflow
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_text_overflow self'
        let result' = (Int -> InscriptionOverflow
    forall a. Enum a => Int -> a
    toEnum (Int -> InscriptionOverflow)
    -> (CUInt -> Int) -> CUInt -> InscriptionOverflow
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetTextOverflowMethodInfo
    instance (signature ~ (m Gtk.Enums.InscriptionOverflow), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetTextOverflowMethodInfo a signature where
        overloadedMethod = inscriptionGetTextOverflow

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

    #endif

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

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

    -- | Returns line wrap mode used by the inscription.
    --
    -- See 'GI.Gtk.Objects.Inscription.inscriptionSetWrapMode'.
    --
    -- /Since: 4.8/
    inscriptionGetWrapMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Pango.Enums.WrapMode
        -- ^ __Returns:__ the line wrap mode
    inscriptionGetWrapMode :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m WrapMode
    inscriptionGetWrapMode a
    self = IO WrapMode -> m WrapMode
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_wrap_mode self'
        let result' = (Int -> WrapMode
    forall a. Enum a => Int -> a
    toEnum (Int -> WrapMode) -> (CUInt -> Int) -> CUInt -> WrapMode
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetWrapModeMethodInfo
    instance (signature ~ (m Pango.Enums.WrapMode), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetWrapModeMethodInfo a signature where
        overloadedMethod = inscriptionGetWrapMode

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

    #endif

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

    foreign import ccall "gtk_inscription_get_xalign" gtk_inscription_get_xalign ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO CFloat

    -- | Gets the @xalign@ of the inscription.
    --
    -- See the [Inscription:xalign]("GI.Gtk.Objects.Inscription#g:attr:xalign") property.
    --
    -- /Since: 4.8/
    inscriptionGetXalign ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Float
        -- ^ __Returns:__ the xalign property
    inscriptionGetXalign :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m Float
    inscriptionGetXalign a
    self = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_xalign self'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetXalignMethodInfo
    instance (signature ~ (m Float), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetXalignMethodInfo a signature where
        overloadedMethod = inscriptionGetXalign

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

    #endif

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

    foreign import ccall "gtk_inscription_get_yalign" gtk_inscription_get_yalign ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        IO CFloat

    -- | Gets the @yalign@ of the inscription.
    --
    -- See the [Inscription:yalign]("GI.Gtk.Objects.Inscription#g:attr:yalign") property.
    --
    -- /Since: 4.8/
    inscriptionGetYalign ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> m Float
        -- ^ __Returns:__ the yalign property
    inscriptionGetYalign :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> m Float
    inscriptionGetYalign a
    self = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_inscription_get_yalign self'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data InscriptionGetYalignMethodInfo
    instance (signature ~ (m Float), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetYalignMethodInfo a signature where
        overloadedMethod = inscriptionGetYalign

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

    #endif

    -- method Inscription::set_attributes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attrs"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "AttrList" }
    --           , argCType = Just "PangoAttrList*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a [struct@Pango.AttrList]"
    --                 , 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_inscription_set_attributes" gtk_inscription_set_attributes ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        Ptr Pango.AttrList.AttrList ->          -- attrs : TInterface (Name {namespace = "Pango", name = "AttrList"})
        IO ()

    -- | Apply attributes to the inscription text.
    --
    -- These attributes will not be evaluated for sizing the inscription.
    --
    -- /Since: 4.8/
    inscriptionSetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Maybe (Pango.AttrList.AttrList)
        -- ^ /@attrs@/: a t'GI.Pango.Structs.AttrList.AttrList'
        -> m ()
    inscriptionSetAttributes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Maybe AttrList -> m ()
    inscriptionSetAttributes a
    self Maybe AttrList
    attrs = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeAttrs <- case attrs of
            Maybe AttrList
    Nothing -> Ptr AttrList -> IO (Ptr AttrList)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr AttrList
    forall a. Ptr a
    FP.nullPtr
            Just AttrList
    jAttrs -> do
                jAttrs' <- AttrList -> IO (Ptr AttrList)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr AttrList
    jAttrs
                return jAttrs'
        gtk_inscription_set_attributes self' maybeAttrs
        touchManagedPtr self
        whenJust attrs touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetAttributesMethodInfo
    instance (signature ~ (Maybe (Pango.AttrList.AttrList) -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetAttributesMethodInfo a signature where
        overloadedMethod = inscriptionSetAttributes

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

    #endif

    -- method Inscription::set_markup
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "markup"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The markup to display"
    --                 , 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_inscription_set_markup" gtk_inscription_set_markup ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        CString ->                              -- markup : TBasicType TUTF8
        IO ()

    -- | Utility function to set the text and attributes to be displayed.
    --
    -- See the [Inscription:markup]("GI.Gtk.Objects.Inscription#g:attr:markup") property.
    --
    -- /Since: 4.8/
    inscriptionSetMarkup ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Maybe (T.Text)
        -- ^ /@markup@/: The markup to display
        -> m ()
    inscriptionSetMarkup :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Maybe Text -> m ()
    inscriptionSetMarkup a
    self Maybe Text
    markup = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeMarkup <- case markup of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jMarkup -> do
                jMarkup' <- Text -> IO (Ptr CChar)
    textToCString Text
    jMarkup
                return jMarkup'
        gtk_inscription_set_markup self' maybeMarkup
        touchManagedPtr self
        freeMem maybeMarkup
        return ()

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

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

    #endif

    -- method Inscription::set_min_chars
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min_chars"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the minimum number of characters that should fit, approximately"
    --                 , 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_inscription_set_min_chars" gtk_inscription_set_min_chars ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        Word32 ->                               -- min_chars : TBasicType TUInt
        IO ()

    -- | Sets the @min-chars@ of the inscription.
    --
    -- See the [Inscription:minChars]("GI.Gtk.Objects.Inscription#g:attr:minChars") property.
    --
    -- /Since: 4.8/
    inscriptionSetMinChars ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Word32
        -- ^ /@minChars@/: the minimum number of characters that should fit, approximately
        -> m ()
    inscriptionSetMinChars :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Word32 -> m ()
    inscriptionSetMinChars a
    self Word32
    minChars = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_inscription_set_min_chars self' minChars
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetMinCharsMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetMinCharsMethodInfo a signature where
        overloadedMethod = inscriptionSetMinChars

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

    #endif

    -- method Inscription::set_min_lines
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min_lines"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the minimum number of lines that should fit, approximately"
    --                 , 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_inscription_set_min_lines" gtk_inscription_set_min_lines ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        Word32 ->                               -- min_lines : TBasicType TUInt
        IO ()

    -- | Sets the @min-lines@ of the inscription.
    --
    -- See the [Inscription:minLines]("GI.Gtk.Objects.Inscription#g:attr:minLines") property.
    --
    -- /Since: 4.8/
    inscriptionSetMinLines ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Word32
        -- ^ /@minLines@/: the minimum number of lines that should fit, approximately
        -> m ()
    inscriptionSetMinLines :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Word32 -> m ()
    inscriptionSetMinLines a
    self Word32
    minLines = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_inscription_set_min_lines self' minLines
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetMinLinesMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetMinLinesMethodInfo a signature where
        overloadedMethod = inscriptionSetMinLines

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

    #endif

    -- method Inscription::set_nat_chars
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "nat_chars"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the number of characters that should ideally fit, approximately"
    --                 , 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_inscription_set_nat_chars" gtk_inscription_set_nat_chars ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        Word32 ->                               -- nat_chars : TBasicType TUInt
        IO ()

    -- | Sets the @nat-chars@ of the inscription.
    --
    -- See the [Inscription:natChars]("GI.Gtk.Objects.Inscription#g:attr:natChars") property.
    --
    -- /Since: 4.8/
    inscriptionSetNatChars ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Word32
        -- ^ /@natChars@/: the number of characters that should ideally fit, approximately
        -> m ()
    inscriptionSetNatChars :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Word32 -> m ()
    inscriptionSetNatChars a
    self Word32
    natChars = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_inscription_set_nat_chars self' natChars
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetNatCharsMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetNatCharsMethodInfo a signature where
        overloadedMethod = inscriptionSetNatChars

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

    #endif

    -- method Inscription::set_nat_lines
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "nat_lines"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of lines that should ideally fit"
    --                 , 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_inscription_set_nat_lines" gtk_inscription_set_nat_lines ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        Word32 ->                               -- nat_lines : TBasicType TUInt
        IO ()

    -- | Sets the @nat-lines@ of the inscription.
    --
    -- See the [Inscription:natLines]("GI.Gtk.Objects.Inscription#g:attr:natLines") property.
    --
    -- /Since: 4.8/
    inscriptionSetNatLines ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Word32
        -- ^ /@natLines@/: the number of lines that should ideally fit
        -> m ()
    inscriptionSetNatLines :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Word32 -> m ()
    inscriptionSetNatLines a
    self Word32
    natLines = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_inscription_set_nat_lines self' natLines
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetNatLinesMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetNatLinesMethodInfo a signature where
        overloadedMethod = inscriptionSetNatLines

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

    #endif

    -- method Inscription::set_text
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "text"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The text to display"
    --                 , 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_inscription_set_text" gtk_inscription_set_text ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        CString ->                              -- text : TBasicType TUTF8
        IO ()

    -- | Sets the text to be displayed.
    --
    -- /Since: 4.8/
    inscriptionSetText ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Maybe (T.Text)
        -- ^ /@text@/: The text to display
        -> m ()
    inscriptionSetText :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Maybe Text -> m ()
    inscriptionSetText a
    self Maybe Text
    text = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeText <- case text of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jText -> do
                jText' <- Text -> IO (Ptr CChar)
    textToCString Text
    jText
                return jText'
        gtk_inscription_set_text self' maybeText
        touchManagedPtr self
        freeMem maybeText
        return ()

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

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

    #endif

    -- method Inscription::set_text_overflow
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "overflow"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "InscriptionOverflow" }
    --           , argCType = Just "GtkInscriptionOverflow"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the overflow method to use"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_inscription_set_text_overflow" gtk_inscription_set_text_overflow ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        CUInt ->                                -- overflow : TInterface (Name {namespace = "Gtk", name = "InscriptionOverflow"})
        IO ()

    -- | Sets what to do when the text doesn\'t fit.
    --
    -- /Since: 4.8/
    inscriptionSetTextOverflow ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Gtk.Enums.InscriptionOverflow
        -- ^ /@overflow@/: the overflow method to use
        -> m ()
    inscriptionSetTextOverflow :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> InscriptionOverflow -> m ()
    inscriptionSetTextOverflow a
    self InscriptionOverflow
    overflow = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let overflow' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (InscriptionOverflow -> Int) -> InscriptionOverflow -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . InscriptionOverflow -> Int
    forall a. Enum a => a -> Int
    fromEnum) InscriptionOverflow
    overflow
        gtk_inscription_set_text_overflow self' overflow'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetTextOverflowMethodInfo
    instance (signature ~ (Gtk.Enums.InscriptionOverflow -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetTextOverflowMethodInfo a signature where
        overloadedMethod = inscriptionSetTextOverflow

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

    #endif

    -- method Inscription::set_wrap_mode
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "wrap_mode"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "WrapMode" }
    --           , argCType = Just "PangoWrapMode"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the line wrapping mode"
    --                 , 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_inscription_set_wrap_mode" gtk_inscription_set_wrap_mode ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        CUInt ->                                -- wrap_mode : TInterface (Name {namespace = "Pango", name = "WrapMode"})
        IO ()

    -- | Controls how line wrapping is done.
    --
    -- /Since: 4.8/
    inscriptionSetWrapMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Pango.Enums.WrapMode
        -- ^ /@wrapMode@/: the line wrapping mode
        -> m ()
    inscriptionSetWrapMode :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> WrapMode -> m ()
    inscriptionSetWrapMode a
    self WrapMode
    wrapMode = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let wrapMode' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (WrapMode -> Int) -> WrapMode -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WrapMode -> Int
    forall a. Enum a => a -> Int
    fromEnum) WrapMode
    wrapMode
        gtk_inscription_set_wrap_mode self' wrapMode'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetWrapModeMethodInfo
    instance (signature ~ (Pango.Enums.WrapMode -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetWrapModeMethodInfo a signature where
        overloadedMethod = inscriptionSetWrapMode

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

    #endif

    -- method Inscription::set_xalign
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new xalign value, between 0 and 1"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    -- | Sets the @xalign@ of the inscription.
    --
    -- See the [Inscription:xalign]("GI.Gtk.Objects.Inscription#g:attr:xalign") property.
    --
    -- /Since: 4.8/
    inscriptionSetXalign ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Float
        -- ^ /@xalign@/: the new xalign value, between 0 and 1
        -> m ()
    inscriptionSetXalign :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Float -> m ()
    inscriptionSetXalign a
    self Float
    xalign = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let xalign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xalign
        gtk_inscription_set_xalign self' xalign'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetXalignMethodInfo
    instance (signature ~ (Float -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetXalignMethodInfo a signature where
        overloadedMethod = inscriptionSetXalign

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

    #endif

    -- method Inscription::set_yalign
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Inscription" }
    --           , argCType = Just "GtkInscription*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "yalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new yalign value, between 0 and 1"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_inscription_set_yalign" gtk_inscription_set_yalign ::
        Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
        CFloat ->                               -- yalign : TBasicType TFloat
        IO ()

    -- | Sets the @yalign@ of the inscription.
    --
    -- See the [Inscription:yalign]("GI.Gtk.Objects.Inscription#g:attr:yalign") property.
    --
    -- /Since: 4.8/
    inscriptionSetYalign ::
        (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
        a
        -- ^ /@self@/: a @GtkInscription@
        -> Float
        -- ^ /@yalign@/: the new yalign value, between 0 and 1
        -> m ()
    inscriptionSetYalign :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsInscription a) =>
    a -> Float -> m ()
    inscriptionSetYalign a
    self Float
    yalign = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Inscription)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let yalign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yalign
        gtk_inscription_set_yalign self' yalign'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data InscriptionSetYalignMethodInfo
    instance (signature ~ (Float -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetYalignMethodInfo a signature where
        overloadedMethod = inscriptionSetYalign

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

    #endif