    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- /No description available in the introspection data./

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

    module GI.Gtk.Structs.WidgetClass
        (

    -- * Exported types
        WidgetClass(..)                         ,
        newZeroWidgetClass                      ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [addShortcut]("GI.Gtk.Structs.WidgetClass#g:method:addShortcut"), [bindTemplateCallbackFull]("GI.Gtk.Structs.WidgetClass#g:method:bindTemplateCallbackFull"), [bindTemplateChildFull]("GI.Gtk.Structs.WidgetClass#g:method:bindTemplateChildFull"), [installAction]("GI.Gtk.Structs.WidgetClass#g:method:installAction"), [installPropertyAction]("GI.Gtk.Structs.WidgetClass#g:method:installPropertyAction"), [queryAction]("GI.Gtk.Structs.WidgetClass#g:method:queryAction").
    --
    -- ==== Getters
    -- [getAccessibleRole]("GI.Gtk.Structs.WidgetClass#g:method:getAccessibleRole"), [getActivateSignal]("GI.Gtk.Structs.WidgetClass#g:method:getActivateSignal"), [getCssName]("GI.Gtk.Structs.WidgetClass#g:method:getCssName"), [getLayoutManagerType]("GI.Gtk.Structs.WidgetClass#g:method:getLayoutManagerType").
    --
    -- ==== Setters
    -- [setAccessibleRole]("GI.Gtk.Structs.WidgetClass#g:method:setAccessibleRole"), [setActivateSignal]("GI.Gtk.Structs.WidgetClass#g:method:setActivateSignal"), [setActivateSignalFromName]("GI.Gtk.Structs.WidgetClass#g:method:setActivateSignalFromName"), [setCssName]("GI.Gtk.Structs.WidgetClass#g:method:setCssName"), [setLayoutManagerType]("GI.Gtk.Structs.WidgetClass#g:method:setLayoutManagerType"), [setTemplate]("GI.Gtk.Structs.WidgetClass#g:method:setTemplate"), [setTemplateFromResource]("GI.Gtk.Structs.WidgetClass#g:method:setTemplateFromResource"), [setTemplateScope]("GI.Gtk.Structs.WidgetClass#g:method:setTemplateScope").

    #if defined(ENABLE_OVERLOADING)
        ResolveWidgetClassMethod                ,
    #endif

    -- ** addShortcut #method:addShortcut#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassAddShortcutMethodInfo        ,
    #endif
        widgetClassAddShortcut                  ,

    -- ** bindTemplateCallbackFull #method:bindTemplateCallbackFull#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassBindTemplateCallbackFullMethodInfo,
    #endif
        widgetClassBindTemplateCallbackFull     ,

    -- ** bindTemplateChildFull #method:bindTemplateChildFull#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassBindTemplateChildFullMethodInfo,
    #endif
        widgetClassBindTemplateChildFull        ,

    -- ** getAccessibleRole #method:getAccessibleRole#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassGetAccessibleRoleMethodInfo  ,
    #endif
        widgetClassGetAccessibleRole            ,

    -- ** getActivateSignal #method:getActivateSignal#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassGetActivateSignalMethodInfo  ,
    #endif
        widgetClassGetActivateSignal            ,

    -- ** getCssName #method:getCssName#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassGetCssNameMethodInfo         ,
    #endif
        widgetClassGetCssName                   ,

    -- ** getLayoutManagerType #method:getLayoutManagerType#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassGetLayoutManagerTypeMethodInfo,
    #endif
        widgetClassGetLayoutManagerType         ,

    -- ** installAction #method:installAction#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassInstallActionMethodInfo      ,
    #endif
        widgetClassInstallAction                ,

    -- ** installPropertyAction #method:installPropertyAction#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassInstallPropertyActionMethodInfo,
    #endif
        widgetClassInstallPropertyAction        ,

    -- ** queryAction #method:queryAction#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassQueryActionMethodInfo        ,
    #endif
        widgetClassQueryAction                  ,

    -- ** setAccessibleRole #method:setAccessibleRole#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetAccessibleRoleMethodInfo  ,
    #endif
        widgetClassSetAccessibleRole            ,

    -- ** setActivateSignal #method:setActivateSignal#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetActivateSignalMethodInfo  ,
    #endif
        widgetClassSetActivateSignal            ,

    -- ** setActivateSignalFromName #method:setActivateSignalFromName#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetActivateSignalFromNameMethodInfo,
    #endif
        widgetClassSetActivateSignalFromName    ,

    -- ** setCssName #method:setCssName#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetCssNameMethodInfo         ,
    #endif
        widgetClassSetCssName                   ,

    -- ** setLayoutManagerType #method:setLayoutManagerType#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetLayoutManagerTypeMethodInfo,
    #endif
        widgetClassSetLayoutManagerType         ,

    -- ** setTemplate #method:setTemplate#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetTemplateMethodInfo        ,
    #endif
        widgetClassSetTemplate                  ,

    -- ** setTemplateFromResource #method:setTemplateFromResource#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetTemplateFromResourceMethodInfo,
    #endif
        widgetClassSetTemplateFromResource      ,

    -- ** setTemplateScope #method:setTemplateScope#

    #if defined(ENABLE_OVERLOADING)
        WidgetClassSetTemplateScopeMethodInfo   ,
    #endif
        widgetClassSetTemplateScope             ,

     -- * Properties

    -- ** computeExpand #attr:computeExpand#
    -- | Computes whether a container should give this
    --   widget extra space when possible.

        clearWidgetClassComputeExpand           ,
        getWidgetClassComputeExpand             ,
        setWidgetClassComputeExpand             ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_computeExpand               ,
    #endif

    -- ** contains #attr:contains#
    -- | Vfunc for 'GI.Gtk.Objects.Widget.widgetContains'.

        clearWidgetClassContains                ,
        getWidgetClassContains                  ,
        setWidgetClassContains                  ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_contains                    ,
    #endif

    -- ** cssChanged #attr:cssChanged#
    -- | Vfunc called when the CSS used by widget was changed. Widgets
    --   should then discard their caches that depend on CSS and queue resizes or
    --   redraws accordingly. The default implementation will take care of this for
    --   all the default CSS properties, so implementations must chain up.

        clearWidgetClassCssChanged              ,
        getWidgetClassCssChanged                ,
        setWidgetClassCssChanged                ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_cssChanged                  ,
    #endif

    -- ** directionChanged #attr:directionChanged#
    -- | Signal emitted when the text direction of a
    --   widget changes.

        clearWidgetClassDirectionChanged        ,
        getWidgetClassDirectionChanged          ,
        setWidgetClassDirectionChanged          ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_directionChanged            ,
    #endif

    -- ** focus #attr:focus#
    -- | Vfunc for 'GI.Gtk.Objects.Widget.widgetChildFocus'

        clearWidgetClassFocus                   ,
        getWidgetClassFocus                     ,
        setWidgetClassFocus                     ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_focus                       ,
    #endif

    -- ** getRequestMode #attr:getRequestMode#
    -- | Called to get the request mode, if the widget
    --   does not have a layout manager.
    --   This allows a widget to tell its parent container whether
    --   it prefers to be allocated in 'GI.Gtk.Enums.SizeRequestModeHeightForWidth' or
    --   'GI.Gtk.Enums.SizeRequestModeWidthForHeight' mode.
    --   'GI.Gtk.Enums.SizeRequestModeHeightForWidth' means the widget prefers to have
    --   @GtkWidgetClass.measure()@ called first to get the default width (passing
    --   a for_size of -1), then again to get the height for said default width.
    --   'GI.Gtk.Enums.SizeRequestModeConstantSize' disables any height-for-width or
    --   width-for-height geometry management for said widget and is the
    --   default return.
    --   It’s important to note that any widget
    --   which trades height-for-width or width-for-height must respond properly
    --   to a for_size value >= -1 passed to @GtkWidgetClass.measure@, for both
    --   possible orientations.

        clearWidgetClassGetRequestMode          ,
        getWidgetClassGetRequestMode            ,
        setWidgetClassGetRequestMode            ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_getRequestMode              ,
    #endif

    -- ** grabFocus #attr:grabFocus#
    -- | Causes /@widget@/ to have the keyboard focus for the
    --   @GtkWindow@ it’s inside.

        clearWidgetClassGrabFocus               ,
        getWidgetClassGrabFocus                 ,
        setWidgetClassGrabFocus                 ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_grabFocus                   ,
    #endif

    -- ** hide #attr:hide#
    -- | Signal emitted when widget is hidden.

        clearWidgetClassHide                    ,
        getWidgetClassHide                      ,
        setWidgetClassHide                      ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_hide                        ,
    #endif

    -- ** keynavFailed #attr:keynavFailed#
    -- | Signal emitted if keyboard navigation fails.

        clearWidgetClassKeynavFailed            ,
        getWidgetClassKeynavFailed              ,
        setWidgetClassKeynavFailed              ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_keynavFailed                ,
    #endif

    -- ** map #attr:map#
    -- | Signal emitted when widget is going to be mapped, that is
    --   when the widget is visible (which is controlled with
    --   'GI.Gtk.Objects.Widget.widgetSetVisible') and all its parents up to the toplevel
    --   widget are also visible.

        clearWidgetClassMap                     ,
        getWidgetClassMap                       ,
        setWidgetClassMap                       ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_map                         ,
    #endif

    -- ** measure #attr:measure#
    -- | Called to obtain the minimum and natural size of the widget,
    --   if the widget does not have a layout manager.
    --   Depending on the orientation parameter, the passed for_size can be
    --   interpreted as width or height. A widget will never be allocated less
    --   than its minimum size.

        clearWidgetClassMeasure                 ,
        getWidgetClassMeasure                   ,
        setWidgetClassMeasure                   ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_measure                     ,
    #endif

    -- ** mnemonicActivate #attr:mnemonicActivate#
    -- | Activates the /@widget@/ if /@groupCycling@/ is
    --   'P.False', and just grabs the focus if /@groupCycling@/ is 'P.True'.

        clearWidgetClassMnemonicActivate        ,
        getWidgetClassMnemonicActivate          ,
        setWidgetClassMnemonicActivate          ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_mnemonicActivate            ,
    #endif

    -- ** moveFocus #attr:moveFocus#
    -- | Signal emitted when a change of focus is requested

        clearWidgetClassMoveFocus               ,
        getWidgetClassMoveFocus                 ,
        setWidgetClassMoveFocus                 ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_moveFocus                   ,
    #endif

    -- ** parentClass #attr:parentClass#
    -- | The object class structure needs to be the first
    --   element in the widget class structure in order for the class mechanism
    --   to work correctly. This allows a GtkWidgetClass pointer to be cast to
    --   a GObjectClass pointer.

        getWidgetClassParentClass               ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_parentClass                 ,
    #endif

    -- ** queryTooltip #attr:queryTooltip#
    -- | Signal emitted when “has-tooltip” is 'P.True' and the
    --   hover timeout has expired with the cursor hovering “above”
    --   widget; or emitted when widget got focus in keyboard mode.

        clearWidgetClassQueryTooltip            ,
        getWidgetClassQueryTooltip              ,
        setWidgetClassQueryTooltip              ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_queryTooltip                ,
    #endif

    -- ** realize #attr:realize#
    -- | Signal emitted when widget is associated with a
    --   @GdkSurface@, which means that 'GI.Gtk.Objects.Widget.widgetRealize' has been called or
    --   the widget has been mapped (that is, it is going to be drawn).

        clearWidgetClassRealize                 ,
        getWidgetClassRealize                   ,
        setWidgetClassRealize                   ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_realize                     ,
    #endif

    -- ** root #attr:root#
    -- | Called when the widget gets added to a @GtkRoot@ widget. Must
    --   chain up

        clearWidgetClassRoot                    ,
        getWidgetClassRoot                      ,
        setWidgetClassRoot                      ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_root                        ,
    #endif

    -- ** setFocusChild #attr:setFocusChild#
    -- | Sets the focused child of a widget. Must chain up

        clearWidgetClassSetFocusChild           ,
        getWidgetClassSetFocusChild             ,
        setWidgetClassSetFocusChild             ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_setFocusChild               ,
    #endif

    -- ** show #attr:show#
    -- | Signal emitted when widget is shown

        clearWidgetClassShow                    ,
        getWidgetClassShow                      ,
        setWidgetClassShow                      ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_show                        ,
    #endif

    -- ** sizeAllocate #attr:sizeAllocate#
    -- | Called to set the allocation, if the widget does
    --   not have a layout manager.

        clearWidgetClassSizeAllocate            ,
        getWidgetClassSizeAllocate              ,
        setWidgetClassSizeAllocate              ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_sizeAllocate                ,
    #endif

    -- ** snapshot #attr:snapshot#
    -- | Vfunc called when a new snapshot of the widget has to be taken.

        clearWidgetClassSnapshot                ,
        getWidgetClassSnapshot                  ,
        setWidgetClassSnapshot                  ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_snapshot                    ,
    #endif

    -- ** stateFlagsChanged #attr:stateFlagsChanged#
    -- | Signal emitted when the widget state changes,
    --   see 'GI.Gtk.Objects.Widget.widgetGetStateFlags'.

        clearWidgetClassStateFlagsChanged       ,
        getWidgetClassStateFlagsChanged         ,
        setWidgetClassStateFlagsChanged         ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_stateFlagsChanged           ,
    #endif

    -- ** systemSettingChanged #attr:systemSettingChanged#
    -- | Emitted when a system setting was changed. Must chain up.

        clearWidgetClassSystemSettingChanged    ,
        getWidgetClassSystemSettingChanged      ,
        setWidgetClassSystemSettingChanged      ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_systemSettingChanged        ,
    #endif

    -- ** unmap #attr:unmap#
    -- | Signal emitted when widget is going to be unmapped, which
    --   means that either it or any of its parents up to the toplevel
    --   widget have been set as hidden.

        clearWidgetClassUnmap                   ,
        getWidgetClassUnmap                     ,
        setWidgetClassUnmap                     ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_unmap                       ,
    #endif

    -- ** unrealize #attr:unrealize#
    -- | Signal emitted when the GdkSurface associated with
    --   widget is destroyed, which means that 'GI.Gtk.Objects.Widget.widgetUnrealize' has
    --   been called or the widget has been unmapped (that is, it is going
    --   to be hidden).

        clearWidgetClassUnrealize               ,
        getWidgetClassUnrealize                 ,
        setWidgetClassUnrealize                 ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_unrealize                   ,
    #endif

    -- ** unroot #attr:unroot#
    -- | Called when the widget is about to be removed from its
    --   @GtkRoot@ widget. Must chain up

        clearWidgetClassUnroot                  ,
        getWidgetClassUnroot                    ,
        setWidgetClassUnroot                    ,
    #if defined(ENABLE_OVERLOADING)
        widgetClass_unroot                      ,
    #endif

        ) where

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

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

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

    #else
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GLib.Structs.VariantType as GLib.VariantType
    import qualified GI.GObject.Callbacks as GObject.Callbacks
    import qualified GI.GObject.Structs.InitiallyUnownedClass as GObject.InitiallyUnownedClass
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.BuilderScope as Gtk.BuilderScope
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Shortcut as Gtk.Shortcut

    #endif

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

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

    instance BoxedPtr WidgetClass where
        boxedPtrCopy :: WidgetClass -> IO WidgetClass
    boxedPtrCopy = \WidgetClass
    p -> WidgetClass
    -> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr WidgetClass
    p (Int -> Ptr WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    408 (Ptr WidgetClass -> IO (Ptr WidgetClass))
    -> (Ptr WidgetClass -> IO WidgetClass)
    -> Ptr WidgetClass
    -> IO WidgetClass
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr WidgetClass -> WidgetClass)
    -> Ptr WidgetClass -> IO WidgetClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr WidgetClass -> WidgetClass
    WidgetClass)
        boxedPtrFree :: WidgetClass -> IO ()
    boxedPtrFree = \WidgetClass
    x -> WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr WidgetClass
    x Ptr WidgetClass -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr WidgetClass where
        boxedPtrCalloc :: IO (Ptr WidgetClass)
    boxedPtrCalloc = Int -> IO (Ptr WidgetClass)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    408

    -- | Construct a t'WidgetClass' struct initialized to zero.
    newZeroWidgetClass :: MonadIO m => m WidgetClass
    newZeroWidgetClass :: forall (m :: * -> *). MonadIO m => m WidgetClass
    newZeroWidgetClass = IO WidgetClass -> m WidgetClass
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO WidgetClass -> m WidgetClass)
    -> IO WidgetClass -> m WidgetClass
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr WidgetClass)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr WidgetClass)
    -> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr WidgetClass -> WidgetClass)
    -> Ptr WidgetClass -> IO WidgetClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr WidgetClass -> WidgetClass
    WidgetClass

    instance tag ~ 'AttrSet => Constructible WidgetClass tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr WidgetClass -> WidgetClass)
    -> [AttrOp WidgetClass tag] -> m WidgetClass
    new ManagedPtr WidgetClass -> WidgetClass
    _ [AttrOp WidgetClass tag]
    attrs = do
            o <- m WidgetClass
    forall (m :: * -> *). MonadIO m => m WidgetClass
    newZeroWidgetClass
            GI.Attributes.set o attrs
            return o

    -- | Get the value of the “@parent_class@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #parentClass
    -- @
    getWidgetClassParentClass :: MonadIO m => WidgetClass -> m GObject.InitiallyUnownedClass.InitiallyUnownedClass
    getWidgetClassParentClass :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m InitiallyUnownedClass
    getWidgetClassParentClass WidgetClass
    s = IO InitiallyUnownedClass -> m InitiallyUnownedClass
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO InitiallyUnownedClass -> m InitiallyUnownedClass)
    -> IO InitiallyUnownedClass -> m InitiallyUnownedClass
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO InitiallyUnownedClass)
    -> IO InitiallyUnownedClass
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO InitiallyUnownedClass)
     -> IO InitiallyUnownedClass)
    -> (Ptr WidgetClass -> IO InitiallyUnownedClass)
    -> IO InitiallyUnownedClass
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        let val :: Ptr InitiallyUnownedClass
    val = Ptr WidgetClass
    ptr Ptr WidgetClass -> Int -> Ptr InitiallyUnownedClass
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0 :: (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
        val' <- ((ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
    -> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
    GObject.InitiallyUnownedClass.InitiallyUnownedClass) Ptr InitiallyUnownedClass
    val
        return val'

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassParentClassFieldInfo
    instance AttrInfo WidgetClassParentClassFieldInfo where
        type AttrBaseTypeConstraint WidgetClassParentClassFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassParentClassFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint WidgetClassParentClassFieldInfo = (~) (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
        type AttrTransferTypeConstraint WidgetClassParentClassFieldInfo = (~)(Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
        type AttrTransferType WidgetClassParentClassFieldInfo = (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
        type AttrGetType WidgetClassParentClassFieldInfo = GObject.InitiallyUnownedClass.InitiallyUnownedClass
        type AttrLabel WidgetClassParentClassFieldInfo = "parent_class"
        type AttrOrigin WidgetClassParentClassFieldInfo = WidgetClass
        attrGet = getWidgetClassParentClass
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.parentClass"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:parentClass"
            })

    widgetClass_parentClass :: AttrLabelProxy "parentClass"
    widgetClass_parentClass = AttrLabelProxy

    #endif

    -- | Get the value of the “@show@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #show
    -- @
    getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowFieldCallback)
    getWidgetClassShow :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassShow WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    136) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassShowFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@show@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #show 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassShow :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassShow WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    136) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)

    -- | Set the value of the “@show@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #show
    -- @
    clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassShow :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassShow WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    136) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassShowFieldInfo
    instance AttrInfo WidgetClassShowFieldInfo where
        type AttrBaseTypeConstraint WidgetClassShowFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassShowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassShowFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
        type AttrTransferTypeConstraint WidgetClassShowFieldInfo = (~)Gtk.Callbacks.WidgetClassShowFieldCallback
        type AttrTransferType WidgetClassShowFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
        type AttrGetType WidgetClassShowFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowFieldCallback
        type AttrLabel WidgetClassShowFieldInfo = "show"
        type AttrOrigin WidgetClassShowFieldInfo = WidgetClass
        attrGet = getWidgetClassShow
        attrSet = setWidgetClassShow
        attrConstruct = undefined
        attrClear = clearWidgetClassShow
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassShowFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.show"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:show"
            })

    widgetClass_show :: AttrLabelProxy "show"
    widgetClass_show = AttrLabelProxy

    #endif

    -- | Get the value of the “@hide@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #hide
    -- @
    getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassHideFieldCallback)
    getWidgetClassHide :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassHide WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    144) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassHideFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@hide@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #hide 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback -> m ()
    setWidgetClassHide :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassHide WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    144) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)

    -- | Set the value of the “@hide@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #hide
    -- @
    clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassHide :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassHide WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    144) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassHideFieldInfo
    instance AttrInfo WidgetClassHideFieldInfo where
        type AttrBaseTypeConstraint WidgetClassHideFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassHideFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassHideFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
        type AttrTransferTypeConstraint WidgetClassHideFieldInfo = (~)Gtk.Callbacks.WidgetClassHideFieldCallback
        type AttrTransferType WidgetClassHideFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
        type AttrGetType WidgetClassHideFieldInfo = Maybe Gtk.Callbacks.WidgetClassHideFieldCallback
        type AttrLabel WidgetClassHideFieldInfo = "hide"
        type AttrOrigin WidgetClassHideFieldInfo = WidgetClass
        attrGet = getWidgetClassHide
        attrSet = setWidgetClassHide
        attrConstruct = undefined
        attrClear = clearWidgetClassHide
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassHideFieldCallback (Gtk.Callbacks.wrap_WidgetClassHideFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.hide"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:hide"
            })

    widgetClass_hide :: AttrLabelProxy "hide"
    widgetClass_hide = AttrLabelProxy

    #endif

    -- | Get the value of the “@map@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #map
    -- @
    getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMapFieldCallback)
    getWidgetClassMap :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassMap WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    152) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassMapFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@map@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #map 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback -> m ()
    setWidgetClassMap :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassMap WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    152) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)

    -- | Set the value of the “@map@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #map
    -- @
    clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassMap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassMap WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    152) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassMapFieldInfo
    instance AttrInfo WidgetClassMapFieldInfo where
        type AttrBaseTypeConstraint WidgetClassMapFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassMapFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
        type AttrTransferTypeConstraint WidgetClassMapFieldInfo = (~)Gtk.Callbacks.WidgetClassMapFieldCallback
        type AttrTransferType WidgetClassMapFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
        type AttrGetType WidgetClassMapFieldInfo = Maybe Gtk.Callbacks.WidgetClassMapFieldCallback
        type AttrLabel WidgetClassMapFieldInfo = "map"
        type AttrOrigin WidgetClassMapFieldInfo = WidgetClass
        attrGet = getWidgetClassMap
        attrSet = setWidgetClassMap
        attrConstruct = undefined
        attrClear = clearWidgetClassMap
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassMapFieldCallback (Gtk.Callbacks.wrap_WidgetClassMapFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.map"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:map"
            })

    widgetClass_map :: AttrLabelProxy "map"
    widgetClass_map = AttrLabelProxy

    #endif

    -- | Get the value of the “@unmap@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #unmap
    -- @
    getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback)
    getWidgetClassUnmap :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassUnmap WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    160) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassUnmapFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@unmap@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #unmap 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback -> m ()
    setWidgetClassUnmap :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassUnmap WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    160) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)

    -- | Set the value of the “@unmap@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #unmap
    -- @
    clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassUnmap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassUnmap WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    160) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassUnmapFieldInfo
    instance AttrInfo WidgetClassUnmapFieldInfo where
        type AttrBaseTypeConstraint WidgetClassUnmapFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassUnmapFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
        type AttrTransferTypeConstraint WidgetClassUnmapFieldInfo = (~)Gtk.Callbacks.WidgetClassUnmapFieldCallback
        type AttrTransferType WidgetClassUnmapFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
        type AttrGetType WidgetClassUnmapFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback
        type AttrLabel WidgetClassUnmapFieldInfo = "unmap"
        type AttrOrigin WidgetClassUnmapFieldInfo = WidgetClass
        attrGet = getWidgetClassUnmap
        attrSet = setWidgetClassUnmap
        attrConstruct = undefined
        attrClear = clearWidgetClassUnmap
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassUnmapFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnmapFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unmap"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unmap"
            })

    widgetClass_unmap :: AttrLabelProxy "unmap"
    widgetClass_unmap = AttrLabelProxy

    #endif

    -- | Get the value of the “@realize@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #realize
    -- @
    getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback)
    getWidgetClassRealize :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassRealize WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    168) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassRealizeFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@realize@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #realize 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback -> m ()
    setWidgetClassRealize :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassRealize WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    168) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)

    -- | Set the value of the “@realize@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #realize
    -- @
    clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassRealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassRealize WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    168) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassRealizeFieldInfo
    instance AttrInfo WidgetClassRealizeFieldInfo where
        type AttrBaseTypeConstraint WidgetClassRealizeFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassRealizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassRealizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
        type AttrTransferTypeConstraint WidgetClassRealizeFieldInfo = (~)Gtk.Callbacks.WidgetClassRealizeFieldCallback
        type AttrTransferType WidgetClassRealizeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
        type AttrGetType WidgetClassRealizeFieldInfo = Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback
        type AttrLabel WidgetClassRealizeFieldInfo = "realize"
        type AttrOrigin WidgetClassRealizeFieldInfo = WidgetClass
        attrGet = getWidgetClassRealize
        attrSet = setWidgetClassRealize
        attrConstruct = undefined
        attrClear = clearWidgetClassRealize
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassRealizeFieldCallback (Gtk.Callbacks.wrap_WidgetClassRealizeFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.realize"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:realize"
            })

    widgetClass_realize :: AttrLabelProxy "realize"
    widgetClass_realize = AttrLabelProxy

    #endif

    -- | Get the value of the “@unrealize@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #unrealize
    -- @
    getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback)
    getWidgetClassUnrealize :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassUnrealize WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    176) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassUnrealizeFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@unrealize@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #unrealize 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback -> m ()
    setWidgetClassUnrealize :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassUnrealize WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    176) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)

    -- | Set the value of the “@unrealize@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #unrealize
    -- @
    clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassUnrealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassUnrealize WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    176) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassUnrealizeFieldInfo
    instance AttrInfo WidgetClassUnrealizeFieldInfo where
        type AttrBaseTypeConstraint WidgetClassUnrealizeFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassUnrealizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassUnrealizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
        type AttrTransferTypeConstraint WidgetClassUnrealizeFieldInfo = (~)Gtk.Callbacks.WidgetClassUnrealizeFieldCallback
        type AttrTransferType WidgetClassUnrealizeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
        type AttrGetType WidgetClassUnrealizeFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback
        type AttrLabel WidgetClassUnrealizeFieldInfo = "unrealize"
        type AttrOrigin WidgetClassUnrealizeFieldInfo = WidgetClass
        attrGet = getWidgetClassUnrealize
        attrSet = setWidgetClassUnrealize
        attrConstruct = undefined
        attrClear = clearWidgetClassUnrealize
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassUnrealizeFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnrealizeFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unrealize"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unrealize"
            })

    widgetClass_unrealize :: AttrLabelProxy "unrealize"
    widgetClass_unrealize = AttrLabelProxy

    #endif

    -- | Get the value of the “@root@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #root
    -- @
    getWidgetClassRoot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRootFieldCallback)
    getWidgetClassRoot :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassRoot WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    184) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassRootFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@root@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #root 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassRoot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback -> m ()
    setWidgetClassRoot :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassRoot WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    184) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)

    -- | Set the value of the “@root@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #root
    -- @
    clearWidgetClassRoot :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassRoot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassRoot WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    184) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassRootFieldInfo
    instance AttrInfo WidgetClassRootFieldInfo where
        type AttrBaseTypeConstraint WidgetClassRootFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassRootFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassRootFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
        type AttrTransferTypeConstraint WidgetClassRootFieldInfo = (~)Gtk.Callbacks.WidgetClassRootFieldCallback
        type AttrTransferType WidgetClassRootFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
        type AttrGetType WidgetClassRootFieldInfo = Maybe Gtk.Callbacks.WidgetClassRootFieldCallback
        type AttrLabel WidgetClassRootFieldInfo = "root"
        type AttrOrigin WidgetClassRootFieldInfo = WidgetClass
        attrGet = getWidgetClassRoot
        attrSet = setWidgetClassRoot
        attrConstruct = undefined
        attrClear = clearWidgetClassRoot
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassRootFieldCallback (Gtk.Callbacks.wrap_WidgetClassRootFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.root"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:root"
            })

    widgetClass_root :: AttrLabelProxy "root"
    widgetClass_root = AttrLabelProxy

    #endif

    -- | Get the value of the “@unroot@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #unroot
    -- @
    getWidgetClassUnroot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrootFieldCallback)
    getWidgetClassUnroot :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
    getWidgetClassUnroot WidgetClass
    s = IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassShowFieldCallback)
     -> m (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    -> m (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
     -> IO (Maybe WidgetClassShowFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
    -> IO (Maybe WidgetClassShowFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> IO (FunPtr C_WidgetClassShowFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    192) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
    val' -> do
            let val'' :: WidgetClassShowFieldCallback
    val'' = FunPtr C_WidgetClassShowFieldCallback
    -> WidgetClassShowFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_WidgetClassUnrootFieldCallback FunPtr C_WidgetClassShowFieldCallback
    val'
            WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassShowFieldCallback
    val''
        return result

    -- | Set the value of the “@unroot@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #unroot 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassUnroot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback -> m ()
    setWidgetClassUnroot :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
    setWidgetClassUnroot WidgetClass
    s FunPtr C_WidgetClassShowFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    192) (FunPtr C_WidgetClassShowFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)

    -- | Set the value of the “@unroot@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #unroot
    -- @
    clearWidgetClassUnroot :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassUnroot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassUnroot WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassShowFieldCallback)
    -> FunPtr C_WidgetClassShowFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    192) (FunPtr C_WidgetClassShowFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassUnrootFieldInfo
    instance AttrInfo WidgetClassUnrootFieldInfo where
        type AttrBaseTypeConstraint WidgetClassUnrootFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassUnrootFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassUnrootFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
        type AttrTransferTypeConstraint WidgetClassUnrootFieldInfo = (~)Gtk.Callbacks.WidgetClassUnrootFieldCallback
        type AttrTransferType WidgetClassUnrootFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
        type AttrGetType WidgetClassUnrootFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnrootFieldCallback
        type AttrLabel WidgetClassUnrootFieldInfo = "unroot"
        type AttrOrigin WidgetClassUnrootFieldInfo = WidgetClass
        attrGet = getWidgetClassUnroot
        attrSet = setWidgetClassUnroot
        attrConstruct = undefined
        attrClear = clearWidgetClassUnroot
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassUnrootFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnrootFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unroot"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unroot"
            })

    widgetClass_unroot :: AttrLabelProxy "unroot"
    widgetClass_unroot = AttrLabelProxy

    #endif

    -- | Get the value of the “@size_allocate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #sizeAllocate
    -- @
    getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback)
    getWidgetClassSizeAllocate :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)
    getWidgetClassSizeAllocate WidgetClass
    s = IO (Maybe WidgetClassSizeAllocateFieldCallback)
    -> m (Maybe WidgetClassSizeAllocateFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassSizeAllocateFieldCallback)
     -> m (Maybe WidgetClassSizeAllocateFieldCallback))
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback)
    -> m (Maybe WidgetClassSizeAllocateFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
     -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    200) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassSizeAllocateFieldCallback
    val' -> do
            let val'' :: WidgetClassSizeAllocateFieldCallback
    val'' = FunPtr C_WidgetClassSizeAllocateFieldCallback
    -> WidgetClassSizeAllocateFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassSizeAllocateFieldCallback
    -> a -> Int32 -> Int32 -> Int32 -> m ()
    Gtk.Callbacks.dynamic_WidgetClassSizeAllocateFieldCallback FunPtr C_WidgetClassSizeAllocateFieldCallback
    val'
            WidgetClassSizeAllocateFieldCallback
    -> IO WidgetClassSizeAllocateFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassSizeAllocateFieldCallback
    val''
        return result

    -- | Set the value of the “@size_allocate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #sizeAllocate 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback -> m ()
    setWidgetClassSizeAllocate :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()
    setWidgetClassSizeAllocate WidgetClass
    s FunPtr C_WidgetClassSizeAllocateFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    -> FunPtr C_WidgetClassSizeAllocateFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    200) (FunPtr C_WidgetClassSizeAllocateFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)

    -- | Set the value of the “@size_allocate@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #sizeAllocate
    -- @
    clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassSizeAllocate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassSizeAllocate WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    -> FunPtr C_WidgetClassSizeAllocateFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    200) (FunPtr C_WidgetClassSizeAllocateFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSizeAllocateFieldInfo
    instance AttrInfo WidgetClassSizeAllocateFieldInfo where
        type AttrBaseTypeConstraint WidgetClassSizeAllocateFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassSizeAllocateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassSizeAllocateFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
        type AttrTransferTypeConstraint WidgetClassSizeAllocateFieldInfo = (~)Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback
        type AttrTransferType WidgetClassSizeAllocateFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
        type AttrGetType WidgetClassSizeAllocateFieldInfo = Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback
        type AttrLabel WidgetClassSizeAllocateFieldInfo = "size_allocate"
        type AttrOrigin WidgetClassSizeAllocateFieldInfo = WidgetClass
        attrGet = getWidgetClassSizeAllocate
        attrSet = setWidgetClassSizeAllocate
        attrConstruct = undefined
        attrClear = clearWidgetClassSizeAllocate
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassSizeAllocateFieldCallback (Gtk.Callbacks.wrap_WidgetClassSizeAllocateFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.sizeAllocate"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:sizeAllocate"
            })

    widgetClass_sizeAllocate :: AttrLabelProxy "sizeAllocate"
    widgetClass_sizeAllocate = AttrLabelProxy

    #endif

    -- | Get the value of the “@state_flags_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #stateFlagsChanged
    -- @
    getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback)
    getWidgetClassStateFlagsChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
    getWidgetClassStateFlagsChanged WidgetClass
    s = IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
    -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
     -> m (Maybe WidgetClassStateFlagsChangedFieldCallback))
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
    -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
     -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    208) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val' -> do
            let val'' :: WidgetClassStateFlagsChangedFieldCallback
    val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> WidgetClassStateFlagsChangedFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> a -> [StateFlags] -> m ()
    Gtk.Callbacks.dynamic_WidgetClassStateFlagsChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val'
            WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassStateFlagsChangedFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassStateFlagsChangedFieldCallback
    val''
        return result

    -- | Set the value of the “@state_flags_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #stateFlagsChanged 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback -> m ()
    setWidgetClassStateFlagsChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
    setWidgetClassStateFlagsChanged WidgetClass
    s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    208) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)

    -- | Set the value of the “@state_flags_changed@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #stateFlagsChanged
    -- @
    clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassStateFlagsChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassStateFlagsChanged WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    208) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassStateFlagsChangedFieldInfo
    instance AttrInfo WidgetClassStateFlagsChangedFieldInfo where
        type AttrBaseTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassStateFlagsChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
        type AttrTransferTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback
        type AttrTransferType WidgetClassStateFlagsChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
        type AttrGetType WidgetClassStateFlagsChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback
        type AttrLabel WidgetClassStateFlagsChangedFieldInfo = "state_flags_changed"
        type AttrOrigin WidgetClassStateFlagsChangedFieldInfo = WidgetClass
        attrGet = getWidgetClassStateFlagsChanged
        attrSet = setWidgetClassStateFlagsChanged
        attrConstruct = undefined
        attrClear = clearWidgetClassStateFlagsChanged
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassStateFlagsChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStateFlagsChangedFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.stateFlagsChanged"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:stateFlagsChanged"
            })

    widgetClass_stateFlagsChanged :: AttrLabelProxy "stateFlagsChanged"
    widgetClass_stateFlagsChanged = AttrLabelProxy

    #endif

    -- | Get the value of the “@direction_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #directionChanged
    -- @
    getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback)
    getWidgetClassDirectionChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)
    getWidgetClassDirectionChanged WidgetClass
    s = IO (Maybe WidgetClassDirectionChangedFieldCallback)
    -> m (Maybe WidgetClassDirectionChangedFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassDirectionChangedFieldCallback)
     -> m (Maybe WidgetClassDirectionChangedFieldCallback))
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback)
    -> m (Maybe WidgetClassDirectionChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
     -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    216) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val' -> do
            let val'' :: WidgetClassDirectionChangedFieldCallback
    val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> WidgetClassDirectionChangedFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> a -> TextDirection -> m ()
    Gtk.Callbacks.dynamic_WidgetClassDirectionChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val'
            WidgetClassDirectionChangedFieldCallback
    -> IO WidgetClassDirectionChangedFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassDirectionChangedFieldCallback
    val''
        return result

    -- | Set the value of the “@direction_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #directionChanged 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback -> m ()
    setWidgetClassDirectionChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
    setWidgetClassDirectionChanged WidgetClass
    s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    216) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)

    -- | Set the value of the “@direction_changed@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #directionChanged
    -- @
    clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassDirectionChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassDirectionChanged WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    216) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassDirectionChangedFieldInfo
    instance AttrInfo WidgetClassDirectionChangedFieldInfo where
        type AttrBaseTypeConstraint WidgetClassDirectionChangedFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassDirectionChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassDirectionChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
        type AttrTransferTypeConstraint WidgetClassDirectionChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback
        type AttrTransferType WidgetClassDirectionChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
        type AttrGetType WidgetClassDirectionChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback
        type AttrLabel WidgetClassDirectionChangedFieldInfo = "direction_changed"
        type AttrOrigin WidgetClassDirectionChangedFieldInfo = WidgetClass
        attrGet = getWidgetClassDirectionChanged
        attrSet = setWidgetClassDirectionChanged
        attrConstruct = undefined
        attrClear = clearWidgetClassDirectionChanged
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassDirectionChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDirectionChangedFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.directionChanged"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:directionChanged"
            })

    widgetClass_directionChanged :: AttrLabelProxy "directionChanged"
    widgetClass_directionChanged = AttrLabelProxy

    #endif

    -- | Get the value of the “@get_request_mode@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #getRequestMode
    -- @
    getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback)
    getWidgetClassGetRequestMode :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)
    getWidgetClassGetRequestMode WidgetClass
    s = IO (Maybe WidgetClassGetRequestModeFieldCallback)
    -> m (Maybe WidgetClassGetRequestModeFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassGetRequestModeFieldCallback)
     -> m (Maybe WidgetClassGetRequestModeFieldCallback))
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback)
    -> m (Maybe WidgetClassGetRequestModeFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
     -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    224) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassGetRequestModeFieldCallback
    val' -> do
            let val'' :: WidgetClassGetRequestModeFieldCallback
    val'' = FunPtr C_WidgetClassGetRequestModeFieldCallback
    -> WidgetClassGetRequestModeFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassGetRequestModeFieldCallback
    -> a -> m SizeRequestMode
    Gtk.Callbacks.dynamic_WidgetClassGetRequestModeFieldCallback FunPtr C_WidgetClassGetRequestModeFieldCallback
    val'
            WidgetClassGetRequestModeFieldCallback
    -> IO WidgetClassGetRequestModeFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassGetRequestModeFieldCallback
    val''
        return result

    -- | Set the value of the “@get_request_mode@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #getRequestMode 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback -> m ()
    setWidgetClassGetRequestMode :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()
    setWidgetClassGetRequestMode WidgetClass
    s FunPtr C_WidgetClassGetRequestModeFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    -> FunPtr C_WidgetClassGetRequestModeFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    224) (FunPtr C_WidgetClassGetRequestModeFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)

    -- | Set the value of the “@get_request_mode@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #getRequestMode
    -- @
    clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassGetRequestMode :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassGetRequestMode WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    -> FunPtr C_WidgetClassGetRequestModeFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    224) (FunPtr C_WidgetClassGetRequestModeFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassGetRequestModeFieldInfo
    instance AttrInfo WidgetClassGetRequestModeFieldInfo where
        type AttrBaseTypeConstraint WidgetClassGetRequestModeFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassGetRequestModeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassGetRequestModeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
        type AttrTransferTypeConstraint WidgetClassGetRequestModeFieldInfo = (~)Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback
        type AttrTransferType WidgetClassGetRequestModeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
        type AttrGetType WidgetClassGetRequestModeFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback
        type AttrLabel WidgetClassGetRequestModeFieldInfo = "get_request_mode"
        type AttrOrigin WidgetClassGetRequestModeFieldInfo = WidgetClass
        attrGet = getWidgetClassGetRequestMode
        attrSet = setWidgetClassGetRequestMode
        attrConstruct = undefined
        attrClear = clearWidgetClassGetRequestMode
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassGetRequestModeFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetRequestModeFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getRequestMode"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getRequestMode"
            })

    widgetClass_getRequestMode :: AttrLabelProxy "getRequestMode"
    widgetClass_getRequestMode = AttrLabelProxy

    #endif

    -- | Get the value of the “@measure@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #measure
    -- @
    getWidgetClassMeasure :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMeasureFieldCallback)
    getWidgetClassMeasure :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassMeasureFieldCallback)
    getWidgetClassMeasure WidgetClass
    s = IO (Maybe WidgetClassMeasureFieldCallback)
    -> m (Maybe WidgetClassMeasureFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassMeasureFieldCallback)
     -> m (Maybe WidgetClassMeasureFieldCallback))
    -> IO (Maybe WidgetClassMeasureFieldCallback)
    -> m (Maybe WidgetClassMeasureFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
    -> IO (Maybe WidgetClassMeasureFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
     -> IO (Maybe WidgetClassMeasureFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
    -> IO (Maybe WidgetClassMeasureFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
    -> IO (FunPtr C_WidgetClassMeasureFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    232) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassMeasureFieldCallback
    val' -> do
            let val'' :: WidgetClassMeasureFieldCallback
    val'' = FunPtr C_WidgetClassMeasureFieldCallback
    -> WidgetClassMeasureFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassMeasureFieldCallback
    -> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)
    Gtk.Callbacks.dynamic_WidgetClassMeasureFieldCallback FunPtr C_WidgetClassMeasureFieldCallback
    val'
            WidgetClassMeasureFieldCallback
    -> IO WidgetClassMeasureFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassMeasureFieldCallback
    val''
        return result

    -- | Set the value of the “@measure@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #measure 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassMeasure :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback -> m ()
    setWidgetClassMeasure :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassMeasureFieldCallback -> m ()
    setWidgetClassMeasure WidgetClass
    s FunPtr C_WidgetClassMeasureFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
    -> FunPtr C_WidgetClassMeasureFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    232) (FunPtr C_WidgetClassMeasureFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)

    -- | Set the value of the “@measure@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #measure
    -- @
    clearWidgetClassMeasure :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassMeasure :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassMeasure WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
    -> FunPtr C_WidgetClassMeasureFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    232) (FunPtr C_WidgetClassMeasureFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassMeasureFieldInfo
    instance AttrInfo WidgetClassMeasureFieldInfo where
        type AttrBaseTypeConstraint WidgetClassMeasureFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassMeasureFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassMeasureFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
        type AttrTransferTypeConstraint WidgetClassMeasureFieldInfo = (~)Gtk.Callbacks.WidgetClassMeasureFieldCallback
        type AttrTransferType WidgetClassMeasureFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
        type AttrGetType WidgetClassMeasureFieldInfo = Maybe Gtk.Callbacks.WidgetClassMeasureFieldCallback
        type AttrLabel WidgetClassMeasureFieldInfo = "measure"
        type AttrOrigin WidgetClassMeasureFieldInfo = WidgetClass
        attrGet = getWidgetClassMeasure
        attrSet = setWidgetClassMeasure
        attrConstruct = undefined
        attrClear = clearWidgetClassMeasure
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassMeasureFieldCallback (Gtk.Callbacks.wrap_WidgetClassMeasureFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.measure"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:measure"
            })

    widgetClass_measure :: AttrLabelProxy "measure"
    widgetClass_measure = AttrLabelProxy

    #endif

    -- | Get the value of the “@mnemonic_activate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #mnemonicActivate
    -- @
    getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback)
    getWidgetClassMnemonicActivate :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
    getWidgetClassMnemonicActivate WidgetClass
    s = IO (Maybe WidgetClassMnemonicActivateFieldCallback)
    -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassMnemonicActivateFieldCallback)
     -> m (Maybe WidgetClassMnemonicActivateFieldCallback))
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
    -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
     -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    240) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassMnemonicActivateFieldCallback
    val' -> do
            let val'' :: WidgetClassMnemonicActivateFieldCallback
    val'' = FunPtr C_WidgetClassMnemonicActivateFieldCallback
    -> WidgetClassMnemonicActivateFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassMnemonicActivateFieldCallback
    -> a -> Bool -> m Bool
    Gtk.Callbacks.dynamic_WidgetClassMnemonicActivateFieldCallback FunPtr C_WidgetClassMnemonicActivateFieldCallback
    val'
            WidgetClassMnemonicActivateFieldCallback
    -> IO WidgetClassMnemonicActivateFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassMnemonicActivateFieldCallback
    val''
        return result

    -- | Set the value of the “@mnemonic_activate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #mnemonicActivate 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback -> m ()
    setWidgetClassMnemonicActivate :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()
    setWidgetClassMnemonicActivate WidgetClass
    s FunPtr C_WidgetClassMnemonicActivateFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    -> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    240) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)

    -- | Set the value of the “@mnemonic_activate@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #mnemonicActivate
    -- @
    clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassMnemonicActivate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassMnemonicActivate WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    -> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    240) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassMnemonicActivateFieldInfo
    instance AttrInfo WidgetClassMnemonicActivateFieldInfo where
        type AttrBaseTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassMnemonicActivateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
        type AttrTransferTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~)Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback
        type AttrTransferType WidgetClassMnemonicActivateFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
        type AttrGetType WidgetClassMnemonicActivateFieldInfo = Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback
        type AttrLabel WidgetClassMnemonicActivateFieldInfo = "mnemonic_activate"
        type AttrOrigin WidgetClassMnemonicActivateFieldInfo = WidgetClass
        attrGet = getWidgetClassMnemonicActivate
        attrSet = setWidgetClassMnemonicActivate
        attrConstruct = undefined
        attrClear = clearWidgetClassMnemonicActivate
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassMnemonicActivateFieldCallback (Gtk.Callbacks.wrap_WidgetClassMnemonicActivateFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.mnemonicActivate"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:mnemonicActivate"
            })

    widgetClass_mnemonicActivate :: AttrLabelProxy "mnemonicActivate"
    widgetClass_mnemonicActivate = AttrLabelProxy

    #endif

    -- | Get the value of the “@grab_focus@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #grabFocus
    -- @
    getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback)
    getWidgetClassGrabFocus :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassGrabFocusFieldCallback)
    getWidgetClassGrabFocus WidgetClass
    s = IO (Maybe WidgetClassGrabFocusFieldCallback)
    -> m (Maybe WidgetClassGrabFocusFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassGrabFocusFieldCallback)
     -> m (Maybe WidgetClassGrabFocusFieldCallback))
    -> IO (Maybe WidgetClassGrabFocusFieldCallback)
    -> m (Maybe WidgetClassGrabFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassGrabFocusFieldCallback))
    -> IO (Maybe WidgetClassGrabFocusFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassGrabFocusFieldCallback))
     -> IO (Maybe WidgetClassGrabFocusFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassGrabFocusFieldCallback))
    -> IO (Maybe WidgetClassGrabFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
    -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    248) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassGrabFocusFieldCallback
    val' -> do
            let val'' :: WidgetClassGrabFocusFieldCallback
    val'' = FunPtr C_WidgetClassGrabFocusFieldCallback
    -> WidgetClassGrabFocusFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m Bool
    Gtk.Callbacks.dynamic_WidgetClassGrabFocusFieldCallback FunPtr C_WidgetClassGrabFocusFieldCallback
    val'
            WidgetClassGrabFocusFieldCallback
    -> IO WidgetClassGrabFocusFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassGrabFocusFieldCallback
    val''
        return result

    -- | Set the value of the “@grab_focus@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #grabFocus 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback -> m ()
    setWidgetClassGrabFocus :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassGrabFocusFieldCallback -> m ()
    setWidgetClassGrabFocus WidgetClass
    s FunPtr C_WidgetClassGrabFocusFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
    -> FunPtr C_WidgetClassGrabFocusFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    248) (FunPtr C_WidgetClassGrabFocusFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)

    -- | Set the value of the “@grab_focus@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #grabFocus
    -- @
    clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassGrabFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassGrabFocus WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
    -> FunPtr C_WidgetClassGrabFocusFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    248) (FunPtr C_WidgetClassGrabFocusFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassGrabFocusFieldInfo
    instance AttrInfo WidgetClassGrabFocusFieldInfo where
        type AttrBaseTypeConstraint WidgetClassGrabFocusFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassGrabFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassGrabFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
        type AttrTransferTypeConstraint WidgetClassGrabFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabFocusFieldCallback
        type AttrTransferType WidgetClassGrabFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
        type AttrGetType WidgetClassGrabFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback
        type AttrLabel WidgetClassGrabFocusFieldInfo = "grab_focus"
        type AttrOrigin WidgetClassGrabFocusFieldInfo = WidgetClass
        attrGet = getWidgetClassGrabFocus
        attrSet = setWidgetClassGrabFocus
        attrConstruct = undefined
        attrClear = clearWidgetClassGrabFocus
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassGrabFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabFocusFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.grabFocus"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:grabFocus"
            })

    widgetClass_grabFocus :: AttrLabelProxy "grabFocus"
    widgetClass_grabFocus = AttrLabelProxy

    #endif

    -- | Get the value of the “@focus@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #focus
    -- @
    getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback)
    getWidgetClassFocus :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
    getWidgetClassFocus WidgetClass
    s = IO (Maybe WidgetClassFocusFieldCallback)
    -> m (Maybe WidgetClassFocusFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassFocusFieldCallback)
     -> m (Maybe WidgetClassFocusFieldCallback))
    -> IO (Maybe WidgetClassFocusFieldCallback)
    -> m (Maybe WidgetClassFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
    -> IO (Maybe WidgetClassFocusFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
     -> IO (Maybe WidgetClassFocusFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
    -> IO (Maybe WidgetClassFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    -> IO (FunPtr C_WidgetClassFocusFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    256) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassFocusFieldCallback
    val' -> do
            let val'' :: WidgetClassFocusFieldCallback
    val'' = FunPtr C_WidgetClassFocusFieldCallback
    -> WidgetClassFocusFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassFocusFieldCallback
    -> a -> DirectionType -> m Bool
    Gtk.Callbacks.dynamic_WidgetClassFocusFieldCallback FunPtr C_WidgetClassFocusFieldCallback
    val'
            WidgetClassFocusFieldCallback -> IO WidgetClassFocusFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassFocusFieldCallback
    val''
        return result

    -- | Set the value of the “@focus@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #focus 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback -> m ()
    setWidgetClassFocus :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
    setWidgetClassFocus WidgetClass
    s FunPtr C_WidgetClassFocusFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    -> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    256) (FunPtr C_WidgetClassFocusFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)

    -- | Set the value of the “@focus@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #focus
    -- @
    clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassFocus WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    -> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    256) (FunPtr C_WidgetClassFocusFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassFocusFieldInfo
    instance AttrInfo WidgetClassFocusFieldInfo where
        type AttrBaseTypeConstraint WidgetClassFocusFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
        type AttrTransferTypeConstraint WidgetClassFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusFieldCallback
        type AttrTransferType WidgetClassFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
        type AttrGetType WidgetClassFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback
        type AttrLabel WidgetClassFocusFieldInfo = "focus"
        type AttrOrigin WidgetClassFocusFieldInfo = WidgetClass
        attrGet = getWidgetClassFocus
        attrSet = setWidgetClassFocus
        attrConstruct = undefined
        attrClear = clearWidgetClassFocus
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.focus"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:focus"
            })

    widgetClass_focus :: AttrLabelProxy "focus"
    widgetClass_focus = AttrLabelProxy

    #endif

    -- | Get the value of the “@set_focus_child@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #setFocusChild
    -- @
    getWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback)
    getWidgetClassSetFocusChild :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassSetFocusChildFieldCallback)
    getWidgetClassSetFocusChild WidgetClass
    s = IO (Maybe WidgetClassSetFocusChildFieldCallback)
    -> m (Maybe WidgetClassSetFocusChildFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassSetFocusChildFieldCallback)
     -> m (Maybe WidgetClassSetFocusChildFieldCallback))
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback)
    -> m (Maybe WidgetClassSetFocusChildFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
     -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    -> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    264) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassSetFocusChildFieldCallback
    val' -> do
            let val'' :: WidgetClassSetFocusChildFieldCallback
    val'' = FunPtr C_WidgetClassSetFocusChildFieldCallback
    -> WidgetClassSetFocusChildFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    FunPtr C_WidgetClassSetFocusChildFieldCallback
    -> a -> Maybe b -> m ()
    Gtk.Callbacks.dynamic_WidgetClassSetFocusChildFieldCallback FunPtr C_WidgetClassSetFocusChildFieldCallback
    val'
            WidgetClassSetFocusChildFieldCallback
    -> IO WidgetClassSetFocusChildFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassSetFocusChildFieldCallback
    val''
        return result

    -- | Set the value of the “@set_focus_child@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #setFocusChild 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback -> m ()
    setWidgetClassSetFocusChild :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassSetFocusChildFieldCallback -> m ()
    setWidgetClassSetFocusChild WidgetClass
    s FunPtr C_WidgetClassSetFocusChildFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    -> FunPtr C_WidgetClassSetFocusChildFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    264) (FunPtr C_WidgetClassSetFocusChildFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)

    -- | Set the value of the “@set_focus_child@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #setFocusChild
    -- @
    clearWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassSetFocusChild :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassSetFocusChild WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    -> FunPtr C_WidgetClassSetFocusChildFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    264) (FunPtr C_WidgetClassSetFocusChildFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetFocusChildFieldInfo
    instance AttrInfo WidgetClassSetFocusChildFieldInfo where
        type AttrBaseTypeConstraint WidgetClassSetFocusChildFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassSetFocusChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassSetFocusChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
        type AttrTransferTypeConstraint WidgetClassSetFocusChildFieldInfo = (~)Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback
        type AttrTransferType WidgetClassSetFocusChildFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
        type AttrGetType WidgetClassSetFocusChildFieldInfo = Maybe Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback
        type AttrLabel WidgetClassSetFocusChildFieldInfo = "set_focus_child"
        type AttrOrigin WidgetClassSetFocusChildFieldInfo = WidgetClass
        attrGet = getWidgetClassSetFocusChild
        attrSet = setWidgetClassSetFocusChild
        attrConstruct = undefined
        attrClear = clearWidgetClassSetFocusChild
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassSetFocusChildFieldCallback (Gtk.Callbacks.wrap_WidgetClassSetFocusChildFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.setFocusChild"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:setFocusChild"
            })

    widgetClass_setFocusChild :: AttrLabelProxy "setFocusChild"
    widgetClass_setFocusChild = AttrLabelProxy

    #endif

    -- | Get the value of the “@move_focus@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #moveFocus
    -- @
    getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback)
    getWidgetClassMoveFocus :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)
    getWidgetClassMoveFocus WidgetClass
    s = IO (Maybe WidgetClassMoveFocusFieldCallback)
    -> m (Maybe WidgetClassMoveFocusFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassMoveFocusFieldCallback)
     -> m (Maybe WidgetClassMoveFocusFieldCallback))
    -> IO (Maybe WidgetClassMoveFocusFieldCallback)
    -> m (Maybe WidgetClassMoveFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassMoveFocusFieldCallback))
    -> IO (Maybe WidgetClassMoveFocusFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassMoveFocusFieldCallback))
     -> IO (Maybe WidgetClassMoveFocusFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassMoveFocusFieldCallback))
    -> IO (Maybe WidgetClassMoveFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    272) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val' -> do
            let val'' :: WidgetClassMoveFocusFieldCallback
    val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> WidgetClassMoveFocusFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> a -> DirectionType -> m ()
    Gtk.Callbacks.dynamic_WidgetClassMoveFocusFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val'
            WidgetClassMoveFocusFieldCallback
    -> IO WidgetClassMoveFocusFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassMoveFocusFieldCallback
    val''
        return result

    -- | Set the value of the “@move_focus@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #moveFocus 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback -> m ()
    setWidgetClassMoveFocus :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
    setWidgetClassMoveFocus WidgetClass
    s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    272) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)

    -- | Set the value of the “@move_focus@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #moveFocus
    -- @
    clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassMoveFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassMoveFocus WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    272) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassMoveFocusFieldInfo
    instance AttrInfo WidgetClassMoveFocusFieldInfo where
        type AttrBaseTypeConstraint WidgetClassMoveFocusFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassMoveFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassMoveFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
        type AttrTransferTypeConstraint WidgetClassMoveFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassMoveFocusFieldCallback
        type AttrTransferType WidgetClassMoveFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
        type AttrGetType WidgetClassMoveFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback
        type AttrLabel WidgetClassMoveFocusFieldInfo = "move_focus"
        type AttrOrigin WidgetClassMoveFocusFieldInfo = WidgetClass
        attrGet = getWidgetClassMoveFocus
        attrSet = setWidgetClassMoveFocus
        attrConstruct = undefined
        attrClear = clearWidgetClassMoveFocus
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassMoveFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassMoveFocusFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.moveFocus"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:moveFocus"
            })

    widgetClass_moveFocus :: AttrLabelProxy "moveFocus"
    widgetClass_moveFocus = AttrLabelProxy

    #endif

    -- | Get the value of the “@keynav_failed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #keynavFailed
    -- @
    getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback)
    getWidgetClassKeynavFailed :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
    getWidgetClassKeynavFailed WidgetClass
    s = IO (Maybe WidgetClassFocusFieldCallback)
    -> m (Maybe WidgetClassFocusFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassFocusFieldCallback)
     -> m (Maybe WidgetClassFocusFieldCallback))
    -> IO (Maybe WidgetClassFocusFieldCallback)
    -> m (Maybe WidgetClassFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
    -> IO (Maybe WidgetClassFocusFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
     -> IO (Maybe WidgetClassFocusFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
    -> IO (Maybe WidgetClassFocusFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    -> IO (FunPtr C_WidgetClassFocusFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    280) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassFocusFieldCallback
    val' -> do
            let val'' :: WidgetClassFocusFieldCallback
    val'' = FunPtr C_WidgetClassFocusFieldCallback
    -> WidgetClassFocusFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassFocusFieldCallback
    -> a -> DirectionType -> m Bool
    Gtk.Callbacks.dynamic_WidgetClassKeynavFailedFieldCallback FunPtr C_WidgetClassFocusFieldCallback
    val'
            WidgetClassFocusFieldCallback -> IO WidgetClassFocusFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassFocusFieldCallback
    val''
        return result

    -- | Set the value of the “@keynav_failed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #keynavFailed 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback -> m ()
    setWidgetClassKeynavFailed :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
    setWidgetClassKeynavFailed WidgetClass
    s FunPtr C_WidgetClassFocusFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    -> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    280) (FunPtr C_WidgetClassFocusFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)

    -- | Set the value of the “@keynav_failed@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #keynavFailed
    -- @
    clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassKeynavFailed :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassKeynavFailed WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    -> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    280) (FunPtr C_WidgetClassFocusFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassKeynavFailedFieldInfo
    instance AttrInfo WidgetClassKeynavFailedFieldInfo where
        type AttrBaseTypeConstraint WidgetClassKeynavFailedFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassKeynavFailedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassKeynavFailedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
        type AttrTransferTypeConstraint WidgetClassKeynavFailedFieldInfo = (~)Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback
        type AttrTransferType WidgetClassKeynavFailedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
        type AttrGetType WidgetClassKeynavFailedFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback
        type AttrLabel WidgetClassKeynavFailedFieldInfo = "keynav_failed"
        type AttrOrigin WidgetClassKeynavFailedFieldInfo = WidgetClass
        attrGet = getWidgetClassKeynavFailed
        attrSet = setWidgetClassKeynavFailed
        attrConstruct = undefined
        attrClear = clearWidgetClassKeynavFailed
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassKeynavFailedFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeynavFailedFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.keynavFailed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:keynavFailed"
            })

    widgetClass_keynavFailed :: AttrLabelProxy "keynavFailed"
    widgetClass_keynavFailed = AttrLabelProxy

    #endif

    -- | Get the value of the “@query_tooltip@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #queryTooltip
    -- @
    getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback)
    getWidgetClassQueryTooltip :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)
    getWidgetClassQueryTooltip WidgetClass
    s = IO (Maybe WidgetClassQueryTooltipFieldCallback)
    -> m (Maybe WidgetClassQueryTooltipFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassQueryTooltipFieldCallback)
     -> m (Maybe WidgetClassQueryTooltipFieldCallback))
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback)
    -> m (Maybe WidgetClassQueryTooltipFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
     -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    288) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassQueryTooltipFieldCallback
    val' -> do
            let val'' :: WidgetClassQueryTooltipFieldCallback
    val'' = FunPtr C_WidgetClassQueryTooltipFieldCallback
    -> WidgetClassQueryTooltipFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) =>
    FunPtr C_WidgetClassQueryTooltipFieldCallback
    -> a -> Int32 -> Int32 -> Bool -> b -> m Bool
    Gtk.Callbacks.dynamic_WidgetClassQueryTooltipFieldCallback FunPtr C_WidgetClassQueryTooltipFieldCallback
    val'
            WidgetClassQueryTooltipFieldCallback
    -> IO WidgetClassQueryTooltipFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassQueryTooltipFieldCallback
    val''
        return result

    -- | Set the value of the “@query_tooltip@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #queryTooltip 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback -> m ()
    setWidgetClassQueryTooltip :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()
    setWidgetClassQueryTooltip WidgetClass
    s FunPtr C_WidgetClassQueryTooltipFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    -> FunPtr C_WidgetClassQueryTooltipFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    288) (FunPtr C_WidgetClassQueryTooltipFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)

    -- | Set the value of the “@query_tooltip@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #queryTooltip
    -- @
    clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassQueryTooltip :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassQueryTooltip WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    -> FunPtr C_WidgetClassQueryTooltipFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    288) (FunPtr C_WidgetClassQueryTooltipFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassQueryTooltipFieldInfo
    instance AttrInfo WidgetClassQueryTooltipFieldInfo where
        type AttrBaseTypeConstraint WidgetClassQueryTooltipFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassQueryTooltipFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassQueryTooltipFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
        type AttrTransferTypeConstraint WidgetClassQueryTooltipFieldInfo = (~)Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback
        type AttrTransferType WidgetClassQueryTooltipFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
        type AttrGetType WidgetClassQueryTooltipFieldInfo = Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback
        type AttrLabel WidgetClassQueryTooltipFieldInfo = "query_tooltip"
        type AttrOrigin WidgetClassQueryTooltipFieldInfo = WidgetClass
        attrGet = getWidgetClassQueryTooltip
        attrSet = setWidgetClassQueryTooltip
        attrConstruct = undefined
        attrClear = clearWidgetClassQueryTooltip
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassQueryTooltipFieldCallback (Gtk.Callbacks.wrap_WidgetClassQueryTooltipFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.queryTooltip"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:queryTooltip"
            })

    widgetClass_queryTooltip :: AttrLabelProxy "queryTooltip"
    widgetClass_queryTooltip = AttrLabelProxy

    #endif

    -- | Get the value of the “@compute_expand@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #computeExpand
    -- @
    getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback)
    getWidgetClassComputeExpand :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)
    getWidgetClassComputeExpand WidgetClass
    s = IO (Maybe WidgetClassComputeExpandFieldCallback)
    -> m (Maybe WidgetClassComputeExpandFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassComputeExpandFieldCallback)
     -> m (Maybe WidgetClassComputeExpandFieldCallback))
    -> IO (Maybe WidgetClassComputeExpandFieldCallback)
    -> m (Maybe WidgetClassComputeExpandFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassComputeExpandFieldCallback))
    -> IO (Maybe WidgetClassComputeExpandFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassComputeExpandFieldCallback))
     -> IO (Maybe WidgetClassComputeExpandFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassComputeExpandFieldCallback))
    -> IO (Maybe WidgetClassComputeExpandFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
    -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    296) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassComputeExpandFieldCallback
    val' -> do
            let val'' :: WidgetClassComputeExpandFieldCallback
    val'' = FunPtr C_WidgetClassComputeExpandFieldCallback
    -> WidgetClassComputeExpandFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassComputeExpandFieldCallback
    -> a -> Bool -> Bool -> m ()
    Gtk.Callbacks.dynamic_WidgetClassComputeExpandFieldCallback FunPtr C_WidgetClassComputeExpandFieldCallback
    val'
            WidgetClassComputeExpandFieldCallback
    -> IO WidgetClassComputeExpandFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassComputeExpandFieldCallback
    val''
        return result

    -- | Set the value of the “@compute_expand@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #computeExpand 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback -> m ()
    setWidgetClassComputeExpand :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()
    setWidgetClassComputeExpand WidgetClass
    s FunPtr C_WidgetClassComputeExpandFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
    -> FunPtr C_WidgetClassComputeExpandFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    296) (FunPtr C_WidgetClassComputeExpandFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)

    -- | Set the value of the “@compute_expand@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #computeExpand
    -- @
    clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassComputeExpand :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassComputeExpand WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
    -> FunPtr C_WidgetClassComputeExpandFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    296) (FunPtr C_WidgetClassComputeExpandFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassComputeExpandFieldInfo
    instance AttrInfo WidgetClassComputeExpandFieldInfo where
        type AttrBaseTypeConstraint WidgetClassComputeExpandFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassComputeExpandFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassComputeExpandFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
        type AttrTransferTypeConstraint WidgetClassComputeExpandFieldInfo = (~)Gtk.Callbacks.WidgetClassComputeExpandFieldCallback
        type AttrTransferType WidgetClassComputeExpandFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
        type AttrGetType WidgetClassComputeExpandFieldInfo = Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback
        type AttrLabel WidgetClassComputeExpandFieldInfo = "compute_expand"
        type AttrOrigin WidgetClassComputeExpandFieldInfo = WidgetClass
        attrGet = getWidgetClassComputeExpand
        attrSet = setWidgetClassComputeExpand
        attrConstruct = undefined
        attrClear = clearWidgetClassComputeExpand
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassComputeExpandFieldCallback (Gtk.Callbacks.wrap_WidgetClassComputeExpandFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.computeExpand"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:computeExpand"
            })

    widgetClass_computeExpand :: AttrLabelProxy "computeExpand"
    widgetClass_computeExpand = AttrLabelProxy

    #endif

    -- | Get the value of the “@css_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #cssChanged
    -- @
    getWidgetClassCssChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassCssChangedFieldCallback)
    getWidgetClassCssChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassCssChangedFieldCallback)
    getWidgetClassCssChanged WidgetClass
    s = IO (Maybe WidgetClassCssChangedFieldCallback)
    -> m (Maybe WidgetClassCssChangedFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassCssChangedFieldCallback)
     -> m (Maybe WidgetClassCssChangedFieldCallback))
    -> IO (Maybe WidgetClassCssChangedFieldCallback)
    -> m (Maybe WidgetClassCssChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassCssChangedFieldCallback))
    -> IO (Maybe WidgetClassCssChangedFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassCssChangedFieldCallback))
     -> IO (Maybe WidgetClassCssChangedFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassCssChangedFieldCallback))
    -> IO (Maybe WidgetClassCssChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
    -> IO (FunPtr C_WidgetClassCssChangedFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    304) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassCssChangedFieldCallback
    val' -> do
            let val'' :: WidgetClassCssChangedFieldCallback
    val'' = FunPtr C_WidgetClassCssChangedFieldCallback
    -> WidgetClassCssChangedFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassCssChangedFieldCallback
    -> a -> CssStyleChange -> m ()
    Gtk.Callbacks.dynamic_WidgetClassCssChangedFieldCallback FunPtr C_WidgetClassCssChangedFieldCallback
    val'
            WidgetClassCssChangedFieldCallback
    -> IO WidgetClassCssChangedFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassCssChangedFieldCallback
    val''
        return result

    -- | Set the value of the “@css_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #cssChanged 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassCssChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback -> m ()
    setWidgetClassCssChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassCssChangedFieldCallback -> m ()
    setWidgetClassCssChanged WidgetClass
    s FunPtr C_WidgetClassCssChangedFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
    -> FunPtr C_WidgetClassCssChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    304) (FunPtr C_WidgetClassCssChangedFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)

    -- | Set the value of the “@css_changed@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #cssChanged
    -- @
    clearWidgetClassCssChanged :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassCssChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassCssChanged WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
    -> FunPtr C_WidgetClassCssChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    304) (FunPtr C_WidgetClassCssChangedFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassCssChangedFieldInfo
    instance AttrInfo WidgetClassCssChangedFieldInfo where
        type AttrBaseTypeConstraint WidgetClassCssChangedFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassCssChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassCssChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
        type AttrTransferTypeConstraint WidgetClassCssChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassCssChangedFieldCallback
        type AttrTransferType WidgetClassCssChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
        type AttrGetType WidgetClassCssChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassCssChangedFieldCallback
        type AttrLabel WidgetClassCssChangedFieldInfo = "css_changed"
        type AttrOrigin WidgetClassCssChangedFieldInfo = WidgetClass
        attrGet = getWidgetClassCssChanged
        attrSet = setWidgetClassCssChanged
        attrConstruct = undefined
        attrClear = clearWidgetClassCssChanged
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassCssChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassCssChangedFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.cssChanged"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:cssChanged"
            })

    widgetClass_cssChanged :: AttrLabelProxy "cssChanged"
    widgetClass_cssChanged = AttrLabelProxy

    #endif

    -- | Get the value of the “@system_setting_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #systemSettingChanged
    -- @
    getWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback)
    getWidgetClassSystemSettingChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
    getWidgetClassSystemSettingChanged WidgetClass
    s = IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
    -> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
     -> m (Maybe WidgetClassSystemSettingChangedFieldCallback))
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
    -> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass
      -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
     -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
    -> (Ptr WidgetClass
        -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    312) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val' -> do
            let val'' :: WidgetClassSystemSettingChangedFieldCallback
    val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> WidgetClassSystemSettingChangedFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> a -> SystemSetting -> m ()
    Gtk.Callbacks.dynamic_WidgetClassSystemSettingChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val'
            WidgetClassSystemSettingChangedFieldCallback
    -> IO WidgetClassSystemSettingChangedFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassSystemSettingChangedFieldCallback
    val''
        return result

    -- | Set the value of the “@system_setting_changed@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #systemSettingChanged 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback -> m ()
    setWidgetClassSystemSettingChanged :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
    setWidgetClassSystemSettingChanged WidgetClass
    s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    312) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)

    -- | Set the value of the “@system_setting_changed@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #systemSettingChanged
    -- @
    clearWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassSystemSettingChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassSystemSettingChanged WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    312) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSystemSettingChangedFieldInfo
    instance AttrInfo WidgetClassSystemSettingChangedFieldInfo where
        type AttrBaseTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassSystemSettingChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
        type AttrTransferTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback
        type AttrTransferType WidgetClassSystemSettingChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
        type AttrGetType WidgetClassSystemSettingChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback
        type AttrLabel WidgetClassSystemSettingChangedFieldInfo = "system_setting_changed"
        type AttrOrigin WidgetClassSystemSettingChangedFieldInfo = WidgetClass
        attrGet = getWidgetClassSystemSettingChanged
        attrSet = setWidgetClassSystemSettingChanged
        attrConstruct = undefined
        attrClear = clearWidgetClassSystemSettingChanged
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassSystemSettingChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassSystemSettingChangedFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.systemSettingChanged"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:systemSettingChanged"
            })

    widgetClass_systemSettingChanged :: AttrLabelProxy "systemSettingChanged"
    widgetClass_systemSettingChanged = AttrLabelProxy

    #endif

    -- | Get the value of the “@snapshot@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #snapshot
    -- @
    getWidgetClassSnapshot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSnapshotFieldCallback)
    getWidgetClassSnapshot :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassSnapshotFieldCallback)
    getWidgetClassSnapshot WidgetClass
    s = IO (Maybe WidgetClassSnapshotFieldCallback)
    -> m (Maybe WidgetClassSnapshotFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassSnapshotFieldCallback)
     -> m (Maybe WidgetClassSnapshotFieldCallback))
    -> IO (Maybe WidgetClassSnapshotFieldCallback)
    -> m (Maybe WidgetClassSnapshotFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
    -> IO (Maybe WidgetClassSnapshotFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
     -> IO (Maybe WidgetClassSnapshotFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
    -> IO (Maybe WidgetClassSnapshotFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
    -> IO (FunPtr C_WidgetClassSnapshotFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    320) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassSnapshotFieldCallback
    val' -> do
            let val'' :: WidgetClassSnapshotFieldCallback
    val'' = FunPtr C_WidgetClassSnapshotFieldCallback
    -> WidgetClassSnapshotFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWidget a, IsSnapshot b) =>
    FunPtr C_WidgetClassSnapshotFieldCallback -> a -> b -> m ()
    Gtk.Callbacks.dynamic_WidgetClassSnapshotFieldCallback FunPtr C_WidgetClassSnapshotFieldCallback
    val'
            WidgetClassSnapshotFieldCallback
    -> IO WidgetClassSnapshotFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassSnapshotFieldCallback
    val''
        return result

    -- | Set the value of the “@snapshot@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #snapshot 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassSnapshot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback -> m ()
    setWidgetClassSnapshot :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassSnapshotFieldCallback -> m ()
    setWidgetClassSnapshot WidgetClass
    s FunPtr C_WidgetClassSnapshotFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
    -> FunPtr C_WidgetClassSnapshotFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    320) (FunPtr C_WidgetClassSnapshotFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)

    -- | Set the value of the “@snapshot@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #snapshot
    -- @
    clearWidgetClassSnapshot :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassSnapshot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassSnapshot WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
    -> FunPtr C_WidgetClassSnapshotFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    320) (FunPtr C_WidgetClassSnapshotFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSnapshotFieldInfo
    instance AttrInfo WidgetClassSnapshotFieldInfo where
        type AttrBaseTypeConstraint WidgetClassSnapshotFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassSnapshotFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassSnapshotFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
        type AttrTransferTypeConstraint WidgetClassSnapshotFieldInfo = (~)Gtk.Callbacks.WidgetClassSnapshotFieldCallback
        type AttrTransferType WidgetClassSnapshotFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
        type AttrGetType WidgetClassSnapshotFieldInfo = Maybe Gtk.Callbacks.WidgetClassSnapshotFieldCallback
        type AttrLabel WidgetClassSnapshotFieldInfo = "snapshot"
        type AttrOrigin WidgetClassSnapshotFieldInfo = WidgetClass
        attrGet = getWidgetClassSnapshot
        attrSet = setWidgetClassSnapshot
        attrConstruct = undefined
        attrClear = clearWidgetClassSnapshot
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassSnapshotFieldCallback (Gtk.Callbacks.wrap_WidgetClassSnapshotFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.snapshot"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:snapshot"
            })

    widgetClass_snapshot :: AttrLabelProxy "snapshot"
    widgetClass_snapshot = AttrLabelProxy

    #endif

    -- | Get the value of the “@contains@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' widgetClass #contains
    -- @
    getWidgetClassContains :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassContainsFieldCallback)
    getWidgetClassContains :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> m (Maybe WidgetClassContainsFieldCallback)
    getWidgetClassContains WidgetClass
    s = IO (Maybe WidgetClassContainsFieldCallback)
    -> m (Maybe WidgetClassContainsFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe WidgetClassContainsFieldCallback)
     -> m (Maybe WidgetClassContainsFieldCallback))
    -> IO (Maybe WidgetClassContainsFieldCallback)
    -> m (Maybe WidgetClassContainsFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ WidgetClass
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
    -> IO (Maybe WidgetClassContainsFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
     -> IO (Maybe WidgetClassContainsFieldCallback))
    -> (Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
    -> IO (Maybe WidgetClassContainsFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        val <- Ptr (FunPtr C_WidgetClassContainsFieldCallback)
    -> IO (FunPtr C_WidgetClassContainsFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    328) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassContainsFieldCallback
    val' -> do
            let val'' :: WidgetClassContainsFieldCallback
    val'' = FunPtr C_WidgetClassContainsFieldCallback
    -> WidgetClassContainsFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWidget a) =>
    FunPtr C_WidgetClassContainsFieldCallback
    -> a -> Double -> Double -> m Bool
    Gtk.Callbacks.dynamic_WidgetClassContainsFieldCallback FunPtr C_WidgetClassContainsFieldCallback
    val'
            WidgetClassContainsFieldCallback
    -> IO WidgetClassContainsFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return WidgetClassContainsFieldCallback
    val''
        return result

    -- | Set the value of the “@contains@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' widgetClass [ #contains 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWidgetClassContains :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback -> m ()
    setWidgetClassContains :: forall (m :: * -> *).
    MonadIO m =>
    WidgetClass -> FunPtr C_WidgetClassContainsFieldCallback -> m ()
    setWidgetClassContains WidgetClass
    s FunPtr C_WidgetClassContainsFieldCallback
    val = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassContainsFieldCallback)
    -> FunPtr C_WidgetClassContainsFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    328) (FunPtr C_WidgetClassContainsFieldCallback
    val :: FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)

    -- | Set the value of the “@contains@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #contains
    -- @
    clearWidgetClassContains :: MonadIO m => WidgetClass -> m ()
    clearWidgetClassContains :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
    clearWidgetClassContains WidgetClass
    s = 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
    $ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr WidgetClass
    s ((Ptr WidgetClass -> IO ()) -> IO ())
    -> (Ptr WidgetClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr WidgetClass
    ptr -> do
        Ptr (FunPtr C_WidgetClassContainsFieldCallback)
    -> FunPtr C_WidgetClassContainsFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr WidgetClass
    ptr Ptr WidgetClass
    -> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    328) (FunPtr C_WidgetClassContainsFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassContainsFieldInfo
    instance AttrInfo WidgetClassContainsFieldInfo where
        type AttrBaseTypeConstraint WidgetClassContainsFieldInfo = (~) WidgetClass
        type AttrAllowedOps WidgetClassContainsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint WidgetClassContainsFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
        type AttrTransferTypeConstraint WidgetClassContainsFieldInfo = (~)Gtk.Callbacks.WidgetClassContainsFieldCallback
        type AttrTransferType WidgetClassContainsFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
        type AttrGetType WidgetClassContainsFieldInfo = Maybe Gtk.Callbacks.WidgetClassContainsFieldCallback
        type AttrLabel WidgetClassContainsFieldInfo = "contains"
        type AttrOrigin WidgetClassContainsFieldInfo = WidgetClass
        attrGet = getWidgetClassContains
        attrSet = setWidgetClassContains
        attrConstruct = undefined
        attrClear = clearWidgetClassContains
        attrTransfer _ v = do
            Gtk.Callbacks.mk_WidgetClassContainsFieldCallback (Gtk.Callbacks.wrap_WidgetClassContainsFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.contains"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:contains"
            })

    widgetClass_contains :: AttrLabelProxy "contains"
    widgetClass_contains = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList WidgetClass
    type instance O.AttributeList WidgetClass = WidgetClassAttributeList
    type WidgetClassAttributeList = ('[ '("parentClass", WidgetClassParentClassFieldInfo), '("show", WidgetClassShowFieldInfo), '("hide", WidgetClassHideFieldInfo), '("map", WidgetClassMapFieldInfo), '("unmap", WidgetClassUnmapFieldInfo), '("realize", WidgetClassRealizeFieldInfo), '("unrealize", WidgetClassUnrealizeFieldInfo), '("root", WidgetClassRootFieldInfo), '("unroot", WidgetClassUnrootFieldInfo), '("sizeAllocate", WidgetClassSizeAllocateFieldInfo), '("stateFlagsChanged", WidgetClassStateFlagsChangedFieldInfo), '("directionChanged", WidgetClassDirectionChangedFieldInfo), '("getRequestMode", WidgetClassGetRequestModeFieldInfo), '("measure", WidgetClassMeasureFieldInfo), '("mnemonicActivate", WidgetClassMnemonicActivateFieldInfo), '("grabFocus", WidgetClassGrabFocusFieldInfo), '("focus", WidgetClassFocusFieldInfo), '("setFocusChild", WidgetClassSetFocusChildFieldInfo), '("moveFocus", WidgetClassMoveFocusFieldInfo), '("keynavFailed", WidgetClassKeynavFailedFieldInfo), '("queryTooltip", WidgetClassQueryTooltipFieldInfo), '("computeExpand", WidgetClassComputeExpandFieldInfo), '("cssChanged", WidgetClassCssChangedFieldInfo), '("systemSettingChanged", WidgetClassSystemSettingChangedFieldInfo), '("snapshot", WidgetClassSnapshotFieldInfo), '("contains", WidgetClassContainsFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    -- method WidgetClass::add_shortcut
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the class to add the shortcut to"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "shortcut"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Shortcut" }
    --           , argCType = Just "GtkShortcut*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the shortcut to add"
    --                 , 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_widget_class_add_shortcut" gtk_widget_class_add_shortcut ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        Ptr Gtk.Shortcut.Shortcut ->            -- shortcut : TInterface (Name {namespace = "Gtk", name = "Shortcut"})
        IO ()

    -- | Installs a shortcut in /@widgetClass@/.
    --
    -- Every instance created for /@widgetClass@/ or its subclasses will
    -- inherit this shortcut and trigger it.
    --
    -- Shortcuts added this way will be triggered in the 'GI.Gtk.Enums.PropagationPhaseBubble'
    -- phase, which means they may also trigger if child widgets have focus.
    --
    -- This function must only be used in class initialization functions
    -- otherwise it is not guaranteed that the shortcut will be installed.
    widgetClassAddShortcut ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.Shortcut.IsShortcut a) =>
        WidgetClass
        -- ^ /@widgetClass@/: the class to add the shortcut to
        -> a
        -- ^ /@shortcut@/: the shortcut to add
        -> m ()
    widgetClassAddShortcut :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsShortcut a) =>
    WidgetClass -> a -> m ()
    widgetClassAddShortcut WidgetClass
    widgetClass a
    shortcut = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        shortcut' <- unsafeManagedPtrCastPtr shortcut
        gtk_widget_class_add_shortcut widgetClass' shortcut'
        touchManagedPtr widgetClass
        touchManagedPtr shortcut
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassAddShortcutMethodInfo
    instance (signature ~ (a -> m ()), MonadIO m, Gtk.Shortcut.IsShortcut a) => O.OverloadedMethod WidgetClassAddShortcutMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassAddShortcut

    instance O.OverloadedMethodInfo WidgetClassAddShortcutMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassAddShortcut",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassAddShortcut"
            })

    #endif

    -- method WidgetClass::bind_template_callback_full
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "name of the callback as expected in the template XML"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback_symbol"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Callback" }
    --           , argCType = Just "GCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the callback symbol"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_widget_class_bind_template_callback_full" gtk_widget_class_bind_template_callback_full ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- callback_name : TBasicType TUTF8
        FunPtr GObject.Callbacks.C_Callback ->  -- callback_symbol : TInterface (Name {namespace = "GObject", name = "Callback"})
        IO ()

    -- | Associates a name to be used in GtkBuilder XML with a symbol.
    --
    -- This function is not supported after 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateScope'
    -- has been used on /@widgetClass@/.
    --
    -- See 'GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol'.
    --
    -- Note that this must be called from a composite widget classes
    -- class initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
    widgetClassBindTemplateCallbackFull ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> T.Text
        -- ^ /@callbackName@/: name of the callback as expected in the template XML
        -> GObject.Callbacks.Callback
        -- ^ /@callbackSymbol@/: the callback symbol
        -> m ()
    widgetClassBindTemplateCallbackFull :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Text -> IO () -> m ()
    widgetClassBindTemplateCallbackFull WidgetClass
    widgetClass Text
    callbackName IO ()
    callbackSymbol = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        callbackName' <- textToCString callbackName
        ptrcallbackSymbol <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
        callbackSymbol' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrcallbackSymbol) callbackSymbol)
        poke ptrcallbackSymbol callbackSymbol'
        gtk_widget_class_bind_template_callback_full widgetClass' callbackName' callbackSymbol'
        touchManagedPtr widgetClass
        freeMem callbackName'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassBindTemplateCallbackFullMethodInfo
    instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassBindTemplateCallbackFull

    instance O.OverloadedMethodInfo WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateCallbackFull",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateCallbackFull"
            })

    #endif

    -- method WidgetClass::bind_template_child_full
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "ID of the child defined in the template XML"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "internal_child"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "whether the child should be accessible as an \8220internal-child\8221\n  when this class is used in GtkBuilder XML"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "struct_offset"
    --           , argType = TBasicType TSSize
    --           , argCType = Just "gssize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "The offset into the composite widget\8217s instance\n  public or private structure where the automated child pointer should be set,\n  or 0 to not assign the pointer"
    --                 , 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_widget_class_bind_template_child_full" gtk_widget_class_bind_template_child_full ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- name : TBasicType TUTF8
        CInt ->                                 -- internal_child : TBasicType TBoolean
        DI.Int64 ->                             -- struct_offset : TBasicType TSSize
        IO ()

    -- | Assigns an object declared in the class template XML to be set to
    -- a location on a freshly built instance’s private data, or
    -- alternatively accessible via 'GI.Gtk.Objects.Widget.widgetGetTemplateChild'.
    --
    -- The struct can point either into the public instance, then you should
    -- use @G_STRUCT_OFFSET(WidgetType, member)@ for /@structOffset@/, or in the
    -- private struct, then you should use @G_PRIVATE_OFFSET(WidgetType, member)@.
    --
    -- An explicit strong reference will be held automatically for the duration
    -- of your instance’s life cycle, it will be released automatically when
    -- @GObjectClass.dispose()@ runs on your instance and if a nonzero /@structOffset@/
    -- is specified, then the automatic location in your instance public or private
    -- data will be set to @NULL@. You can however access an automated child pointer
    -- the first time your classes @GObjectClass.dispose()@ runs, or alternatively
    -- in [Widget::destroy]("GI.Gtk.Objects.Widget#g:signal:destroy").
    --
    -- If /@internalChild@/ is specified, t'GI.Gtk.Interfaces.Buildable.Buildable'.@/get_internal_child/@()
    -- will be automatically implemented by the widget class so there is no
    -- need to implement it manually.
    --
    -- The wrapper macros @/Gtk.widget_class_bind_template_child/@,
    -- @/Gtk.widget_class_bind_template_child_internal/@,
    -- @/Gtk.widget_class_bind_template_child_private/@ and
    -- @/Gtk.widget_class_bind_template_child_internal_private/@
    -- might be more convenient to use.
    --
    -- Note that this must be called from a composite widget classes class
    -- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
    widgetClassBindTemplateChildFull ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> T.Text
        -- ^ /@name@/: ID of the child defined in the template XML
        -> Bool
        -- ^ /@internalChild@/: whether the child should be accessible as an “internal-child”
        --   when this class is used in GtkBuilder XML
        -> DI.Int64
        -- ^ /@structOffset@/: The offset into the composite widget’s instance
        --   public or private structure where the automated child pointer should be set,
        --   or 0 to not assign the pointer
        -> m ()
    widgetClassBindTemplateChildFull :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Text -> Bool -> Int64 -> m ()
    widgetClassBindTemplateChildFull WidgetClass
    widgetClass Text
    name Bool
    internalChild Int64
    structOffset = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        name' <- textToCString name
        let internalChild' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    internalChild
        gtk_widget_class_bind_template_child_full widgetClass' name' internalChild' structOffset
        touchManagedPtr widgetClass
        freeMem name'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassBindTemplateChildFullMethodInfo
    instance (signature ~ (T.Text -> Bool -> DI.Int64 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateChildFullMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassBindTemplateChildFull

    instance O.OverloadedMethodInfo WidgetClassBindTemplateChildFullMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateChildFull",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateChildFull"
            })

    #endif

    -- method WidgetClass::get_accessible_role
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "AccessibleRole" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_widget_class_get_accessible_role" gtk_widget_class_get_accessible_role ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        IO CUInt

    -- | Retrieves the accessible role used by the given widget class.
    --
    -- Different accessible roles have different states, and are rendered
    -- differently by assistive technologies.
    --
    -- See also: 'GI.Gtk.Interfaces.Accessible.accessibleGetAccessibleRole'.
    widgetClassGetAccessibleRole ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> m Gtk.Enums.AccessibleRole
        -- ^ __Returns:__ the accessible role for the widget class
    widgetClassGetAccessibleRole :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> m AccessibleRole
    widgetClassGetAccessibleRole WidgetClass
    widgetClass = IO AccessibleRole -> m AccessibleRole
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO AccessibleRole -> m AccessibleRole)
    -> IO AccessibleRole -> m AccessibleRole
    forall a b. (a -> b) -> a -> b
    $ do
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        result <- gtk_widget_class_get_accessible_role widgetClass'
        let result' = (Int -> AccessibleRole
    forall a. Enum a => Int -> a
    toEnum (Int -> AccessibleRole)
    -> (CUInt -> Int) -> CUInt -> AccessibleRole
    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 widgetClass
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassGetAccessibleRoleMethodInfo
    instance (signature ~ (m Gtk.Enums.AccessibleRole), MonadIO m) => O.OverloadedMethod WidgetClassGetAccessibleRoleMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassGetAccessibleRole

    instance O.OverloadedMethodInfo WidgetClassGetAccessibleRoleMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetAccessibleRole",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetAccessibleRole"
            })

    #endif

    -- method WidgetClass::get_activate_signal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , 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_widget_class_get_activate_signal" gtk_widget_class_get_activate_signal ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        IO Word32

    -- | Retrieves the signal id for the activation signal.
    --
    -- The activation signal is set using
    -- 'GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignal'.
    widgetClassGetActivateSignal ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> m Word32
        -- ^ __Returns:__ a signal id, or 0 if the widget class does not
        --   specify an activation signal
    widgetClassGetActivateSignal :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> m Word32
    widgetClassGetActivateSignal WidgetClass
    widgetClass = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        result <- gtk_widget_class_get_activate_signal widgetClass'
        touchManagedPtr widgetClass
        return result

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassGetActivateSignalMethodInfo
    instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod WidgetClassGetActivateSignalMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassGetActivateSignal

    instance O.OverloadedMethodInfo WidgetClassGetActivateSignalMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetActivateSignal",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetActivateSignal"
            })

    #endif

    -- method WidgetClass::get_css_name
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "class to set the name on"
    --                 , 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_widget_class_get_css_name" gtk_widget_class_get_css_name ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        IO CString

    -- | Gets the name used by this class for matching in CSS code.
    --
    -- See 'GI.Gtk.Structs.WidgetClass.widgetClassSetCssName' for details.
    widgetClassGetCssName ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: class to set the name on
        -> m T.Text
        -- ^ __Returns:__ the CSS name of the given class
    widgetClassGetCssName :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> m Text
    widgetClassGetCssName WidgetClass
    widgetClass = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        result <- gtk_widget_class_get_css_name widgetClass'
        checkUnexpectedReturnNULL "widgetClassGetCssName" result
        result' <- cstringToText result
        touchManagedPtr widgetClass
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassGetCssNameMethodInfo
    instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod WidgetClassGetCssNameMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassGetCssName

    instance O.OverloadedMethodInfo WidgetClassGetCssNameMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetCssName",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetCssName"
            })

    #endif

    -- method WidgetClass::get_layout_manager_type
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TGType)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_widget_class_get_layout_manager_type" gtk_widget_class_get_layout_manager_type ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        IO CGType

    -- | Retrieves the type of the t'GI.Gtk.Objects.LayoutManager.LayoutManager'
    -- used by widgets of class /@widgetClass@/.
    --
    -- See also: 'GI.Gtk.Structs.WidgetClass.widgetClassSetLayoutManagerType'.
    widgetClassGetLayoutManagerType ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> m GType
        -- ^ __Returns:__ type of a @GtkLayoutManager@ subclass, or @G_TYPE_INVALID@
    widgetClassGetLayoutManagerType :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> m GType
    widgetClassGetLayoutManagerType WidgetClass
    widgetClass = IO GType -> m GType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GType -> m GType) -> IO GType -> m GType
    forall a b. (a -> b) -> a -> b
    $ do
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        result <- gtk_widget_class_get_layout_manager_type widgetClass'
        let result' = CGType -> GType
    GType CGType
    result
        touchManagedPtr widgetClass
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassGetLayoutManagerTypeMethodInfo
    instance (signature ~ (m GType), MonadIO m) => O.OverloadedMethod WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassGetLayoutManagerType

    instance O.OverloadedMethodInfo WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetLayoutManagerType",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetLayoutManagerType"
            })

    #endif

    -- method WidgetClass::install_action
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "action_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a prefixed action name, such as \"clipboard.paste\""
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "parameter_type"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the parameter type" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "activate"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "WidgetActionActivateFunc" }
    --           , argCType = Just "GtkWidgetActionActivateFunc"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "callback to use when the action is activated"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeNotified
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_widget_class_install_action" gtk_widget_class_install_action ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- action_name : TBasicType TUTF8
        CString ->                              -- parameter_type : TBasicType TUTF8
        FunPtr Gtk.Callbacks.C_WidgetActionActivateFunc -> -- activate : TInterface (Name {namespace = "Gtk", name = "WidgetActionActivateFunc"})
        IO ()

    -- | Adds an action for all instances of a widget class.
    --
    -- This function should be called at class initialization time.
    --
    -- Actions installed by this function are stateless. The only state
    -- they have is whether they are enabled or not (which can be changed
    -- with 'GI.Gtk.Objects.Widget.widgetActionSetEnabled').
    widgetClassInstallAction ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> T.Text
        -- ^ /@actionName@/: a prefixed action name, such as \"clipboard.paste\"
        -> Maybe (T.Text)
        -- ^ /@parameterType@/: the parameter type
        -> Gtk.Callbacks.WidgetActionActivateFunc
        -- ^ /@activate@/: callback to use when the action is activated
        -> m ()
    widgetClassInstallAction :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass
    -> Text -> Maybe Text -> WidgetActionActivateFunc -> m ()
    widgetClassInstallAction WidgetClass
    widgetClass Text
    actionName Maybe Text
    parameterType WidgetActionActivateFunc
    activate = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        actionName' <- textToCString actionName
        maybeParameterType <- case parameterType of
            Maybe Text
    Nothing -> CString -> IO CString
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CString
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jParameterType -> do
                jParameterType' <- Text -> IO CString
    textToCString Text
    jParameterType
                return jParameterType'
        activate' <- Gtk.Callbacks.mk_WidgetActionActivateFunc (Gtk.Callbacks.wrap_WidgetActionActivateFunc Nothing activate)
        gtk_widget_class_install_action widgetClass' actionName' maybeParameterType activate'
        touchManagedPtr widgetClass
        freeMem actionName'
        freeMem maybeParameterType
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassInstallActionMethodInfo
    instance (signature ~ (T.Text -> Maybe (T.Text) -> Gtk.Callbacks.WidgetActionActivateFunc -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallActionMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassInstallAction

    instance O.OverloadedMethodInfo WidgetClassInstallActionMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallAction",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallAction"
            })

    #endif

    -- method WidgetClass::install_property_action
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "action_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "name of the action" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "name of a property in instances of @widget_class\n  or any parent class"
    --                 , 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_widget_class_install_property_action" gtk_widget_class_install_property_action ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- action_name : TBasicType TUTF8
        CString ->                              -- property_name : TBasicType TUTF8
        IO ()

    -- | Installs an action called /@actionName@/ on /@widgetClass@/ and
    -- binds its state to the value of the /@propertyName@/ property.
    --
    -- This function will perform a few sanity checks on the property selected
    -- via /@propertyName@/. Namely, the property must exist, must be readable,
    -- writable and must not be construct-only. There are also restrictions
    -- on the type of the given property, it must be boolean, int, unsigned int,
    -- double or string. If any of these conditions are not met, a critical
    -- warning will be printed and no action will be added.
    --
    -- The state type of the action matches the property type.
    --
    -- If the property is boolean, the action will have no parameter and
    -- toggle the property value. Otherwise, the action will have a parameter
    -- of the same type as the property.
    widgetClassInstallPropertyAction ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> T.Text
        -- ^ /@actionName@/: name of the action
        -> T.Text
        -- ^ /@propertyName@/: name of a property in instances of /@widgetClass@/
        --   or any parent class
        -> m ()
    widgetClassInstallPropertyAction :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Text -> Text -> m ()
    widgetClassInstallPropertyAction WidgetClass
    widgetClass Text
    actionName Text
    propertyName = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        actionName' <- textToCString actionName
        propertyName' <- textToCString propertyName
        gtk_widget_class_install_property_action widgetClass' actionName' propertyName'
        touchManagedPtr widgetClass
        freeMem actionName'
        freeMem propertyName'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassInstallPropertyActionMethodInfo
    instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallPropertyActionMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassInstallPropertyAction

    instance O.OverloadedMethodInfo WidgetClassInstallPropertyActionMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallPropertyAction",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallPropertyAction"
            })

    #endif

    -- method WidgetClass::query_action
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "index_"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "position of the action to query"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "owner"
    --           , argType = TBasicType TGType
    --           , argCType = Just "GType*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the type where the action was defined"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "action_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the action name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "parameter_type"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "VariantType" }
    --           , argCType = Just "const GVariantType**"
    --           , direction = DirectionOut
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the parameter type"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char**"
    --           , direction = DirectionOut
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the property name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_widget_class_query_action" gtk_widget_class_query_action ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        Word32 ->                               -- index_ : TBasicType TUInt
        Ptr CGType ->                           -- owner : TBasicType TGType
        Ptr CString ->                          -- action_name : TBasicType TUTF8
        Ptr (Ptr GLib.VariantType.VariantType) -> -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
        Ptr CString ->                          -- property_name : TBasicType TUTF8
        IO CInt

    -- | Returns details about an action that has been
    -- installed for /@widgetClass@/.
    --
    -- See 'GI.Gtk.Structs.WidgetClass.widgetClassInstallAction' for details on
    -- how to install actions.
    --
    -- Note that this function will also return actions defined
    -- by parent classes. You can identify those by looking
    -- at /@owner@/.
    widgetClassQueryAction ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> Word32
        -- ^ /@index_@/: position of the action to query
        -> m ((Bool, GType, T.Text, Maybe GLib.VariantType.VariantType, Maybe T.Text))
        -- ^ __Returns:__ true if the action was found
    widgetClassQueryAction :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass
    -> Word32 -> m (Bool, GType, Text, Maybe VariantType, Maybe Text)
    widgetClassQueryAction WidgetClass
    widgetClass Word32
    index_ = IO (Bool, GType, Text, Maybe VariantType, Maybe Text)
    -> m (Bool, GType, Text, Maybe VariantType, Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, GType, Text, Maybe VariantType, Maybe Text)
     -> m (Bool, GType, Text, Maybe VariantType, Maybe Text))
    -> IO (Bool, GType, Text, Maybe VariantType, Maybe Text)
    -> m (Bool, GType, Text, Maybe VariantType, Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ do
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        owner <- allocMem :: IO (Ptr CGType)
        actionName <- callocMem :: IO (Ptr CString)
        parameterType <- callocMem :: IO (Ptr (Ptr GLib.VariantType.VariantType))
        propertyName <- callocMem :: IO (Ptr CString)
        result <- gtk_widget_class_query_action widgetClass' index_ owner actionName parameterType propertyName
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        owner' <- peek owner
        let owner'' = CGType -> GType
    GType CGType
    owner'
        actionName' <- peek actionName
        actionName'' <- cstringToText actionName'
        parameterType' <- peek parameterType
        maybeParameterType' <- convertIfNonNull parameterType' $ \Ptr VariantType
    parameterType'' -> do
            parameterType''' <- ((ManagedPtr VariantType -> VariantType)
    -> Ptr VariantType -> IO VariantType
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr VariantType -> VariantType
    GLib.VariantType.VariantType) Ptr VariantType
    parameterType''
            return parameterType'''
        propertyName' <- peek propertyName
        maybePropertyName' <- convertIfNonNull propertyName' $ \CString
    propertyName'' -> do
            propertyName''' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    propertyName''
            return propertyName'''
        touchManagedPtr widgetClass
        freeMem owner
        freeMem actionName
        freeMem parameterType
        freeMem propertyName
        return (result', owner'', actionName'', maybeParameterType', maybePropertyName')

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassQueryActionMethodInfo
    instance (signature ~ (Word32 -> m ((Bool, GType, T.Text, Maybe GLib.VariantType.VariantType, Maybe T.Text))), MonadIO m) => O.OverloadedMethod WidgetClassQueryActionMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassQueryAction

    instance O.OverloadedMethodInfo WidgetClassQueryActionMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassQueryAction",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassQueryAction"
            })

    #endif

    -- method WidgetClass::set_accessible_role
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "accessible_role"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "AccessibleRole" }
    --           , argCType = Just "GtkAccessibleRole"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the accessible role 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_widget_class_set_accessible_role" gtk_widget_class_set_accessible_role ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CUInt ->                                -- accessible_role : TInterface (Name {namespace = "Gtk", name = "AccessibleRole"})
        IO ()

    -- | Sets the accessible role used by the given widget class.
    --
    -- Different accessible roles have different states, and are
    -- rendered differently by assistive technologies.
    widgetClassSetAccessibleRole ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> Gtk.Enums.AccessibleRole
        -- ^ /@accessibleRole@/: the accessible role to use
        -> m ()
    widgetClassSetAccessibleRole :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> AccessibleRole -> m ()
    widgetClassSetAccessibleRole WidgetClass
    widgetClass AccessibleRole
    accessibleRole = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        let accessibleRole' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (AccessibleRole -> Int) -> AccessibleRole -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . AccessibleRole -> Int
    forall a. Enum a => a -> Int
    fromEnum) AccessibleRole
    accessibleRole
        gtk_widget_class_set_accessible_role widgetClass' accessibleRole'
        touchManagedPtr widgetClass
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetAccessibleRoleMethodInfo
    instance (signature ~ (Gtk.Enums.AccessibleRole -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetAccessibleRoleMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetAccessibleRole

    instance O.OverloadedMethodInfo WidgetClassSetAccessibleRoleMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleRole",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetAccessibleRole"
            })

    #endif

    -- method WidgetClass::set_activate_signal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "signal_id"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the id for the activate signal"
    --                 , 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_widget_class_set_activate_signal" gtk_widget_class_set_activate_signal ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        Word32 ->                               -- signal_id : TBasicType TUInt
        IO ()

    -- | Sets the activation signal for a widget class.
    --
    -- The signal will be emitted when calling 'GI.Gtk.Objects.Widget.widgetActivate'.
    --
    -- The /@signalId@/ must have been registered with [function.GObject.signal_new]
    -- or @/GObject.signal_newv/@ before calling this function.
    widgetClassSetActivateSignal ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> Word32
        -- ^ /@signalId@/: the id for the activate signal
        -> m ()
    widgetClassSetActivateSignal :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Word32 -> m ()
    widgetClassSetActivateSignal WidgetClass
    widgetClass Word32
    signalId = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        gtk_widget_class_set_activate_signal widgetClass' signalId
        touchManagedPtr widgetClass
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetActivateSignalMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetActivateSignalMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetActivateSignal

    instance O.OverloadedMethodInfo WidgetClassSetActivateSignalMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignal",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetActivateSignal"
            })

    #endif

    -- method WidgetClass::set_activate_signal_from_name
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "signal_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the name of the activate signal of @widget_type"
    --                 , 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_widget_class_set_activate_signal_from_name" gtk_widget_class_set_activate_signal_from_name ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- signal_name : TBasicType TUTF8
        IO ()

    -- | Sets the activation signal for a widget class.
    --
    -- The signal id will by looked up by /@signalName@/.
    --
    -- The signal will be emitted when calling 'GI.Gtk.Objects.Widget.widgetActivate'.
    --
    -- The /@signalName@/ must have been registered with [function.GObject.signal_new]
    -- or @/GObject.signal_newv/@ before calling this function.
    widgetClassSetActivateSignalFromName ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> T.Text
        -- ^ /@signalName@/: the name of the activate signal of /@widgetType@/
        -> m ()
    widgetClassSetActivateSignalFromName :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Text -> m ()
    widgetClassSetActivateSignalFromName WidgetClass
    widgetClass Text
    signalName = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        signalName' <- textToCString signalName
        gtk_widget_class_set_activate_signal_from_name widgetClass' signalName'
        touchManagedPtr widgetClass
        freeMem signalName'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetActivateSignalFromNameMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetActivateSignalFromNameMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetActivateSignalFromName

    instance O.OverloadedMethodInfo WidgetClassSetActivateSignalFromNameMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignalFromName",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetActivateSignalFromName"
            })

    #endif

    -- method WidgetClass::set_css_name
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "class to set the name on"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "name 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_widget_class_set_css_name" gtk_widget_class_set_css_name ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- name : TBasicType TUTF8
        IO ()

    -- | Sets the name to be used for CSS matching of widgets.
    --
    -- If this function is not called for a given class, the name
    -- set on the parent class is used. By default, @GtkWidget@
    -- uses the name \"widget\".
    widgetClassSetCssName ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: class to set the name on
        -> T.Text
        -- ^ /@name@/: name to use
        -> m ()
    widgetClassSetCssName :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Text -> m ()
    widgetClassSetCssName WidgetClass
    widgetClass Text
    name = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        name' <- textToCString name
        gtk_widget_class_set_css_name widgetClass' name'
        touchManagedPtr widgetClass
        freeMem name'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetCssNameMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetCssNameMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetCssName

    instance O.OverloadedMethodInfo WidgetClassSetCssNameMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetCssName",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetCssName"
            })

    #endif

    -- method WidgetClass::set_layout_manager_type
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType = TBasicType TGType
    --           , argCType = Just "GType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the object type that implements the `GtkLayoutManager`\n  for @widget_class"
    --                 , 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_widget_class_set_layout_manager_type" gtk_widget_class_set_layout_manager_type ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CGType ->                               -- type : TBasicType TGType
        IO ()

    -- | Sets the type to be used for creating layout managers for
    -- widgets of /@widgetClass@/.
    --
    -- The given /@type@/ must be a subtype of t'GI.Gtk.Objects.LayoutManager.LayoutManager'.
    --
    -- This function should only be called from class init functions
    -- of widgets.
    widgetClassSetLayoutManagerType ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> GType
        -- ^ /@type@/: the object type that implements the @GtkLayoutManager@
        --   for /@widgetClass@/
        -> m ()
    widgetClassSetLayoutManagerType :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> GType -> m ()
    widgetClassSetLayoutManagerType WidgetClass
    widgetClass GType
    type_ = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        let type_' = GType -> CGType
    gtypeToCGType GType
    type_
        gtk_widget_class_set_layout_manager_type widgetClass' type_'
        touchManagedPtr widgetClass
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetLayoutManagerTypeMethodInfo
    instance (signature ~ (GType -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetLayoutManagerType

    instance O.OverloadedMethodInfo WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetLayoutManagerType",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetLayoutManagerType"
            })

    #endif

    -- method WidgetClass::set_template
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "template_bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "`GBytes` holding the `GtkBuilder` XML"
    --                 , 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_widget_class_set_template" gtk_widget_class_set_template ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        Ptr GLib.Bytes.Bytes ->                 -- template_bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO ()

    -- | This should be called at class initialization time to specify
    -- the @GtkBuilder@ XML to be used to extend a widget.
    --
    -- For convenience, 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource'
    -- is also provided.
    --
    -- Note that any class that installs templates must call
    -- 'GI.Gtk.Objects.Widget.widgetInitTemplate' in the widget’s instance initializer.
    widgetClassSetTemplate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> GLib.Bytes.Bytes
        -- ^ /@templateBytes@/: @GBytes@ holding the @GtkBuilder@ XML
        -> m ()
    widgetClassSetTemplate :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Bytes -> m ()
    widgetClassSetTemplate WidgetClass
    widgetClass Bytes
    templateBytes = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        templateBytes' <- unsafeManagedPtrGetPtr templateBytes
        gtk_widget_class_set_template widgetClass' templateBytes'
        touchManagedPtr widgetClass
        touchManagedPtr templateBytes
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetTemplateMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetTemplate

    instance O.OverloadedMethodInfo WidgetClassSetTemplateMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplate"
            })

    #endif

    -- method WidgetClass::set_template_from_resource
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "resource_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "resource path to load the template from"
    --                 , 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_widget_class_set_template_from_resource" gtk_widget_class_set_template_from_resource ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        CString ->                              -- resource_name : TBasicType TUTF8
        IO ()

    -- | A convenience function that calls 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'
    -- with the contents of a resource.
    --
    -- Note that any class that installs templates must call
    -- 'GI.Gtk.Objects.Widget.widgetInitTemplate' in the widget’s instance
    -- initializer.
    widgetClassSetTemplateFromResource ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> T.Text
        -- ^ /@resourceName@/: resource path to load the template from
        -> m ()
    widgetClassSetTemplateFromResource :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    WidgetClass -> Text -> m ()
    widgetClassSetTemplateFromResource WidgetClass
    widgetClass Text
    resourceName = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        resourceName' <- textToCString resourceName
        gtk_widget_class_set_template_from_resource widgetClass' resourceName'
        touchManagedPtr widgetClass
        freeMem resourceName'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetTemplateFromResourceMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateFromResourceMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetTemplateFromResource

    instance O.OverloadedMethodInfo WidgetClassSetTemplateFromResourceMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateFromResource"
            })

    #endif

    -- method WidgetClass::set_template_scope
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "widget_class"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
    --           , argCType = Just "GtkWidgetClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "scope"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "BuilderScope" }
    --           , argCType = Just "GtkBuilderScope*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "`GtkBuilderScope` to use when loading\n  the class template"
    --                 , 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_widget_class_set_template_scope" gtk_widget_class_set_template_scope ::
        Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
        Ptr Gtk.BuilderScope.BuilderScope ->    -- scope : TInterface (Name {namespace = "Gtk", name = "BuilderScope"})
        IO ()

    -- | Overrides the default scope to be used when parsing the class template.
    --
    -- This function is intended for language bindings.
    --
    -- Note that this must be called from a composite widget classes class
    -- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
    widgetClassSetTemplateScope ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.BuilderScope.IsBuilderScope a) =>
        WidgetClass
        -- ^ /@widgetClass@/: a widget class
        -> a
        -- ^ /@scope@/: @GtkBuilderScope@ to use when loading
        --   the class template
        -> m ()
    widgetClassSetTemplateScope :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBuilderScope a) =>
    WidgetClass -> a -> m ()
    widgetClassSetTemplateScope WidgetClass
    widgetClass a
    scope = 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
        widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr WidgetClass
    widgetClass
        scope' <- unsafeManagedPtrCastPtr scope
        gtk_widget_class_set_template_scope widgetClass' scope'
        touchManagedPtr widgetClass
        touchManagedPtr scope
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WidgetClassSetTemplateScopeMethodInfo
    instance (signature ~ (a -> m ()), MonadIO m, Gtk.BuilderScope.IsBuilderScope a) => O.OverloadedMethod WidgetClassSetTemplateScopeMethodInfo WidgetClass signature where
        overloadedMethod = widgetClassSetTemplateScope

    instance O.OverloadedMethodInfo WidgetClassSetTemplateScopeMethodInfo WidgetClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateScope",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateScope"
            })

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveWidgetClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveWidgetClassMethod "addShortcut" o = WidgetClassAddShortcutMethodInfo
        ResolveWidgetClassMethod "bindTemplateCallbackFull" o = WidgetClassBindTemplateCallbackFullMethodInfo
        ResolveWidgetClassMethod "bindTemplateChildFull" o = WidgetClassBindTemplateChildFullMethodInfo
        ResolveWidgetClassMethod "installAction" o = WidgetClassInstallActionMethodInfo
        ResolveWidgetClassMethod "installPropertyAction" o = WidgetClassInstallPropertyActionMethodInfo
        ResolveWidgetClassMethod "queryAction" o = WidgetClassQueryActionMethodInfo
        ResolveWidgetClassMethod "getAccessibleRole" o = WidgetClassGetAccessibleRoleMethodInfo
        ResolveWidgetClassMethod "getActivateSignal" o = WidgetClassGetActivateSignalMethodInfo
        ResolveWidgetClassMethod "getCssName" o = WidgetClassGetCssNameMethodInfo
        ResolveWidgetClassMethod "getLayoutManagerType" o = WidgetClassGetLayoutManagerTypeMethodInfo
        ResolveWidgetClassMethod "setAccessibleRole" o = WidgetClassSetAccessibleRoleMethodInfo
        ResolveWidgetClassMethod "setActivateSignal" o = WidgetClassSetActivateSignalMethodInfo
        ResolveWidgetClassMethod "setActivateSignalFromName" o = WidgetClassSetActivateSignalFromNameMethodInfo
        ResolveWidgetClassMethod "setCssName" o = WidgetClassSetCssNameMethodInfo
        ResolveWidgetClassMethod "setLayoutManagerType" o = WidgetClassSetLayoutManagerTypeMethodInfo
        ResolveWidgetClassMethod "setTemplate" o = WidgetClassSetTemplateMethodInfo
        ResolveWidgetClassMethod "setTemplateFromResource" o = WidgetClassSetTemplateFromResourceMethodInfo
        ResolveWidgetClassMethod "setTemplateScope" o = WidgetClassSetTemplateScopeMethodInfo
        ResolveWidgetClassMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif