    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Shows window frame controls.
    --
    -- Typical window frame controls are minimize, maximize and close buttons,
    -- and the window icon.
    --
    -- \<picture>
    --   \<source srcset=\"windowcontrols-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"An example GtkWindowControls\" src=\"windowcontrols.png\">
    -- \<\/picture>
    --
    -- @GtkWindowControls@ only displays start or end side of the controls (see
    -- [WindowControls:side]("GI.Gtk.Objects.WindowControls#g:attr:side")), so it\'s intended to be always used
    -- in pair with another @GtkWindowControls@ for the opposite side, for example:
    --
    --
    -- === /xml code/
    -- ><object class="GtkBox">
    -- >  <child>
    -- >    <object class="GtkWindowControls">
    -- >      <property name="side">start</property>
    -- >    </object>
    -- >  </child>
    -- >
    -- >  ...
    -- >
    -- >  <child>
    -- >    <object class="GtkWindowControls">
    -- >      <property name="side">end</property>
    -- >    </object>
    -- >  </child>
    -- ></object>
    --
    --
    -- = CSS nodes
    --
    --
    --
    -- >windowcontrols
    -- >├── [image.icon]
    -- >├── [button.minimize]
    -- >├── [button.maximize]
    -- >╰── [button.close]
    --
    --
    -- A @GtkWindowControls@\' CSS node is called windowcontrols. It contains
    -- subnodes corresponding to each title button. Which of the title buttons
    -- exist and where they are placed exactly depends on the desktop environment
    -- and [WindowControls:decorationLayout]("GI.Gtk.Objects.WindowControls#g:attr:decorationLayout") value.
    --
    -- When [WindowControls:empty]("GI.Gtk.Objects.WindowControls#g:attr:empty") is true, it gets the .empty
    -- style class.
    --
    -- = Accessibility
    --
    -- @GtkWindowControls@ uses the 'GI.Gtk.Enums.AccessibleRoleGroup' role.

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

    module GI.Gtk.Objects.WindowControls
        (

    -- * Exported types
        WindowControls(..)                      ,
        IsWindowControls                        ,
        toWindowControls                        ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updatePlatformState]("GI.Gtk.Interfaces.Accessible#g:method:updatePlatformState"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAccessibleId]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleId"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDecorationLayout]("GI.Gtk.Objects.WindowControls#g:method:getDecorationLayout"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEmpty]("GI.Gtk.Objects.WindowControls#g:method:getEmpty"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSide]("GI.Gtk.Objects.WindowControls#g:method:getSide"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getUseNativeControls]("GI.Gtk.Objects.WindowControls#g:method:getUseNativeControls"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDecorationLayout]("GI.Gtk.Objects.WindowControls#g:method:setDecorationLayout"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSide]("GI.Gtk.Objects.WindowControls#g:method:setSide"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setUseNativeControls]("GI.Gtk.Objects.WindowControls#g:method:setUseNativeControls"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

    #if defined(ENABLE_OVERLOADING)
        ResolveWindowControlsMethod             ,
    #endif

    -- ** getDecorationLayout #method:getDecorationLayout#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsGetDecorationLayoutMethodInfo,
    #endif
        windowControlsGetDecorationLayout       ,

    -- ** getEmpty #method:getEmpty#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsGetEmptyMethodInfo        ,
    #endif
        windowControlsGetEmpty                  ,

    -- ** getSide #method:getSide#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsGetSideMethodInfo         ,
    #endif
        windowControlsGetSide                   ,

    -- ** getUseNativeControls #method:getUseNativeControls#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsGetUseNativeControlsMethodInfo,
    #endif
        windowControlsGetUseNativeControls      ,

    -- ** new #method:new#

        windowControlsNew                       ,

    -- ** setDecorationLayout #method:setDecorationLayout#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsSetDecorationLayoutMethodInfo,
    #endif
        windowControlsSetDecorationLayout       ,

    -- ** setSide #method:setSide#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsSetSideMethodInfo         ,
    #endif
        windowControlsSetSide                   ,

    -- ** setUseNativeControls #method:setUseNativeControls#

    #if defined(ENABLE_OVERLOADING)
        WindowControlsSetUseNativeControlsMethodInfo,
    #endif
        windowControlsSetUseNativeControls      ,

     -- * Properties

    -- ** decorationLayout #attr:decorationLayout#
    -- | The decoration layout for window buttons.
    --
    -- If this property is not set, the
    -- [Settings:gtkDecorationLayout]("GI.Gtk.Objects.Settings#g:attr:gtkDecorationLayout") setting is used.

    #if defined(ENABLE_OVERLOADING)
        WindowControlsDecorationLayoutPropertyInfo,
    #endif
        clearWindowControlsDecorationLayout     ,
        constructWindowControlsDecorationLayout ,
        getWindowControlsDecorationLayout       ,
        setWindowControlsDecorationLayout       ,
    #if defined(ENABLE_OVERLOADING)
        windowControlsDecorationLayout          ,
    #endif

    -- ** empty #attr:empty#
    -- | Whether the widget has any window buttons.

    #if defined(ENABLE_OVERLOADING)
        WindowControlsEmptyPropertyInfo         ,
    #endif
        getWindowControlsEmpty                  ,
    #if defined(ENABLE_OVERLOADING)
        windowControlsEmpty                     ,
    #endif

    -- ** side #attr:side#
    -- | Whether the widget shows start or end side of the decoration layout.
    --
    -- See [property/@gtk@/.WindowControls:decoration_layout].

    #if defined(ENABLE_OVERLOADING)
        WindowControlsSidePropertyInfo          ,
    #endif
        constructWindowControlsSide             ,
        getWindowControlsSide                   ,
        setWindowControlsSide                   ,
    #if defined(ENABLE_OVERLOADING)
        windowControlsSide                      ,
    #endif

    -- ** useNativeControls #attr:useNativeControls#
    -- | Whether to show platform native close\/minimize\/maximize buttons.
    --
    -- For macOS, the [HeaderBar:decorationLayout]("GI.Gtk.Objects.HeaderBar#g:attr:decorationLayout") property
    -- controls the use of native window controls.
    --
    -- On other platforms, this option has no effect.
    --
    -- See also <https://docs.gtk.org/gtk4/osx.html?native-window-controls Using GTK on Apple macOS>.
    --
    -- /Since: 4.18/

    #if defined(ENABLE_OVERLOADING)
        WindowControlsUseNativeControlsPropertyInfo,
    #endif
        constructWindowControlsUseNativeControls,
        getWindowControlsUseNativeControls      ,
        setWindowControlsUseNativeControls      ,
    #if defined(ENABLE_OVERLOADING)
        windowControlsUseNativeControls         ,
    #endif

        ) where

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

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

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

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

    #endif

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

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

    foreign import ccall "gtk_window_controls_get_type"
        c_gtk_window_controls_get_type :: IO B.Types.GType

    instance B.Types.TypedObject WindowControls where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_window_controls_get_type

    instance B.Types.GObject WindowControls

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

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

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

    -- | Convert t'WindowControls' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe WindowControls) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_window_controls_get_type
        gvalueSet_ :: Ptr GValue -> Maybe WindowControls -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe WindowControls
    P.Nothing = Ptr GValue -> Ptr WindowControls -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr WindowControls
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr WindowControls)
        gvalueSet_ Ptr GValue
    gv (P.Just WindowControls
    obj) = WindowControls -> (Ptr WindowControls -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr WindowControls
    obj (Ptr GValue -> Ptr WindowControls -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe WindowControls)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr WindowControls)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr WindowControls)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject WindowControls ptr
            else return P.Nothing

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

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

    #endif

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

    #endif

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

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

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

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

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

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

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

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

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

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

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

    -- | Set the value of the “@side@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' windowControls [ #side 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWindowControlsSide :: (MonadIO m, IsWindowControls o) => o -> Gtk.Enums.PackType -> m ()
    setWindowControlsSide :: forall (m :: * -> *) o.
    (MonadIO m, IsWindowControls o) =>
    o -> PackType -> m ()
    setWindowControlsSide o
    obj PackType
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> PackType -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "side" PackType
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@side@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructWindowControlsSide :: (IsWindowControls o, MIO.MonadIO m) => Gtk.Enums.PackType -> m (GValueConstruct o)
    constructWindowControlsSide :: forall o (m :: * -> *).
    (IsWindowControls o, MonadIO m) =>
    PackType -> m (GValueConstruct o)
    constructWindowControlsSide PackType
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> PackType -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "side" PackType
    val

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    windowControlsDecorationLayout :: AttrLabelProxy "decorationLayout"
    windowControlsDecorationLayout = AttrLabelProxy

    windowControlsEmpty :: AttrLabelProxy "empty"
    windowControlsEmpty = AttrLabelProxy

    windowControlsSide :: AttrLabelProxy "side"
    windowControlsSide = AttrLabelProxy

    windowControlsUseNativeControls :: AttrLabelProxy "useNativeControls"
    windowControlsUseNativeControls = AttrLabelProxy

    #endif

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

    #endif

    -- method WindowControls::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "side"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PackType" }
    --           , argCType = Just "GtkPackType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the side" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "WindowControls" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_controls_new" gtk_window_controls_new ::
        CUInt ->                                -- side : TInterface (Name {namespace = "Gtk", name = "PackType"})
        IO (Ptr WindowControls)

    -- | Creates a new @GtkWindowControls@.
    windowControlsNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Gtk.Enums.PackType
        -- ^ /@side@/: the side
        -> m WindowControls
        -- ^ __Returns:__ a new @GtkWindowControls@
    windowControlsNew :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    PackType -> m WindowControls
    windowControlsNew PackType
    side = IO WindowControls -> m WindowControls
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO WindowControls -> m WindowControls)
    -> IO WindowControls -> m WindowControls
    forall a b. (a -> b) -> a -> b
    $ do
        let side' :: CUInt
    side' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (PackType -> Int) -> PackType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackType -> Int
    forall a. Enum a => a -> Int
    fromEnum) PackType
    side
        result <- CUInt -> IO (Ptr WindowControls)
    gtk_window_controls_new CUInt
    side'
        checkUnexpectedReturnNULL "windowControlsNew" result
        result' <- (newObject WindowControls) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method WindowControls::get_decoration_layout
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowControls" }
    --           , argCType = Just "GtkWindowControls*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window controls widget"
    --                 , 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_window_controls_get_decoration_layout" gtk_window_controls_get_decoration_layout ::
        Ptr WindowControls ->                   -- self : TInterface (Name {namespace = "Gtk", name = "WindowControls"})
        IO CString

    -- | Gets the decoration layout of this window controls widget
    windowControlsGetDecorationLayout ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window controls widget
        -> m (Maybe T.Text)
        -- ^ __Returns:__ the decoration layout
    windowControlsGetDecorationLayout :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> m (Maybe Text)
    windowControlsGetDecorationLayout a
    self = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_window_controls_get_decoration_layout self'
        maybeResult <- convertIfNonNull result $ \CString
    result' -> do
            result'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result'
            return result''
        touchManagedPtr self
        return maybeResult

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

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

    #endif

    -- method WindowControls::get_empty
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowControls" }
    --           , argCType = Just "GtkWindowControls*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window controls widget"
    --                 , 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_window_controls_get_empty" gtk_window_controls_get_empty ::
        Ptr WindowControls ->                   -- self : TInterface (Name {namespace = "Gtk", name = "WindowControls"})
        IO CInt

    -- | Gets whether the widget has any window buttons.
    windowControlsGetEmpty ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window controls widget
        -> m Bool
        -- ^ __Returns:__ true if the widget has window buttons
    windowControlsGetEmpty :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> m Bool
    windowControlsGetEmpty a
    self = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_window_controls_get_empty self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowControlsGetEmptyMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindowControls a) => O.OverloadedMethod WindowControlsGetEmptyMethodInfo a signature where
        overloadedMethod = windowControlsGetEmpty

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

    #endif

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

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

    -- | Gets the side to which this window controls widget belongs.
    windowControlsGetSide ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window controls widget
        -> m Gtk.Enums.PackType
        -- ^ __Returns:__ the side
    windowControlsGetSide :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> m PackType
    windowControlsGetSide a
    self = IO PackType -> m PackType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO PackType -> m PackType) -> IO PackType -> m PackType
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_window_controls_get_side self'
        let result' = (Int -> PackType
    forall a. Enum a => Int -> a
    toEnum (Int -> PackType) -> (CUInt -> Int) -> CUInt -> PackType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowControlsGetSideMethodInfo
    instance (signature ~ (m Gtk.Enums.PackType), MonadIO m, IsWindowControls a) => O.OverloadedMethod WindowControlsGetSideMethodInfo a signature where
        overloadedMethod = windowControlsGetSide

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

    #endif

    -- method WindowControls::get_use_native_controls
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowControls" }
    --           , argCType = Just "GtkWindowControls*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window controls widget"
    --                 , 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_window_controls_get_use_native_controls" gtk_window_controls_get_use_native_controls ::
        Ptr WindowControls ->                   -- self : TInterface (Name {namespace = "Gtk", name = "WindowControls"})
        IO CInt

    -- | Returns whether platform native window controls are shown.
    --
    -- /Since: 4.18/
    windowControlsGetUseNativeControls ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window controls widget
        -> m Bool
        -- ^ __Returns:__ true if native window controls are shown
    windowControlsGetUseNativeControls :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> m Bool
    windowControlsGetUseNativeControls a
    self = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_window_controls_get_use_native_controls self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowControlsGetUseNativeControlsMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindowControls a) => O.OverloadedMethod WindowControlsGetUseNativeControlsMethodInfo a signature where
        overloadedMethod = windowControlsGetUseNativeControls

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

    #endif

    -- method WindowControls::set_decoration_layout
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowControls" }
    --           , argCType = Just "GtkWindowControls*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window controls widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "layout"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a decoration layout, or `NULL` to unset the layout"
    --                 , 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_window_controls_set_decoration_layout" gtk_window_controls_set_decoration_layout ::
        Ptr WindowControls ->                   -- self : TInterface (Name {namespace = "Gtk", name = "WindowControls"})
        CString ->                              -- layout : TBasicType TUTF8
        IO ()

    -- | Sets the decoration layout for the title buttons.
    --
    -- This overrides the [Settings:gtkDecorationLayout]("GI.Gtk.Objects.Settings#g:attr:gtkDecorationLayout")
    -- setting.
    --
    -- The format of the string is button names, separated by commas.
    -- A colon separates the buttons that should appear on the left
    -- from those on the right. Recognized button names are minimize,
    -- maximize, close and icon (the window icon).
    --
    -- For example, “icon:minimize,maximize,close” specifies a icon
    -- on the left, and minimize, maximize and close buttons on the right.
    --
    -- If [WindowControls:side]("GI.Gtk.Objects.WindowControls#g:attr:side") value is 'GI.Gtk.Enums.PackTypeStart',
    -- /@self@/ will display the part before the colon, otherwise after that.
    windowControlsSetDecorationLayout ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window controls widget
        -> Maybe (T.Text)
        -- ^ /@layout@/: a decoration layout, or @NULL@ to unset the layout
        -> m ()
    windowControlsSetDecorationLayout :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> Maybe Text -> m ()
    windowControlsSetDecorationLayout a
    self Maybe Text
    layout = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeLayout <- case layout 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
    jLayout -> do
                jLayout' <- Text -> IO CString
    textToCString Text
    jLayout
                return jLayout'
        gtk_window_controls_set_decoration_layout self' maybeLayout
        touchManagedPtr self
        freeMem maybeLayout
        return ()

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

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

    #endif

    -- method WindowControls::set_side
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowControls" }
    --           , argCType = Just "GtkWindowControls*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window controls widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "side"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PackType" }
    --           , argCType = Just "GtkPackType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a side" , 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_window_controls_set_side" gtk_window_controls_set_side ::
        Ptr WindowControls ->                   -- self : TInterface (Name {namespace = "Gtk", name = "WindowControls"})
        CUInt ->                                -- side : TInterface (Name {namespace = "Gtk", name = "PackType"})
        IO ()

    -- | Determines which part of decoration layout
    -- the window controls widget uses.
    --
    -- See [WindowControls:decorationLayout]("GI.Gtk.Objects.WindowControls#g:attr:decorationLayout").
    windowControlsSetSide ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window controls widget
        -> Gtk.Enums.PackType
        -- ^ /@side@/: a side
        -> m ()
    windowControlsSetSide :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> PackType -> m ()
    windowControlsSetSide a
    self PackType
    side = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let side' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (PackType -> Int) -> PackType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackType -> Int
    forall a. Enum a => a -> Int
    fromEnum) PackType
    side
        gtk_window_controls_set_side self' side'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowControlsSetSideMethodInfo
    instance (signature ~ (Gtk.Enums.PackType -> m ()), MonadIO m, IsWindowControls a) => O.OverloadedMethod WindowControlsSetSideMethodInfo a signature where
        overloadedMethod = windowControlsSetSide

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

    #endif

    -- method WindowControls::set_use_native_controls
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowControls" }
    --           , argCType = Just "GtkWindowControls*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window_controls widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "true to show native window controls"
    --                 , 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_window_controls_set_use_native_controls" gtk_window_controls_set_use_native_controls ::
        Ptr WindowControls ->                   -- self : TInterface (Name {namespace = "Gtk", name = "WindowControls"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether platform native window controls are used.
    --
    -- This option shows the \"stoplight\" buttons on macOS.
    -- For Linux, this option has no effect.
    --
    -- See also <https://docs.gtk.org/gtk4/osx.html?native-window-controls Using GTK on Apple macOS>.
    --
    -- /Since: 4.18/
    windowControlsSetUseNativeControls ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindowControls a) =>
        a
        -- ^ /@self@/: a window_controls widget
        -> Bool
        -- ^ /@setting@/: true to show native window controls
        -> m ()
    windowControlsSetUseNativeControls :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindowControls a) =>
    a -> Bool -> m ()
    windowControlsSetUseNativeControls a
    self Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr WindowControls)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_window_controls_set_use_native_controls self' setting'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowControlsSetUseNativeControlsMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindowControls a) => O.OverloadedMethod WindowControlsSetUseNativeControlsMethodInfo a signature where
        overloadedMethod = windowControlsSetUseNativeControls

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

    #endif