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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A toplevel window which can contain other widgets.
    --
    -- \<picture>
    --   \<source srcset=\"window-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"An example GtkWindow\" src=\"window.png\">
    -- \<\/picture>
    --
    -- Windows normally have decorations that are under the control
    -- of the windowing system and allow the user to manipulate the window
    -- (resize it, move it, close it,...).
    --
    -- = GtkWindow as GtkBuildable
    --
    -- The @GtkWindow@ implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface supports
    -- setting a child as the titlebar by specifying “titlebar” as the “type”
    -- attribute of a @\<child>@ element.
    --
    -- = Shortcuts and Gestures
    --
    -- @GtkWindow@ supports the following keyboard shortcuts:
    --
    -- * \<kbd>F10\<\/kbd> activates the menubar, if present.
    -- * \<kbd>Alt\<\/kbd> makes the mnemonics visible while pressed.
    --
    --
    -- The following signals have default keybindings:
    --
    -- * [Window::activateDefault]("GI.Gtk.Objects.Window#g:signal:activateDefault")
    -- * [Window::activateFocus]("GI.Gtk.Objects.Window#g:signal:activateFocus")
    -- * [Window::enableDebugging]("GI.Gtk.Objects.Window#g:signal:enableDebugging")
    --
    --
    -- = Actions
    --
    -- @GtkWindow@ defines a set of built-in actions:
    --
    -- * @default.activate@ activates the default widget.
    -- * @window.minimize@ minimizes the window.
    -- * @window.toggle-maximized@ maximizes or restores the window.
    -- * @window.close@ closes the window.
    --
    --
    -- = CSS nodes
    --
    --
    --
    -- >window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
    -- >├── <child>
    -- >╰── <titlebar child>.titlebar [.default-decoration]
    --
    --
    -- @GtkWindow@ has a main CSS node with name window and style class .background.
    --
    -- Style classes that are typically used with the main CSS node are .csd (when
    -- client-side decorations are in use), .solid-csd (for client-side decorations
    -- without invisible borders), .ssd (used by mutter when rendering server-side
    -- decorations). GtkWindow also represents window states with the following
    -- style classes on the main node: .maximized, .fullscreen, .tiled (when supported,
    -- also .tiled-top, .tiled-left, .tiled-right, .tiled-bottom).
    --
    -- @GtkWindow@ subclasses often add their own discriminating style classes,
    -- such as .dialog, .popup or .tooltip.
    --
    -- Generally, some CSS properties don\'t make sense on the toplevel window node,
    -- such as margins or padding. When client-side decorations without invisible
    -- borders are in use (i.e. the .solid-csd style class is added to the
    -- main window node), the CSS border of the toplevel window is used for
    -- resize drags. In the .csd case, the shadow area outside of the window
    -- can be used to resize it.
    --
    -- @GtkWindow@ adds the .titlebar and .default-decoration style classes to the
    -- widget that is added as a titlebar child.
    --
    -- = Accessibility
    --
    -- @GtkWindow@ uses the 'GI.Gtk.Enums.AccessibleRoleWindow' role.
    --
    -- From GTK 4.12 to 4.18, it used the 'GI.Gtk.Enums.AccessibleRoleApplication' role.

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

    module GI.Gtk.Objects.Window
        (

    -- * Exported types
        Window(..)                              ,
        IsWindow                                ,
        toWindow                                ,

     -- * 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"), [close]("GI.Gtk.Objects.Window#g:method:close"), [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"), [destroy]("GI.Gtk.Objects.Window#g:method:destroy"), [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"), [fullscreen]("GI.Gtk.Objects.Window#g:method:fullscreen"), [fullscreenOnMonitor]("GI.Gtk.Objects.Window#g:method:fullscreenOnMonitor"), [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"), [hasGroup]("GI.Gtk.Objects.Window#g:method:hasGroup"), [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"), [isActive]("GI.Gtk.Objects.Window#g:method:isActive"), [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"), [isFullscreen]("GI.Gtk.Objects.Window#g:method:isFullscreen"), [isMaximized]("GI.Gtk.Objects.Window#g:method:isMaximized"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isSuspended]("GI.Gtk.Objects.Window#g:method:isSuspended"), [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"), [maximize]("GI.Gtk.Objects.Window#g:method:maximize"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [minimize]("GI.Gtk.Objects.Window#g:method:minimize"), [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"), [present]("GI.Gtk.Objects.Window#g:method:present"), [presentWithTime]("GI.Gtk.Objects.Window#g:method:presentWithTime"), [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"), [unfullscreen]("GI.Gtk.Objects.Window#g:method:unfullscreen"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unmaximize]("GI.Gtk.Objects.Window#g:method:unmaximize"), [unminimize]("GI.Gtk.Objects.Window#g:method:unminimize"), [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"), [getApplication]("GI.Gtk.Objects.Window#g:method:getApplication"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.Window#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDecorated]("GI.Gtk.Objects.Window#g:method:getDecorated"), [getDefaultSize]("GI.Gtk.Objects.Window#g:method:getDefaultSize"), [getDefaultWidget]("GI.Gtk.Objects.Window#g:method:getDefaultWidget"), [getDeletable]("GI.Gtk.Objects.Window#g:method:getDeletable"), [getDestroyWithParent]("GI.Gtk.Objects.Window#g:method:getDestroyWithParent"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocus]("GI.Gtk.Objects.Window#g:method:getFocus"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVisible]("GI.Gtk.Objects.Window#g:method:getFocusVisible"), [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"), [getGravity]("GI.Gtk.Objects.Window#g:method:getGravity"), [getGroup]("GI.Gtk.Objects.Window#g:method:getGroup"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHandleMenubarAccel]("GI.Gtk.Objects.Window#g:method:getHandleMenubarAccel"), [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"), [getHideOnClose]("GI.Gtk.Objects.Window#g:method:getHideOnClose"), [getIconName]("GI.Gtk.Objects.Window#g:method:getIconName"), [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"), [getMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:getMnemonicsVisible"), [getModal]("GI.Gtk.Objects.Window#g:method:getModal"), [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"), [getRenderer]("GI.Gtk.Interfaces.Native#g:method:getRenderer"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getResizable]("GI.Gtk.Objects.Window#g:method:getResizable"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSurface]("GI.Gtk.Interfaces.Native#g:method:getSurface"), [getSurfaceTransform]("GI.Gtk.Interfaces.Native#g:method:getSurfaceTransform"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Gtk.Objects.Window#g:method:getTitle"), [getTitlebar]("GI.Gtk.Objects.Window#g:method:getTitlebar"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTransientFor]("GI.Gtk.Objects.Window#g:method:getTransientFor"), [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"), [setApplication]("GI.Gtk.Objects.Window#g:method:setApplication"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.Window#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDecorated]("GI.Gtk.Objects.Window#g:method:setDecorated"), [setDefaultSize]("GI.Gtk.Objects.Window#g:method:setDefaultSize"), [setDefaultWidget]("GI.Gtk.Objects.Window#g:method:setDefaultWidget"), [setDeletable]("GI.Gtk.Objects.Window#g:method:setDeletable"), [setDestroyWithParent]("GI.Gtk.Objects.Window#g:method:setDestroyWithParent"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDisplay]("GI.Gtk.Objects.Window#g:method:setDisplay"), [setFocus]("GI.Gtk.Objects.Window#g:method:setFocus"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVisible]("GI.Gtk.Objects.Window#g:method:setFocusVisible"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setGravity]("GI.Gtk.Objects.Window#g:method:setGravity"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHandleMenubarAccel]("GI.Gtk.Objects.Window#g:method:setHandleMenubarAccel"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHideOnClose]("GI.Gtk.Objects.Window#g:method:setHideOnClose"), [setIconName]("GI.Gtk.Objects.Window#g:method:setIconName"), [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"), [setMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:setMnemonicsVisible"), [setModal]("GI.Gtk.Objects.Window#g:method:setModal"), [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"), [setResizable]("GI.Gtk.Objects.Window#g:method:setResizable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartupId]("GI.Gtk.Objects.Window#g:method:setStartupId"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTitle]("GI.Gtk.Objects.Window#g:method:setTitle"), [setTitlebar]("GI.Gtk.Objects.Window#g:method:setTitlebar"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTransientFor]("GI.Gtk.Objects.Window#g:method:setTransientFor"), [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)
        ResolveWindowMethod                     ,
    #endif

    -- ** close #method:close#

    #if defined(ENABLE_OVERLOADING)
        WindowCloseMethodInfo                   ,
    #endif
        windowClose                             ,

    -- ** destroy #method:destroy#

    #if defined(ENABLE_OVERLOADING)
        WindowDestroyMethodInfo                 ,
    #endif
        windowDestroy                           ,

    -- ** fullscreen #method:fullscreen#

    #if defined(ENABLE_OVERLOADING)
        WindowFullscreenMethodInfo              ,
    #endif
        windowFullscreen                        ,

    -- ** fullscreenOnMonitor #method:fullscreenOnMonitor#

    #if defined(ENABLE_OVERLOADING)
        WindowFullscreenOnMonitorMethodInfo     ,
    #endif
        windowFullscreenOnMonitor               ,

    -- ** getApplication #method:getApplication#

    #if defined(ENABLE_OVERLOADING)
        WindowGetApplicationMethodInfo          ,
    #endif
        windowGetApplication                    ,

    -- ** getChild #method:getChild#

    #if defined(ENABLE_OVERLOADING)
        WindowGetChildMethodInfo                ,
    #endif
        windowGetChild                          ,

    -- ** getDecorated #method:getDecorated#

    #if defined(ENABLE_OVERLOADING)
        WindowGetDecoratedMethodInfo            ,
    #endif
        windowGetDecorated                      ,

    -- ** getDefaultIconName #method:getDefaultIconName#

        windowGetDefaultIconName                ,

    -- ** getDefaultSize #method:getDefaultSize#

    #if defined(ENABLE_OVERLOADING)
        WindowGetDefaultSizeMethodInfo          ,
    #endif
        windowGetDefaultSize                    ,

    -- ** getDefaultWidget #method:getDefaultWidget#

    #if defined(ENABLE_OVERLOADING)
        WindowGetDefaultWidgetMethodInfo        ,
    #endif
        windowGetDefaultWidget                  ,

    -- ** getDeletable #method:getDeletable#

    #if defined(ENABLE_OVERLOADING)
        WindowGetDeletableMethodInfo            ,
    #endif
        windowGetDeletable                      ,

    -- ** getDestroyWithParent #method:getDestroyWithParent#

    #if defined(ENABLE_OVERLOADING)
        WindowGetDestroyWithParentMethodInfo    ,
    #endif
        windowGetDestroyWithParent              ,

    -- ** getFocus #method:getFocus#

    #if defined(ENABLE_OVERLOADING)
        WindowGetFocusMethodInfo                ,
    #endif
        windowGetFocus                          ,

    -- ** getFocusVisible #method:getFocusVisible#

    #if defined(ENABLE_OVERLOADING)
        WindowGetFocusVisibleMethodInfo         ,
    #endif
        windowGetFocusVisible                   ,

    -- ** getGravity #method:getGravity#

    #if defined(ENABLE_OVERLOADING)
        WindowGetGravityMethodInfo              ,
    #endif
        windowGetGravity                        ,

    -- ** getGroup #method:getGroup#

    #if defined(ENABLE_OVERLOADING)
        WindowGetGroupMethodInfo                ,
    #endif
        windowGetGroup                          ,

    -- ** getHandleMenubarAccel #method:getHandleMenubarAccel#

    #if defined(ENABLE_OVERLOADING)
        WindowGetHandleMenubarAccelMethodInfo   ,
    #endif
        windowGetHandleMenubarAccel             ,

    -- ** getHideOnClose #method:getHideOnClose#

    #if defined(ENABLE_OVERLOADING)
        WindowGetHideOnCloseMethodInfo          ,
    #endif
        windowGetHideOnClose                    ,

    -- ** getIconName #method:getIconName#

    #if defined(ENABLE_OVERLOADING)
        WindowGetIconNameMethodInfo             ,
    #endif
        windowGetIconName                       ,

    -- ** getMnemonicsVisible #method:getMnemonicsVisible#

    #if defined(ENABLE_OVERLOADING)
        WindowGetMnemonicsVisibleMethodInfo     ,
    #endif
        windowGetMnemonicsVisible               ,

    -- ** getModal #method:getModal#

    #if defined(ENABLE_OVERLOADING)
        WindowGetModalMethodInfo                ,
    #endif
        windowGetModal                          ,

    -- ** getResizable #method:getResizable#

    #if defined(ENABLE_OVERLOADING)
        WindowGetResizableMethodInfo            ,
    #endif
        windowGetResizable                      ,

    -- ** getTitle #method:getTitle#

    #if defined(ENABLE_OVERLOADING)
        WindowGetTitleMethodInfo                ,
    #endif
        windowGetTitle                          ,

    -- ** getTitlebar #method:getTitlebar#

    #if defined(ENABLE_OVERLOADING)
        WindowGetTitlebarMethodInfo             ,
    #endif
        windowGetTitlebar                       ,

    -- ** getToplevels #method:getToplevels#

        windowGetToplevels                      ,

    -- ** getTransientFor #method:getTransientFor#

    #if defined(ENABLE_OVERLOADING)
        WindowGetTransientForMethodInfo         ,
    #endif
        windowGetTransientFor                   ,

    -- ** hasGroup #method:hasGroup#

    #if defined(ENABLE_OVERLOADING)
        WindowHasGroupMethodInfo                ,
    #endif
        windowHasGroup                          ,

    -- ** isActive #method:isActive#

    #if defined(ENABLE_OVERLOADING)
        WindowIsActiveMethodInfo                ,
    #endif
        windowIsActive                          ,

    -- ** isFullscreen #method:isFullscreen#

    #if defined(ENABLE_OVERLOADING)
        WindowIsFullscreenMethodInfo            ,
    #endif
        windowIsFullscreen                      ,

    -- ** isMaximized #method:isMaximized#

    #if defined(ENABLE_OVERLOADING)
        WindowIsMaximizedMethodInfo             ,
    #endif
        windowIsMaximized                       ,

    -- ** isSuspended #method:isSuspended#

    #if defined(ENABLE_OVERLOADING)
        WindowIsSuspendedMethodInfo             ,
    #endif
        windowIsSuspended                       ,

    -- ** listToplevels #method:listToplevels#

        windowListToplevels                     ,

    -- ** maximize #method:maximize#

    #if defined(ENABLE_OVERLOADING)
        WindowMaximizeMethodInfo                ,
    #endif
        windowMaximize                          ,

    -- ** minimize #method:minimize#

    #if defined(ENABLE_OVERLOADING)
        WindowMinimizeMethodInfo                ,
    #endif
        windowMinimize                          ,

    -- ** new #method:new#

        windowNew                               ,

    -- ** present #method:present#

    #if defined(ENABLE_OVERLOADING)
        WindowPresentMethodInfo                 ,
    #endif
        windowPresent                           ,

    -- ** presentWithTime #method:presentWithTime#

    #if defined(ENABLE_OVERLOADING)
        WindowPresentWithTimeMethodInfo         ,
    #endif
        windowPresentWithTime                   ,

    -- ** setApplication #method:setApplication#

    #if defined(ENABLE_OVERLOADING)
        WindowSetApplicationMethodInfo          ,
    #endif
        windowSetApplication                    ,

    -- ** setAutoStartupNotification #method:setAutoStartupNotification#

        windowSetAutoStartupNotification        ,

    -- ** setChild #method:setChild#

    #if defined(ENABLE_OVERLOADING)
        WindowSetChildMethodInfo                ,
    #endif
        windowSetChild                          ,

    -- ** setDecorated #method:setDecorated#

    #if defined(ENABLE_OVERLOADING)
        WindowSetDecoratedMethodInfo            ,
    #endif
        windowSetDecorated                      ,

    -- ** setDefaultIconName #method:setDefaultIconName#

        windowSetDefaultIconName                ,

    -- ** setDefaultSize #method:setDefaultSize#

    #if defined(ENABLE_OVERLOADING)
        WindowSetDefaultSizeMethodInfo          ,
    #endif
        windowSetDefaultSize                    ,

    -- ** setDefaultWidget #method:setDefaultWidget#

    #if defined(ENABLE_OVERLOADING)
        WindowSetDefaultWidgetMethodInfo        ,
    #endif
        windowSetDefaultWidget                  ,

    -- ** setDeletable #method:setDeletable#

    #if defined(ENABLE_OVERLOADING)
        WindowSetDeletableMethodInfo            ,
    #endif
        windowSetDeletable                      ,

    -- ** setDestroyWithParent #method:setDestroyWithParent#

    #if defined(ENABLE_OVERLOADING)
        WindowSetDestroyWithParentMethodInfo    ,
    #endif
        windowSetDestroyWithParent              ,

    -- ** setDisplay #method:setDisplay#

    #if defined(ENABLE_OVERLOADING)
        WindowSetDisplayMethodInfo              ,
    #endif
        windowSetDisplay                        ,

    -- ** setFocus #method:setFocus#

    #if defined(ENABLE_OVERLOADING)
        WindowSetFocusMethodInfo                ,
    #endif
        windowSetFocus                          ,

    -- ** setFocusVisible #method:setFocusVisible#

    #if defined(ENABLE_OVERLOADING)
        WindowSetFocusVisibleMethodInfo         ,
    #endif
        windowSetFocusVisible                   ,

    -- ** setGravity #method:setGravity#

    #if defined(ENABLE_OVERLOADING)
        WindowSetGravityMethodInfo              ,
    #endif
        windowSetGravity                        ,

    -- ** setHandleMenubarAccel #method:setHandleMenubarAccel#

    #if defined(ENABLE_OVERLOADING)
        WindowSetHandleMenubarAccelMethodInfo   ,
    #endif
        windowSetHandleMenubarAccel             ,

    -- ** setHideOnClose #method:setHideOnClose#

    #if defined(ENABLE_OVERLOADING)
        WindowSetHideOnCloseMethodInfo          ,
    #endif
        windowSetHideOnClose                    ,

    -- ** setIconName #method:setIconName#

    #if defined(ENABLE_OVERLOADING)
        WindowSetIconNameMethodInfo             ,
    #endif
        windowSetIconName                       ,

    -- ** setInteractiveDebugging #method:setInteractiveDebugging#

        windowSetInteractiveDebugging           ,

    -- ** setMnemonicsVisible #method:setMnemonicsVisible#

    #if defined(ENABLE_OVERLOADING)
        WindowSetMnemonicsVisibleMethodInfo     ,
    #endif
        windowSetMnemonicsVisible               ,

    -- ** setModal #method:setModal#

    #if defined(ENABLE_OVERLOADING)
        WindowSetModalMethodInfo                ,
    #endif
        windowSetModal                          ,

    -- ** setResizable #method:setResizable#

    #if defined(ENABLE_OVERLOADING)
        WindowSetResizableMethodInfo            ,
    #endif
        windowSetResizable                      ,

    -- ** setStartupId #method:setStartupId#

    #if defined(ENABLE_OVERLOADING)
        WindowSetStartupIdMethodInfo            ,
    #endif
        windowSetStartupId                      ,

    -- ** setTitle #method:setTitle#

    #if defined(ENABLE_OVERLOADING)
        WindowSetTitleMethodInfo                ,
    #endif
        windowSetTitle                          ,

    -- ** setTitlebar #method:setTitlebar#

    #if defined(ENABLE_OVERLOADING)
        WindowSetTitlebarMethodInfo             ,
    #endif
        windowSetTitlebar                       ,

    -- ** setTransientFor #method:setTransientFor#

    #if defined(ENABLE_OVERLOADING)
        WindowSetTransientForMethodInfo         ,
    #endif
        windowSetTransientFor                   ,

    -- ** unfullscreen #method:unfullscreen#

    #if defined(ENABLE_OVERLOADING)
        WindowUnfullscreenMethodInfo            ,
    #endif
        windowUnfullscreen                      ,

    -- ** unmaximize #method:unmaximize#

    #if defined(ENABLE_OVERLOADING)
        WindowUnmaximizeMethodInfo              ,
    #endif
        windowUnmaximize                        ,

    -- ** unminimize #method:unminimize#

    #if defined(ENABLE_OVERLOADING)
        WindowUnminimizeMethodInfo              ,
    #endif
        windowUnminimize                        ,

     -- * Properties

    -- ** application #attr:application#
    -- | The @GtkApplication@ associated with the window.
    --
    -- The application will be kept alive for at least as long as it
    -- has any windows associated with it (see 'GI.Gio.Objects.Application.applicationHold'
    -- for a way to keep it alive without windows).
    --
    -- Normally, the connection between the application and the window
    -- will remain until the window is destroyed, but you can explicitly
    -- remove it by setting the this property to @NULL@.

    #if defined(ENABLE_OVERLOADING)
        WindowApplicationPropertyInfo           ,
    #endif
        clearWindowApplication                  ,
        constructWindowApplication              ,
        getWindowApplication                    ,
        setWindowApplication                    ,
    #if defined(ENABLE_OVERLOADING)
        windowApplication                       ,
    #endif

    -- ** child #attr:child#
    -- | The child widget.

    #if defined(ENABLE_OVERLOADING)
        WindowChildPropertyInfo                 ,
    #endif
        clearWindowChild                        ,
        constructWindowChild                    ,
        getWindowChild                          ,
        setWindowChild                          ,
    #if defined(ENABLE_OVERLOADING)
        windowChild                             ,
    #endif

    -- ** decorated #attr:decorated#
    -- | Whether the window should have a frame (also known as *decorations*).

    #if defined(ENABLE_OVERLOADING)
        WindowDecoratedPropertyInfo             ,
    #endif
        constructWindowDecorated                ,
        getWindowDecorated                      ,
        setWindowDecorated                      ,
    #if defined(ENABLE_OVERLOADING)
        windowDecorated                         ,
    #endif

    -- ** defaultHeight #attr:defaultHeight#
    -- | The default height of the window.

    #if defined(ENABLE_OVERLOADING)
        WindowDefaultHeightPropertyInfo         ,
    #endif
        constructWindowDefaultHeight            ,
        getWindowDefaultHeight                  ,
        setWindowDefaultHeight                  ,
    #if defined(ENABLE_OVERLOADING)
        windowDefaultHeight                     ,
    #endif

    -- ** defaultWidget #attr:defaultWidget#
    -- | The default widget.

    #if defined(ENABLE_OVERLOADING)
        WindowDefaultWidgetPropertyInfo         ,
    #endif
        clearWindowDefaultWidget                ,
        constructWindowDefaultWidget            ,
        getWindowDefaultWidget                  ,
        setWindowDefaultWidget                  ,
    #if defined(ENABLE_OVERLOADING)
        windowDefaultWidget                     ,
    #endif

    -- ** defaultWidth #attr:defaultWidth#
    -- | The default width of the window.

    #if defined(ENABLE_OVERLOADING)
        WindowDefaultWidthPropertyInfo          ,
    #endif
        constructWindowDefaultWidth             ,
        getWindowDefaultWidth                   ,
        setWindowDefaultWidth                   ,
    #if defined(ENABLE_OVERLOADING)
        windowDefaultWidth                      ,
    #endif

    -- ** deletable #attr:deletable#
    -- | Whether the window frame should have a close button.

    #if defined(ENABLE_OVERLOADING)
        WindowDeletablePropertyInfo             ,
    #endif
        constructWindowDeletable                ,
        getWindowDeletable                      ,
        setWindowDeletable                      ,
    #if defined(ENABLE_OVERLOADING)
        windowDeletable                         ,
    #endif

    -- ** destroyWithParent #attr:destroyWithParent#
    -- | If this window should be destroyed when the parent is destroyed.

    #if defined(ENABLE_OVERLOADING)
        WindowDestroyWithParentPropertyInfo     ,
    #endif
        constructWindowDestroyWithParent        ,
        getWindowDestroyWithParent              ,
        setWindowDestroyWithParent              ,
    #if defined(ENABLE_OVERLOADING)
        windowDestroyWithParent                 ,
    #endif

    -- ** display #attr:display#
    -- | The display that will display this window.

    #if defined(ENABLE_OVERLOADING)
        WindowDisplayPropertyInfo               ,
    #endif
        constructWindowDisplay                  ,
        getWindowDisplay                        ,
        setWindowDisplay                        ,
    #if defined(ENABLE_OVERLOADING)
        windowDisplay                           ,
    #endif

    -- ** focusVisible #attr:focusVisible#
    -- | Whether \'focus rectangles\' are currently visible in this window.
    --
    -- This property is maintained by GTK based on user input
    -- and should not be set by applications.

    #if defined(ENABLE_OVERLOADING)
        WindowFocusVisiblePropertyInfo          ,
    #endif
        constructWindowFocusVisible             ,
        getWindowFocusVisible                   ,
        setWindowFocusVisible                   ,
    #if defined(ENABLE_OVERLOADING)
        windowFocusVisible                      ,
    #endif

    -- ** focusWidget #attr:focusWidget#
    -- | The focus widget.

    #if defined(ENABLE_OVERLOADING)
        WindowFocusWidgetPropertyInfo           ,
    #endif
        clearWindowFocusWidget                  ,
        constructWindowFocusWidget              ,
        getWindowFocusWidget                    ,
        setWindowFocusWidget                    ,
    #if defined(ENABLE_OVERLOADING)
        windowFocusWidget                       ,
    #endif

    -- ** fullscreened #attr:fullscreened#
    -- | Whether the window is fullscreen.
    --
    -- Setting this property is the equivalent of calling
    -- 'GI.Gtk.Objects.Window.windowFullscreen' or 'GI.Gtk.Objects.Window.windowUnfullscreen';
    -- either operation is asynchronous, which means you will need to
    -- connect to the [notify](#g:signal:notify) signal in order to know whether the
    -- operation was successful.

    #if defined(ENABLE_OVERLOADING)
        WindowFullscreenedPropertyInfo          ,
    #endif
        constructWindowFullscreened             ,
        getWindowFullscreened                   ,
        setWindowFullscreened                   ,
    #if defined(ENABLE_OVERLOADING)
        windowFullscreened                      ,
    #endif

    -- ** gravity #attr:gravity#
    -- | The gravity to use when resizing the window programmatically.
    --
    -- Gravity describes which point of the window we want to keep
    -- fixed (meaning that the window will grow in the opposite direction).
    -- For example, a gravity of @GTK_WINDOW_GRAVITY_TOP_RIGHT@ means that we
    -- want the to fix top right corner of the window.
    --
    -- /Since: 4.20/

    #if defined(ENABLE_OVERLOADING)
        WindowGravityPropertyInfo               ,
    #endif
        constructWindowGravity                  ,
        getWindowGravity                        ,
        setWindowGravity                        ,
    #if defined(ENABLE_OVERLOADING)
        windowGravity                           ,
    #endif

    -- ** handleMenubarAccel #attr:handleMenubarAccel#
    -- | Whether the window frame should handle \<kbd>F10\<\/kbd> for activating
    -- menubars.
    --
    -- /Since: 4.2/

    #if defined(ENABLE_OVERLOADING)
        WindowHandleMenubarAccelPropertyInfo    ,
    #endif
        constructWindowHandleMenubarAccel       ,
        getWindowHandleMenubarAccel             ,
        setWindowHandleMenubarAccel             ,
    #if defined(ENABLE_OVERLOADING)
        windowHandleMenubarAccel                ,
    #endif

    -- ** hideOnClose #attr:hideOnClose#
    -- | If this window should be hidden instead of destroyed when the user clicks
    -- the close button.

    #if defined(ENABLE_OVERLOADING)
        WindowHideOnClosePropertyInfo           ,
    #endif
        constructWindowHideOnClose              ,
        getWindowHideOnClose                    ,
        setWindowHideOnClose                    ,
    #if defined(ENABLE_OVERLOADING)
        windowHideOnClose                       ,
    #endif

    -- ** iconName #attr:iconName#
    -- | Specifies the name of the themed icon to use as the window icon.
    --
    -- See t'GI.Gtk.Objects.IconTheme.IconTheme' for more details.

    #if defined(ENABLE_OVERLOADING)
        WindowIconNamePropertyInfo              ,
    #endif
        clearWindowIconName                     ,
        constructWindowIconName                 ,
        getWindowIconName                       ,
        setWindowIconName                       ,
    #if defined(ENABLE_OVERLOADING)
        windowIconName                          ,
    #endif

    -- ** isActive #attr:isActive#
    -- | Whether the toplevel is the currently active window.

    #if defined(ENABLE_OVERLOADING)
        WindowIsActivePropertyInfo              ,
    #endif
        getWindowIsActive                       ,

    -- ** maximized #attr:maximized#
    -- | Whether the window is maximized.
    --
    -- Setting this property is the equivalent of calling
    -- 'GI.Gtk.Objects.Window.windowMaximize' or 'GI.Gtk.Objects.Window.windowUnmaximize';
    -- either operation is asynchronous, which means you will need to
    -- connect to the [notify](#g:signal:notify) signal in order to know whether the
    -- operation was successful.

    #if defined(ENABLE_OVERLOADING)
        WindowMaximizedPropertyInfo             ,
    #endif
        constructWindowMaximized                ,
        getWindowMaximized                      ,
        setWindowMaximized                      ,
    #if defined(ENABLE_OVERLOADING)
        windowMaximized                         ,
    #endif

    -- ** mnemonicsVisible #attr:mnemonicsVisible#
    -- | Whether mnemonics are currently visible in this window.
    --
    -- This property is maintained by GTK based on user input,
    -- and should not be set by applications.

    #if defined(ENABLE_OVERLOADING)
        WindowMnemonicsVisiblePropertyInfo      ,
    #endif
        constructWindowMnemonicsVisible         ,
        getWindowMnemonicsVisible               ,
        setWindowMnemonicsVisible               ,
    #if defined(ENABLE_OVERLOADING)
        windowMnemonicsVisible                  ,
    #endif

    -- ** modal #attr:modal#
    -- | If true, the window is modal.

    #if defined(ENABLE_OVERLOADING)
        WindowModalPropertyInfo                 ,
    #endif
        constructWindowModal                    ,
        getWindowModal                          ,
        setWindowModal                          ,
    #if defined(ENABLE_OVERLOADING)
        windowModal                             ,
    #endif

    -- ** resizable #attr:resizable#
    -- | If true, users can resize the window.

    #if defined(ENABLE_OVERLOADING)
        WindowResizablePropertyInfo             ,
    #endif
        constructWindowResizable                ,
        getWindowResizable                      ,
        setWindowResizable                      ,
    #if defined(ENABLE_OVERLOADING)
        windowResizable                         ,
    #endif

    -- ** startupId #attr:startupId#
    -- | A write-only property for setting window\'s startup notification identifier.

    #if defined(ENABLE_OVERLOADING)
        WindowStartupIdPropertyInfo             ,
    #endif
        constructWindowStartupId                ,
        setWindowStartupId                      ,
    #if defined(ENABLE_OVERLOADING)
        windowStartupId                         ,
    #endif

    -- ** suspended #attr:suspended#
    -- | Whether the window is suspended.
    --
    -- See 'GI.Gtk.Objects.Window.windowIsSuspended' for details about what suspended means.
    --
    -- /Since: 4.12/

    #if defined(ENABLE_OVERLOADING)
        WindowSuspendedPropertyInfo             ,
    #endif
        getWindowSuspended                      ,
    #if defined(ENABLE_OVERLOADING)
        windowSuspended                         ,
    #endif

    -- ** title #attr:title#
    -- | The title of the window.

    #if defined(ENABLE_OVERLOADING)
        WindowTitlePropertyInfo                 ,
    #endif
        clearWindowTitle                        ,
        constructWindowTitle                    ,
        getWindowTitle                          ,
        setWindowTitle                          ,
    #if defined(ENABLE_OVERLOADING)
        windowTitle                             ,
    #endif

    -- ** titlebar #attr:titlebar#
    -- | The titlebar widget.
    --
    -- /Since: 4.6/

    #if defined(ENABLE_OVERLOADING)
        WindowTitlebarPropertyInfo              ,
    #endif
        clearWindowTitlebar                     ,
        constructWindowTitlebar                 ,
        getWindowTitlebar                       ,
        setWindowTitlebar                       ,
    #if defined(ENABLE_OVERLOADING)
        windowTitlebar                          ,
    #endif

    -- ** transientFor #attr:transientFor#
    -- | The transient parent of the window.

    #if defined(ENABLE_OVERLOADING)
        WindowTransientForPropertyInfo          ,
    #endif
        clearWindowTransientFor                 ,
        constructWindowTransientFor             ,
        getWindowTransientFor                   ,
        setWindowTransientFor                   ,
    #if defined(ENABLE_OVERLOADING)
        windowTransientFor                      ,
    #endif

     -- * Signals

    -- ** activateDefault #signal:activateDefault#

        WindowActivateDefaultCallback           ,
    #if defined(ENABLE_OVERLOADING)
        WindowActivateDefaultSignalInfo         ,
    #endif
        afterWindowActivateDefault              ,
        onWindowActivateDefault                 ,

    -- ** activateFocus #signal:activateFocus#

        WindowActivateFocusCallback             ,
    #if defined(ENABLE_OVERLOADING)
        WindowActivateFocusSignalInfo           ,
    #endif
        afterWindowActivateFocus                ,
        onWindowActivateFocus                   ,

    -- ** closeRequest #signal:closeRequest#

        WindowCloseRequestCallback              ,
    #if defined(ENABLE_OVERLOADING)
        WindowCloseRequestSignalInfo            ,
    #endif
        afterWindowCloseRequest                 ,
        onWindowCloseRequest                    ,

    -- ** enableDebugging #signal:enableDebugging#

        WindowEnableDebuggingCallback           ,
    #if defined(ENABLE_OVERLOADING)
        WindowEnableDebuggingSignalInfo         ,
    #endif
        afterWindowEnableDebugging              ,
        onWindowEnableDebugging                 ,

    -- ** keysChanged #signal:keysChanged#

        WindowKeysChangedCallback               ,
    #if defined(ENABLE_OVERLOADING)
        WindowKeysChangedSignalInfo             ,
    #endif
        afterWindowKeysChanged                  ,
        onWindowKeysChanged                     ,

        ) 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.Monitor as Gdk.Monitor
    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.Flags as Gio.Flags
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.ActionMap as Gio.ActionMap
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.Gio.Objects.Application as Gio.Application
    import qualified GI.Gio.Objects.Menu as Gio.Menu
    import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
    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.ShortcutManager as Gtk.ShortcutManager
    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.Application as Gtk.Application
    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.Objects.WindowGroup as Gtk.WindowGroup
    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 qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.Monitor as Gdk.Monitor
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    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.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ShortcutManager as Gtk.ShortcutManager
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Application as Gtk.Application
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Objects.WindowGroup as Gtk.WindowGroup

    #endif

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

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

    foreign import ccall "gtk_window_get_type"
        c_gtk_window_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Window where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_window_get_type

    instance B.Types.GObject Window

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

    instance O.HasParentTypes Window
    type instance O.ParentTypes Window = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Native.Native, Gtk.Root.Root, Gtk.ShortcutManager.ShortcutManager]

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveWindowMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveWindowMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
        ResolveWindowMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
        ResolveWindowMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
        ResolveWindowMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
        ResolveWindowMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
        ResolveWindowMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
        ResolveWindowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
        ResolveWindowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
        ResolveWindowMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
        ResolveWindowMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
        ResolveWindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveWindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveWindowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
        ResolveWindowMethod "close" o = WindowCloseMethodInfo
        ResolveWindowMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
        ResolveWindowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
        ResolveWindowMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
        ResolveWindowMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
        ResolveWindowMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
        ResolveWindowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
        ResolveWindowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
        ResolveWindowMethod "destroy" o = WindowDestroyMethodInfo
        ResolveWindowMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
        ResolveWindowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
        ResolveWindowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
        ResolveWindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveWindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveWindowMethod "fullscreen" o = WindowFullscreenMethodInfo
        ResolveWindowMethod "fullscreenOnMonitor" o = WindowFullscreenOnMonitorMethodInfo
        ResolveWindowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveWindowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
        ResolveWindowMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
        ResolveWindowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
        ResolveWindowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
        ResolveWindowMethod "hasGroup" o = WindowHasGroupMethodInfo
        ResolveWindowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
        ResolveWindowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
        ResolveWindowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
        ResolveWindowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
        ResolveWindowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
        ResolveWindowMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
        ResolveWindowMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
        ResolveWindowMethod "isActive" o = WindowIsActiveMethodInfo
        ResolveWindowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
        ResolveWindowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
        ResolveWindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveWindowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
        ResolveWindowMethod "isFullscreen" o = WindowIsFullscreenMethodInfo
        ResolveWindowMethod "isMaximized" o = WindowIsMaximizedMethodInfo
        ResolveWindowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
        ResolveWindowMethod "isSuspended" o = WindowIsSuspendedMethodInfo
        ResolveWindowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
        ResolveWindowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
        ResolveWindowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
        ResolveWindowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
        ResolveWindowMethod "maximize" o = WindowMaximizeMethodInfo
        ResolveWindowMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
        ResolveWindowMethod "minimize" o = WindowMinimizeMethodInfo
        ResolveWindowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
        ResolveWindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveWindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveWindowMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
        ResolveWindowMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
        ResolveWindowMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
        ResolveWindowMethod "present" o = WindowPresentMethodInfo
        ResolveWindowMethod "presentWithTime" o = WindowPresentWithTimeMethodInfo
        ResolveWindowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
        ResolveWindowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
        ResolveWindowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
        ResolveWindowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
        ResolveWindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveWindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveWindowMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
        ResolveWindowMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
        ResolveWindowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
        ResolveWindowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
        ResolveWindowMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
        ResolveWindowMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
        ResolveWindowMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
        ResolveWindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveWindowMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
        ResolveWindowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
        ResolveWindowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
        ResolveWindowMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
        ResolveWindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveWindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveWindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveWindowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
        ResolveWindowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
        ResolveWindowMethod "unfullscreen" o = WindowUnfullscreenMethodInfo
        ResolveWindowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
        ResolveWindowMethod "unmaximize" o = WindowUnmaximizeMethodInfo
        ResolveWindowMethod "unminimize" o = WindowUnminimizeMethodInfo
        ResolveWindowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
        ResolveWindowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
        ResolveWindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveWindowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
        ResolveWindowMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
        ResolveWindowMethod "updatePlatformState" o = Gtk.Accessible.AccessibleUpdatePlatformStateMethodInfo
        ResolveWindowMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
        ResolveWindowMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
        ResolveWindowMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
        ResolveWindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveWindowMethod "getAccessibleId" o = Gtk.Accessible.AccessibleGetAccessibleIdMethodInfo
        ResolveWindowMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
        ResolveWindowMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
        ResolveWindowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
        ResolveWindowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
        ResolveWindowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
        ResolveWindowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
        ResolveWindowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
        ResolveWindowMethod "getApplication" o = WindowGetApplicationMethodInfo
        ResolveWindowMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
        ResolveWindowMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
        ResolveWindowMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
        ResolveWindowMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
        ResolveWindowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
        ResolveWindowMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
        ResolveWindowMethod "getChild" o = WindowGetChildMethodInfo
        ResolveWindowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
        ResolveWindowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
        ResolveWindowMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
        ResolveWindowMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
        ResolveWindowMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
        ResolveWindowMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
        ResolveWindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveWindowMethod "getDecorated" o = WindowGetDecoratedMethodInfo
        ResolveWindowMethod "getDefaultSize" o = WindowGetDefaultSizeMethodInfo
        ResolveWindowMethod "getDefaultWidget" o = WindowGetDefaultWidgetMethodInfo
        ResolveWindowMethod "getDeletable" o = WindowGetDeletableMethodInfo
        ResolveWindowMethod "getDestroyWithParent" o = WindowGetDestroyWithParentMethodInfo
        ResolveWindowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
        ResolveWindowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
        ResolveWindowMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
        ResolveWindowMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
        ResolveWindowMethod "getFocus" o = WindowGetFocusMethodInfo
        ResolveWindowMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
        ResolveWindowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
        ResolveWindowMethod "getFocusVisible" o = WindowGetFocusVisibleMethodInfo
        ResolveWindowMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
        ResolveWindowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
        ResolveWindowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
        ResolveWindowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
        ResolveWindowMethod "getGravity" o = WindowGetGravityMethodInfo
        ResolveWindowMethod "getGroup" o = WindowGetGroupMethodInfo
        ResolveWindowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
        ResolveWindowMethod "getHandleMenubarAccel" o = WindowGetHandleMenubarAccelMethodInfo
        ResolveWindowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
        ResolveWindowMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
        ResolveWindowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
        ResolveWindowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
        ResolveWindowMethod "getHideOnClose" o = WindowGetHideOnCloseMethodInfo
        ResolveWindowMethod "getIconName" o = WindowGetIconNameMethodInfo
        ResolveWindowMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
        ResolveWindowMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
        ResolveWindowMethod "getLimitEvents" o = Gtk.Widget.WidgetGetLimitEventsMethodInfo
        ResolveWindowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
        ResolveWindowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
        ResolveWindowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
        ResolveWindowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
        ResolveWindowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
        ResolveWindowMethod "getMnemonicsVisible" o = WindowGetMnemonicsVisibleMethodInfo
        ResolveWindowMethod "getModal" o = WindowGetModalMethodInfo
        ResolveWindowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
        ResolveWindowMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
        ResolveWindowMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
        ResolveWindowMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
        ResolveWindowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
        ResolveWindowMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
        ResolveWindowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
        ResolveWindowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
        ResolveWindowMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
        ResolveWindowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
        ResolveWindowMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
        ResolveWindowMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
        ResolveWindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveWindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveWindowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
        ResolveWindowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
        ResolveWindowMethod "getRenderer" o = Gtk.Native.NativeGetRendererMethodInfo
        ResolveWindowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
        ResolveWindowMethod "getResizable" o = WindowGetResizableMethodInfo
        ResolveWindowMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
        ResolveWindowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
        ResolveWindowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
        ResolveWindowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
        ResolveWindowMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
        ResolveWindowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
        ResolveWindowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
        ResolveWindowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
        ResolveWindowMethod "getSurface" o = Gtk.Native.NativeGetSurfaceMethodInfo
        ResolveWindowMethod "getSurfaceTransform" o = Gtk.Native.NativeGetSurfaceTransformMethodInfo
        ResolveWindowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
        ResolveWindowMethod "getTitle" o = WindowGetTitleMethodInfo
        ResolveWindowMethod "getTitlebar" o = WindowGetTitlebarMethodInfo
        ResolveWindowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
        ResolveWindowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
        ResolveWindowMethod "getTransientFor" o = WindowGetTransientForMethodInfo
        ResolveWindowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
        ResolveWindowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
        ResolveWindowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
        ResolveWindowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
        ResolveWindowMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
        ResolveWindowMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
        ResolveWindowMethod "setApplication" o = WindowSetApplicationMethodInfo
        ResolveWindowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
        ResolveWindowMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
        ResolveWindowMethod "setChild" o = WindowSetChildMethodInfo
        ResolveWindowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
        ResolveWindowMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
        ResolveWindowMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
        ResolveWindowMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
        ResolveWindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveWindowMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveWindowMethod "setDecorated" o = WindowSetDecoratedMethodInfo
        ResolveWindowMethod "setDefaultSize" o = WindowSetDefaultSizeMethodInfo
        ResolveWindowMethod "setDefaultWidget" o = WindowSetDefaultWidgetMethodInfo
        ResolveWindowMethod "setDeletable" o = WindowSetDeletableMethodInfo
        ResolveWindowMethod "setDestroyWithParent" o = WindowSetDestroyWithParentMethodInfo
        ResolveWindowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
        ResolveWindowMethod "setDisplay" o = WindowSetDisplayMethodInfo
        ResolveWindowMethod "setFocus" o = WindowSetFocusMethodInfo
        ResolveWindowMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
        ResolveWindowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
        ResolveWindowMethod "setFocusVisible" o = WindowSetFocusVisibleMethodInfo
        ResolveWindowMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
        ResolveWindowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
        ResolveWindowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
        ResolveWindowMethod "setGravity" o = WindowSetGravityMethodInfo
        ResolveWindowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
        ResolveWindowMethod "setHandleMenubarAccel" o = WindowSetHandleMenubarAccelMethodInfo
        ResolveWindowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
        ResolveWindowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
        ResolveWindowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
        ResolveWindowMethod "setHideOnClose" o = WindowSetHideOnCloseMethodInfo
        ResolveWindowMethod "setIconName" o = WindowSetIconNameMethodInfo
        ResolveWindowMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
        ResolveWindowMethod "setLimitEvents" o = Gtk.Widget.WidgetSetLimitEventsMethodInfo
        ResolveWindowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
        ResolveWindowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
        ResolveWindowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
        ResolveWindowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
        ResolveWindowMethod "setMnemonicsVisible" o = WindowSetMnemonicsVisibleMethodInfo
        ResolveWindowMethod "setModal" o = WindowSetModalMethodInfo
        ResolveWindowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
        ResolveWindowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
        ResolveWindowMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
        ResolveWindowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
        ResolveWindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveWindowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
        ResolveWindowMethod "setResizable" o = WindowSetResizableMethodInfo
        ResolveWindowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
        ResolveWindowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
        ResolveWindowMethod "setStartupId" o = WindowSetStartupIdMethodInfo
        ResolveWindowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
        ResolveWindowMethod "setTitle" o = WindowSetTitleMethodInfo
        ResolveWindowMethod "setTitlebar" o = WindowSetTitlebarMethodInfo
        ResolveWindowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
        ResolveWindowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
        ResolveWindowMethod "setTransientFor" o = WindowSetTransientForMethodInfo
        ResolveWindowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
        ResolveWindowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
        ResolveWindowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
        ResolveWindowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
        ResolveWindowMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- signal Window::activate-default
    -- | Emitted when the user activates the default widget.
    --
    -- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
    --
    -- The keybindings for this signal are all forms of the \<kbd>Enter\<\/kbd> key.
    type WindowActivateDefaultCallback =
        IO ()

    type C_WindowActivateDefaultCallback =
        Ptr Window ->                           -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_WindowActivateDefaultCallback ::
        GObject a => (a -> WindowActivateDefaultCallback) ->
        C_WindowActivateDefaultCallback
    wrap_WindowActivateDefaultCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_WindowActivateDefaultCallback
    wrap_WindowActivateDefaultCallback a -> IO ()
    gi'cb Ptr Window
    gi'selfPtr Ptr ()
    _ = do
        Ptr Window -> (Window -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Window
    gi'selfPtr ((Window -> IO ()) -> IO ()) -> (Window -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Window
    gi'self -> a -> IO ()
    gi'cb (Window -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Window
    gi'self)

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

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

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

    #endif

    -- signal Window::activate-focus
    -- | Emitted when the user activates the currently focused
    -- widget of /@window@/.
    --
    -- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
    --
    -- The default binding for this signal is \<kbd>␣\<\/kbd>.
    type WindowActivateFocusCallback =
        IO ()

    type C_WindowActivateFocusCallback =
        Ptr Window ->                           -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_WindowActivateFocusCallback ::
        GObject a => (a -> WindowActivateFocusCallback) ->
        C_WindowActivateFocusCallback
    wrap_WindowActivateFocusCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_WindowActivateDefaultCallback
    wrap_WindowActivateFocusCallback a -> IO ()
    gi'cb Ptr Window
    gi'selfPtr Ptr ()
    _ = do
        Ptr Window -> (Window -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Window
    gi'selfPtr ((Window -> IO ()) -> IO ()) -> (Window -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Window
    gi'self -> a -> IO ()
    gi'cb (Window -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Window
    gi'self)

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

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

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

    #endif

    -- signal Window::close-request
    -- | Emitted when the user clicks on the close button of the window.
    type WindowCloseRequestCallback =
        IO Bool
        -- ^ __Returns:__ true to stop other handlers from being invoked for the signal

    type C_WindowCloseRequestCallback =
        Ptr Window ->                           -- object
        Ptr () ->                               -- user_data
        IO CInt

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

    wrap_WindowCloseRequestCallback ::
        GObject a => (a -> WindowCloseRequestCallback) ->
        C_WindowCloseRequestCallback
    wrap_WindowCloseRequestCallback :: forall a.
    GObject a =>
    (a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
    wrap_WindowCloseRequestCallback a -> WindowCloseRequestCallback
    gi'cb Ptr Window
    gi'selfPtr Ptr ()
    _ = do
        result <- Ptr Window
    -> (Window -> WindowCloseRequestCallback)
    -> WindowCloseRequestCallback
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Window
    gi'selfPtr ((Window -> WindowCloseRequestCallback)
     -> WindowCloseRequestCallback)
    -> (Window -> WindowCloseRequestCallback)
    -> WindowCloseRequestCallback
    forall a b. (a -> b) -> a -> b
    $ \Window
    gi'self -> a -> WindowCloseRequestCallback
    gi'cb (Window -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Window
    gi'self)
        let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
        return result'

    -- | Connect a signal handler for the [closeRequest](#signal:closeRequest) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' window #closeRequest callback
    -- @
    --
    --
    onWindowCloseRequest :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCloseRequestCallback) -> m SignalHandlerId
    onWindowCloseRequest :: forall a (m :: * -> *).
    (IsWindow a, MonadIO m) =>
    a
    -> ((?self::a) => WindowCloseRequestCallback) -> m SignalHandlerId
    onWindowCloseRequest a
    obj (?self::a) => WindowCloseRequestCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> WindowCloseRequestCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in WindowCloseRequestCallback
    (?self::a) => WindowCloseRequestCallback
    cb
        let wrapped' :: C_WindowCloseRequestCallback
    wrapped' = (a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
    forall a.
    GObject a =>
    (a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
    wrap_WindowCloseRequestCallback a -> WindowCloseRequestCallback
    wrapped
        wrapped'' <- C_WindowCloseRequestCallback
    -> IO (FunPtr C_WindowCloseRequestCallback)
    mk_WindowCloseRequestCallback C_WindowCloseRequestCallback
    wrapped'
        connectSignalFunPtr obj "close-request" wrapped'' SignalConnectBefore Nothing

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

    #if defined(ENABLE_OVERLOADING)
    data WindowCloseRequestSignalInfo
    instance SignalInfo WindowCloseRequestSignalInfo where
        type HaskellCallbackType WindowCloseRequestSignalInfo = WindowCloseRequestCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_WindowCloseRequestCallback cb
            cb'' <- mk_WindowCloseRequestCallback cb'
            connectSignalFunPtr obj "close-request" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window::close-request"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:signal:closeRequest"})

    #endif

    -- signal Window::enable-debugging
    -- | Emitted when the user enables or disables interactive debugging.
    --
    -- When /@toggle@/ is true, interactive debugging is toggled on or off,
    -- when it is false, the debugger will be pointed at the widget
    -- under the pointer.
    --
    -- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
    --
    -- The default bindings for this signal are
    -- \<kbd>Ctrl\<\/kbd>+\<kbd>Shift\<\/kbd>+\<kbd>I\<\/kbd> and
    -- \<kbd>Ctrl\<\/kbd>+\<kbd>Shift\<\/kbd>+\<kbd>D\<\/kbd>.
    type WindowEnableDebuggingCallback =
        Bool
        -- ^ /@toggle@/: toggle the debugger
        -> IO Bool
        -- ^ __Returns:__ true if the key binding was handled

    type C_WindowEnableDebuggingCallback =
        Ptr Window ->                           -- object
        CInt ->
        Ptr () ->                               -- user_data
        IO CInt

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

    wrap_WindowEnableDebuggingCallback ::
        GObject a => (a -> WindowEnableDebuggingCallback) ->
        C_WindowEnableDebuggingCallback
    wrap_WindowEnableDebuggingCallback :: forall a.
    GObject a =>
    (a -> WindowEnableDebuggingCallback)
    -> C_WindowEnableDebuggingCallback
    wrap_WindowEnableDebuggingCallback a -> WindowEnableDebuggingCallback
    gi'cb Ptr Window
    gi'selfPtr CInt
    toggle Ptr ()
    _ = do
        let toggle' :: Bool
    toggle' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    toggle
        result <- Ptr Window
    -> (Window -> WindowCloseRequestCallback)
    -> WindowCloseRequestCallback
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Window
    gi'selfPtr ((Window -> WindowCloseRequestCallback)
     -> WindowCloseRequestCallback)
    -> (Window -> WindowCloseRequestCallback)
    -> WindowCloseRequestCallback
    forall a b. (a -> b) -> a -> b
    $ \Window
    gi'self -> a -> WindowEnableDebuggingCallback
    gi'cb (Window -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Window
    gi'self)  Bool
    toggle'
        let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
        return result'

    -- | Connect a signal handler for the [enableDebugging](#signal:enableDebugging) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' window #enableDebugging callback
    -- @
    --
    --
    onWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId
    onWindowEnableDebugging :: forall a (m :: * -> *).
    (IsWindow a, MonadIO m) =>
    a
    -> ((?self::a) => WindowEnableDebuggingCallback)
    -> m SignalHandlerId
    onWindowEnableDebugging a
    obj (?self::a) => WindowEnableDebuggingCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> WindowEnableDebuggingCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => WindowEnableDebuggingCallback
    WindowEnableDebuggingCallback
    cb
        let wrapped' :: C_WindowEnableDebuggingCallback
    wrapped' = (a -> WindowEnableDebuggingCallback)
    -> C_WindowEnableDebuggingCallback
    forall a.
    GObject a =>
    (a -> WindowEnableDebuggingCallback)
    -> C_WindowEnableDebuggingCallback
    wrap_WindowEnableDebuggingCallback a -> WindowEnableDebuggingCallback
    wrapped
        wrapped'' <- C_WindowEnableDebuggingCallback
    -> IO (FunPtr C_WindowEnableDebuggingCallback)
    mk_WindowEnableDebuggingCallback C_WindowEnableDebuggingCallback
    wrapped'
        connectSignalFunPtr obj "enable-debugging" wrapped'' SignalConnectBefore Nothing

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

    #if defined(ENABLE_OVERLOADING)
    data WindowEnableDebuggingSignalInfo
    instance SignalInfo WindowEnableDebuggingSignalInfo where
        type HaskellCallbackType WindowEnableDebuggingSignalInfo = WindowEnableDebuggingCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_WindowEnableDebuggingCallback cb
            cb'' <- mk_WindowEnableDebuggingCallback cb'
            connectSignalFunPtr obj "enable-debugging" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window::enable-debugging"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:signal:enableDebugging"})

    #endif

    -- signal Window::keys-changed
    {-# DEPRECATED WindowKeysChangedCallback ["(Since version 4.10)","Use t'GI.Gtk.Objects.Shortcut.Shortcut' and t'GI.Gtk.Objects.EventController.EventController'","  to implement keyboard shortcuts"] #-}
    -- | Emitted when the set of accelerators or mnemonics that
    -- are associated with the window changes.
    type WindowKeysChangedCallback =
        IO ()

    type C_WindowKeysChangedCallback =
        Ptr Window ->                           -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_WindowKeysChangedCallback ::
        GObject a => (a -> WindowKeysChangedCallback) ->
        C_WindowKeysChangedCallback
    wrap_WindowKeysChangedCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_WindowActivateDefaultCallback
    wrap_WindowKeysChangedCallback a -> IO ()
    gi'cb Ptr Window
    gi'selfPtr Ptr ()
    _ = do
        Ptr Window -> (Window -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Window
    gi'selfPtr ((Window -> IO ()) -> IO ()) -> (Window -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Window
    gi'self -> a -> IO ()
    gi'cb (Window -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Window
    gi'self)

    -- | Connect a signal handler for the [keysChanged](#signal:keysChanged) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' window #keysChanged callback
    -- @
    --
    --
    onWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId
    onWindowKeysChanged :: forall a (m :: * -> *).
    (IsWindow a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onWindowKeysChanged a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_WindowActivateDefaultCallback
    wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_WindowActivateDefaultCallback
    wrap_WindowKeysChangedCallback a -> IO ()
    wrapped
        wrapped'' <- C_WindowActivateDefaultCallback
    -> IO (FunPtr C_WindowActivateDefaultCallback)
    mk_WindowKeysChangedCallback C_WindowActivateDefaultCallback
    wrapped'
        connectSignalFunPtr obj "keys-changed" wrapped'' SignalConnectBefore Nothing

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

    #if defined(ENABLE_OVERLOADING)
    data WindowKeysChangedSignalInfo
    instance SignalInfo WindowKeysChangedSignalInfo where
        type HaskellCallbackType WindowKeysChangedSignalInfo = WindowKeysChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_WindowKeysChangedCallback cb
            cb'' <- mk_WindowKeysChangedCallback cb'
            connectSignalFunPtr obj "keys-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window::keys-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:signal:keysChanged"})

    #endif

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data WindowApplicationPropertyInfo
    instance AttrInfo WindowApplicationPropertyInfo where
        type AttrAllowedOps WindowApplicationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint WindowApplicationPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowApplicationPropertyInfo = Gtk.Application.IsApplication
        type AttrTransferTypeConstraint WindowApplicationPropertyInfo = Gtk.Application.IsApplication
        type AttrTransferType WindowApplicationPropertyInfo = Gtk.Application.Application
        type AttrGetType WindowApplicationPropertyInfo = (Maybe Gtk.Application.Application)
        type AttrLabel WindowApplicationPropertyInfo = "application"
        type AttrOrigin WindowApplicationPropertyInfo = Window
        attrGet = getWindowApplication
        attrSet = setWindowApplication
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Application.Application v
        attrConstruct = constructWindowApplication
        attrClear = clearWindowApplication
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.application"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:application"
            })
    #endif

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data WindowChildPropertyInfo
    instance AttrInfo WindowChildPropertyInfo where
        type AttrAllowedOps WindowChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint WindowChildPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowChildPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint WindowChildPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType WindowChildPropertyInfo = Gtk.Widget.Widget
        type AttrGetType WindowChildPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel WindowChildPropertyInfo = "child"
        type AttrOrigin WindowChildPropertyInfo = Window
        attrGet = getWindowChild
        attrSet = setWindowChild
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructWindowChild
        attrClear = clearWindowChild
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.child"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:child"
            })
    #endif

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

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

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

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

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

    -- VVV Prop "default-height"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data WindowDefaultHeightPropertyInfo
    instance AttrInfo WindowDefaultHeightPropertyInfo where
        type AttrAllowedOps WindowDefaultHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint WindowDefaultHeightPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowDefaultHeightPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint WindowDefaultHeightPropertyInfo = (~) Int32
        type AttrTransferType WindowDefaultHeightPropertyInfo = Int32
        type AttrGetType WindowDefaultHeightPropertyInfo = Int32
        type AttrLabel WindowDefaultHeightPropertyInfo = "default-height"
        type AttrOrigin WindowDefaultHeightPropertyInfo = Window
        attrGet = getWindowDefaultHeight
        attrSet = setWindowDefaultHeight
        attrPut = setWindowDefaultHeight
        attrTransfer _ v = do
            return v
        attrConstruct = constructWindowDefaultHeight
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.defaultHeight"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:defaultHeight"
            })
    #endif

    -- VVV Prop "default-widget"
       -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just True,Just True)

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

    -- | Set the value of the “@default-widget@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' window [ #defaultWidget 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWindowDefaultWidget :: (MonadIO m, IsWindow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
    setWindowDefaultWidget :: forall (m :: * -> *) o a.
    (MonadIO m, IsWindow o, IsWidget a) =>
    o -> a -> m ()
    setWindowDefaultWidget o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "default-widget" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@default-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructWindowDefaultWidget :: (IsWindow o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
    constructWindowDefaultWidget :: forall o (m :: * -> *) a.
    (IsWindow o, MonadIO m, IsWidget a) =>
    a -> m (GValueConstruct o)
    constructWindowDefaultWidget a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "default-widget" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    -- | Set the value of the “@default-widget@” 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' #defaultWidget
    -- @
    clearWindowDefaultWidget :: (MonadIO m, IsWindow o) => o -> m ()
    clearWindowDefaultWidget :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
    clearWindowDefaultWidget o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Widget -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "default-widget" (Maybe Widget
    forall a. Maybe a
    Nothing :: Maybe Gtk.Widget.Widget)

    #if defined(ENABLE_OVERLOADING)
    data WindowDefaultWidgetPropertyInfo
    instance AttrInfo WindowDefaultWidgetPropertyInfo where
        type AttrAllowedOps WindowDefaultWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint WindowDefaultWidgetPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowDefaultWidgetPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint WindowDefaultWidgetPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType WindowDefaultWidgetPropertyInfo = Gtk.Widget.Widget
        type AttrGetType WindowDefaultWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel WindowDefaultWidgetPropertyInfo = "default-widget"
        type AttrOrigin WindowDefaultWidgetPropertyInfo = Window
        attrGet = getWindowDefaultWidget
        attrSet = setWindowDefaultWidget
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructWindowDefaultWidget
        attrClear = clearWindowDefaultWidget
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.defaultWidget"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:defaultWidget"
            })
    #endif

    -- VVV Prop "default-width"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data WindowDefaultWidthPropertyInfo
    instance AttrInfo WindowDefaultWidthPropertyInfo where
        type AttrAllowedOps WindowDefaultWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint WindowDefaultWidthPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowDefaultWidthPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint WindowDefaultWidthPropertyInfo = (~) Int32
        type AttrTransferType WindowDefaultWidthPropertyInfo = Int32
        type AttrGetType WindowDefaultWidthPropertyInfo = Int32
        type AttrLabel WindowDefaultWidthPropertyInfo = "default-width"
        type AttrOrigin WindowDefaultWidthPropertyInfo = Window
        attrGet = getWindowDefaultWidth
        attrSet = setWindowDefaultWidth
        attrPut = setWindowDefaultWidth
        attrTransfer _ v = do
            return v
        attrConstruct = constructWindowDefaultWidth
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.defaultWidth"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:defaultWidth"
            })
    #endif

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

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

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

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

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

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

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

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

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

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

    -- VVV Prop "display"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Display"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Just False)

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data WindowDisplayPropertyInfo
    instance AttrInfo WindowDisplayPropertyInfo where
        type AttrAllowedOps WindowDisplayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint WindowDisplayPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferTypeConstraint WindowDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferType WindowDisplayPropertyInfo = Gdk.Display.Display
        type AttrGetType WindowDisplayPropertyInfo = (Maybe Gdk.Display.Display)
        type AttrLabel WindowDisplayPropertyInfo = "display"
        type AttrOrigin WindowDisplayPropertyInfo = Window
        attrGet = getWindowDisplay
        attrSet = setWindowDisplay
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gdk.Display.Display v
        attrConstruct = constructWindowDisplay
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.display"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:display"
            })
    #endif

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

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

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

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

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

    -- VVV Prop "focus-widget"
       -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just True,Just True)

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

    -- | Set the value of the “@focus-widget@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' window [ #focusWidget 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setWindowFocusWidget :: (MonadIO m, IsWindow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
    setWindowFocusWidget :: forall (m :: * -> *) o a.
    (MonadIO m, IsWindow o, IsWidget a) =>
    o -> a -> m ()
    setWindowFocusWidget o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "focus-widget" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@focus-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructWindowFocusWidget :: (IsWindow o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
    constructWindowFocusWidget :: forall o (m :: * -> *) a.
    (IsWindow o, MonadIO m, IsWidget a) =>
    a -> m (GValueConstruct o)
    constructWindowFocusWidget a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "focus-widget" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    -- | Set the value of the “@focus-widget@” 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' #focusWidget
    -- @
    clearWindowFocusWidget :: (MonadIO m, IsWindow o) => o -> m ()
    clearWindowFocusWidget :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
    clearWindowFocusWidget o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Widget -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "focus-widget" (Maybe Widget
    forall a. Maybe a
    Nothing :: Maybe Gtk.Widget.Widget)

    #if defined(ENABLE_OVERLOADING)
    data WindowFocusWidgetPropertyInfo
    instance AttrInfo WindowFocusWidgetPropertyInfo where
        type AttrAllowedOps WindowFocusWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint WindowFocusWidgetPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowFocusWidgetPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint WindowFocusWidgetPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType WindowFocusWidgetPropertyInfo = Gtk.Widget.Widget
        type AttrGetType WindowFocusWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel WindowFocusWidgetPropertyInfo = "focus-widget"
        type AttrOrigin WindowFocusWidgetPropertyInfo = Window
        attrGet = getWindowFocusWidget
        attrSet = setWindowFocusWidget
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructWindowFocusWidget
        attrClear = clearWindowFocusWidget
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.focusWidget"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:focusWidget"
            })
    #endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- | Get the value of the “@icon-name@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' window #iconName
    -- @
    getWindowIconName :: (MonadIO m, IsWindow o) => o -> m (Maybe T.Text)
    getWindowIconName :: forall (m :: * -> *) o.
    (MonadIO m, IsWindow o) =>
    o -> m (Maybe Text)
    getWindowIconName 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
    "icon-name"

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

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

    -- | Set the value of the “@icon-name@” 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' #iconName
    -- @
    clearWindowIconName :: (MonadIO m, IsWindow o) => o -> m ()
    clearWindowIconName :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
    clearWindowIconName 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
    "icon-name" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- VVV Prop "startup-id"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyWritable]
       -- Nullable: (Nothing,Just False)

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

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

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

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

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

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

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

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

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

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

    -- | Set the value of the “@title@” 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' #title
    -- @
    clearWindowTitle :: (MonadIO m, IsWindow o) => o -> m ()
    clearWindowTitle :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
    clearWindowTitle 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
    "title" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

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

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

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

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

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

    -- | Set the value of the “@titlebar@” 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' #titlebar
    -- @
    clearWindowTitlebar :: (MonadIO m, IsWindow o) => o -> m ()
    clearWindowTitlebar :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
    clearWindowTitlebar o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe Widget -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "titlebar" (Maybe Widget
    forall a. Maybe a
    Nothing :: Maybe Gtk.Widget.Widget)

    #if defined(ENABLE_OVERLOADING)
    data WindowTitlebarPropertyInfo
    instance AttrInfo WindowTitlebarPropertyInfo where
        type AttrAllowedOps WindowTitlebarPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint WindowTitlebarPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowTitlebarPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint WindowTitlebarPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType WindowTitlebarPropertyInfo = Gtk.Widget.Widget
        type AttrGetType WindowTitlebarPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel WindowTitlebarPropertyInfo = "titlebar"
        type AttrOrigin WindowTitlebarPropertyInfo = Window
        attrGet = getWindowTitlebar
        attrSet = setWindowTitlebar
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructWindowTitlebar
        attrClear = clearWindowTitlebar
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.titlebar"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:titlebar"
            })
    #endif

    -- VVV Prop "transient-for"
       -- Type: TInterface (Name {namespace = "Gtk", name = "Window"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
       -- Nullable: (Just True,Just True)

    -- | Get the value of the “@transient-for@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' window #transientFor
    -- @
    getWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m (Maybe Window)
    getWindowTransientFor :: forall (m :: * -> *) o.
    (MonadIO m, IsWindow o) =>
    o -> m (Maybe Window)
    getWindowTransientFor o
    obj = IO (Maybe Window) -> m (Maybe Window)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Window) -> m (Maybe Window))
    -> IO (Maybe Window) -> m (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Window -> Window) -> IO (Maybe Window)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "transient-for" ManagedPtr Window -> Window
    Window

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data WindowTransientForPropertyInfo
    instance AttrInfo WindowTransientForPropertyInfo where
        type AttrAllowedOps WindowTransientForPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint WindowTransientForPropertyInfo = IsWindow
        type AttrSetTypeConstraint WindowTransientForPropertyInfo = IsWindow
        type AttrTransferTypeConstraint WindowTransientForPropertyInfo = IsWindow
        type AttrTransferType WindowTransientForPropertyInfo = Window
        type AttrGetType WindowTransientForPropertyInfo = (Maybe Window)
        type AttrLabel WindowTransientForPropertyInfo = "transient-for"
        type AttrOrigin WindowTransientForPropertyInfo = Window
        attrGet = getWindowTransientFor
        attrSet = setWindowTransientFor
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Window v
        attrConstruct = constructWindowTransientFor
        attrClear = clearWindowTransientFor
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Window.transientFor"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Window.html#g:attr:transientFor"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Window
    type instance O.AttributeList Window = WindowAttributeList
    type WindowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("application", WindowApplicationPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", WindowChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("defaultHeight", WindowDefaultHeightPropertyInfo), '("defaultWidget", WindowDefaultWidgetPropertyInfo), '("defaultWidth", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroyWithParent", WindowDestroyWithParentPropertyInfo), '("display", WindowDisplayPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusVisible", WindowFocusVisiblePropertyInfo), '("focusWidget", WindowFocusWidgetPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("fullscreened", WindowFullscreenedPropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("handleMenubarAccel", WindowHandleMenubarAccelPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hideOnClose", WindowHideOnClosePropertyInfo), '("iconName", WindowIconNamePropertyInfo), '("isActive", WindowIsActivePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maximized", WindowMaximizedPropertyInfo), '("mnemonicsVisible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startupId", WindowStartupIdPropertyInfo), '("suspended", WindowSuspendedPropertyInfo), '("title", WindowTitlePropertyInfo), '("titlebar", WindowTitlebarPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transientFor", WindowTransientForPropertyInfo), '("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)
    windowApplication :: AttrLabelProxy "application"
    windowApplication = AttrLabelProxy

    windowChild :: AttrLabelProxy "child"
    windowChild = AttrLabelProxy

    windowDecorated :: AttrLabelProxy "decorated"
    windowDecorated = AttrLabelProxy

    windowDefaultHeight :: AttrLabelProxy "defaultHeight"
    windowDefaultHeight = AttrLabelProxy

    windowDefaultWidget :: AttrLabelProxy "defaultWidget"
    windowDefaultWidget = AttrLabelProxy

    windowDefaultWidth :: AttrLabelProxy "defaultWidth"
    windowDefaultWidth = AttrLabelProxy

    windowDeletable :: AttrLabelProxy "deletable"
    windowDeletable = AttrLabelProxy

    windowDestroyWithParent :: AttrLabelProxy "destroyWithParent"
    windowDestroyWithParent = AttrLabelProxy

    windowDisplay :: AttrLabelProxy "display"
    windowDisplay = AttrLabelProxy

    windowFocusVisible :: AttrLabelProxy "focusVisible"
    windowFocusVisible = AttrLabelProxy

    windowFocusWidget :: AttrLabelProxy "focusWidget"
    windowFocusWidget = AttrLabelProxy

    windowFullscreened :: AttrLabelProxy "fullscreened"
    windowFullscreened = AttrLabelProxy

    windowGravity :: AttrLabelProxy "gravity"
    windowGravity = AttrLabelProxy

    windowHandleMenubarAccel :: AttrLabelProxy "handleMenubarAccel"
    windowHandleMenubarAccel = AttrLabelProxy

    windowHideOnClose :: AttrLabelProxy "hideOnClose"
    windowHideOnClose = AttrLabelProxy

    windowIconName :: AttrLabelProxy "iconName"
    windowIconName = AttrLabelProxy

    windowMaximized :: AttrLabelProxy "maximized"
    windowMaximized = AttrLabelProxy

    windowMnemonicsVisible :: AttrLabelProxy "mnemonicsVisible"
    windowMnemonicsVisible = AttrLabelProxy

    windowModal :: AttrLabelProxy "modal"
    windowModal = AttrLabelProxy

    windowResizable :: AttrLabelProxy "resizable"
    windowResizable = AttrLabelProxy

    windowStartupId :: AttrLabelProxy "startupId"
    windowStartupId = AttrLabelProxy

    windowSuspended :: AttrLabelProxy "suspended"
    windowSuspended = AttrLabelProxy

    windowTitle :: AttrLabelProxy "title"
    windowTitle = AttrLabelProxy

    windowTitlebar :: AttrLabelProxy "titlebar"
    windowTitlebar = AttrLabelProxy

    windowTransientFor :: AttrLabelProxy "transientFor"
    windowTransientFor = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Window = WindowSignalList
    type WindowSignalList = ('[ '("activateDefault", WindowActivateDefaultSignalInfo), '("activateFocus", WindowActivateFocusSignalInfo), '("closeRequest", WindowCloseRequestSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("enableDebugging", WindowEnableDebuggingSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("keysChanged", WindowKeysChangedSignalInfo), '("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 Window::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Window" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_new" gtk_window_new ::
        IO (Ptr Window)

    -- | Creates a new @GtkWindow@.
    --
    -- To get an undecorated window (without window borders),
    -- use 'GI.Gtk.Objects.Window.windowSetDecorated'.
    --
    -- All top-level windows created by this function are stored
    -- in an internal top-level window list. This list can be obtained
    -- from 'GI.Gtk.Objects.Window.windowListToplevels'. Due to GTK keeping a
    -- reference to the window internally, this function does not
    -- return a reference to the caller.
    --
    -- To delete a @GtkWindow@, call 'GI.Gtk.Objects.Window.windowDestroy'.
    windowNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Window
        -- ^ __Returns:__ a new @GtkWindow@
    windowNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Window
    windowNew  = IO Window -> m Window
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Window -> m Window) -> IO Window -> m Window
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Window)
    gtk_window_new
        checkUnexpectedReturnNULL "windowNew" result
        result' <- (newObject Window) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Window::close
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_close" gtk_window_close ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Requests that the window is closed.
    --
    -- This is similar to what happens when a window manager
    -- close button is clicked.
    --
    -- This function can be used with close buttons in custom
    -- titlebars.
    windowClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowClose :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowClose a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_close window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowCloseMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowCloseMethodInfo a signature where
        overloadedMethod = windowClose

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

    #endif

    -- method Window::destroy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the window to destroy"
    --                 , 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_destroy" gtk_window_destroy ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Drops the internal reference GTK holds on toplevel windows.
    windowDestroy ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: the window to destroy
        -> m ()
    windowDestroy :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowDestroy a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_destroy window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowDestroyMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowDestroyMethodInfo a signature where
        overloadedMethod = windowDestroy

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

    #endif

    -- method Window::fullscreen
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_fullscreen" gtk_window_fullscreen ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Asks to place the window in the fullscreen state.
    --
    -- Note that you shouldn’t assume the window is definitely fullscreen
    -- afterward, because other entities (e.g. the user or window manager)
    -- unfullscreen it again, and not all window managers honor requests
    -- to fullscreen windows.
    --
    -- If a window is not explicitly fullscreened or unfullscreened before
    -- it is shown, the initial state is at the window managers discretion.
    --
    -- You can track the result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property, or by listening to
    -- notifications of the [Window:fullscreened]("GI.Gtk.Objects.Window#g:attr:fullscreened") property.
    windowFullscreen ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowFullscreen :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowFullscreen a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_fullscreen window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowFullscreenMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowFullscreenMethodInfo a signature where
        overloadedMethod = windowFullscreen

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

    #endif

    -- method Window::fullscreen_on_monitor
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "monitor"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Monitor" }
    --           , argCType = Just "GdkMonitor*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "which monitor to go fullscreen on"
    --                 , 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_fullscreen_on_monitor" gtk_window_fullscreen_on_monitor ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gdk.Monitor.Monitor ->              -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO ()

    -- | Asks to place the window in the fullscreen state on the given monitor.
    --
    -- Note that you shouldn\'t assume the window is definitely fullscreen
    -- afterward, or that the windowing system allows fullscreen windows on
    -- any given monitor.
    --
    -- You can track the result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property, or by listening to
    -- notifications of the [Window:fullscreened]("GI.Gtk.Objects.Window#g:attr:fullscreened") property.
    windowFullscreenOnMonitor ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gdk.Monitor.IsMonitor b) =>
        a
        -- ^ /@window@/: a window
        -> b
        -- ^ /@monitor@/: which monitor to go fullscreen on
        -> m ()
    windowFullscreenOnMonitor :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsMonitor b) =>
    a -> b -> m ()
    windowFullscreenOnMonitor a
    window b
    monitor = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        monitor' <- unsafeManagedPtrCastPtr monitor
        gtk_window_fullscreen_on_monitor window' monitor'
        touchManagedPtr window
        touchManagedPtr monitor
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowFullscreenOnMonitorMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsWindow a, Gdk.Monitor.IsMonitor b) => O.OverloadedMethod WindowFullscreenOnMonitorMethodInfo a signature where
        overloadedMethod = windowFullscreenOnMonitor

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

    #endif

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

    foreign import ccall "gtk_window_get_application" gtk_window_get_application ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Gtk.Application.Application)

    -- | Gets the application object associated with the window.
    windowGetApplication ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe Gtk.Application.Application)
        -- ^ __Returns:__ the application
    windowGetApplication :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Application)
    windowGetApplication a
    window = IO (Maybe Application) -> m (Maybe Application)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Application) -> m (Maybe Application))
    -> IO (Maybe Application) -> m (Maybe Application)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_application window'
        maybeResult <- convertIfNonNull result $ \Ptr Application
    result' -> do
            result'' <- ((ManagedPtr Application -> Application)
    -> Ptr Application -> IO Application
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Application -> Application
    Gtk.Application.Application) Ptr Application
    result'
            return result''
        touchManagedPtr window
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data WindowGetApplicationMethodInfo
    instance (signature ~ (m (Maybe Gtk.Application.Application)), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetApplicationMethodInfo a signature where
        overloadedMethod = windowGetApplication

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

    #endif

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

    foreign import ccall "gtk_window_get_child" gtk_window_get_child ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Gets the child widget of the window.
    windowGetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ the child widget of /@window@/
    windowGetChild :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Widget)
    windowGetChild a
    window = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_child window'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr window
        return maybeResult

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

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

    #endif

    -- method Window::get_decorated
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_decorated" gtk_window_get_decorated ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window has been set to have decorations.
    windowGetDecorated ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window has been set to have decorations
    windowGetDecorated :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetDecorated a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_decorated window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetDecoratedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDecoratedMethodInfo a signature where
        overloadedMethod = windowGetDecorated

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

    #endif

    -- method Window::get_default_size
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store the default width"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store the default height"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_get_default_size" gtk_window_get_default_size ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Int32 ->                            -- width : TBasicType TInt
        Ptr Int32 ->                            -- height : TBasicType TInt
        IO ()

    -- | Gets the default size of the window.
    --
    -- A value of 0 for the width or height indicates that a default
    -- size has not been explicitly set for that dimension, so the
    -- “natural” size of the window will be used.
    --
    -- This function is the recommended way for <https://developer.gnome.org/documentation/tutorials/save-state.html saving window state
    -- across restarts of applications>.
    windowGetDefaultSize ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ((Int32, Int32))
    windowGetDefaultSize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Int32, Int32)
    windowGetDefaultSize a
    window = IO (Int32, Int32) -> m (Int32, Int32)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int32, Int32) -> m (Int32, Int32))
    -> IO (Int32, Int32) -> m (Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        width <- allocMem :: IO (Ptr Int32)
        height <- allocMem :: IO (Ptr Int32)
        gtk_window_get_default_size window' width height
        width' <- peek width
        height' <- peek height
        touchManagedPtr window
        freeMem width
        freeMem height
        return (width', height')

    #if defined(ENABLE_OVERLOADING)
    data WindowGetDefaultSizeMethodInfo
    instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDefaultSizeMethodInfo a signature where
        overloadedMethod = windowGetDefaultSize

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

    #endif

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

    foreign import ccall "gtk_window_get_default_widget" gtk_window_get_default_widget ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Returns the default widget for /@window@/.
    windowGetDefaultWidget ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ the default widget
    windowGetDefaultWidget :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Widget)
    windowGetDefaultWidget a
    window = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_default_widget window'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr window
        return maybeResult

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

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

    #endif

    -- method Window::get_deletable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_deletable" gtk_window_get_deletable ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window has been set to have a close button.
    windowGetDeletable ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window has been set to have a close button
    windowGetDeletable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetDeletable a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_deletable window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetDeletableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDeletableMethodInfo a signature where
        overloadedMethod = windowGetDeletable

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

    #endif

    -- method Window::get_destroy_with_parent
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_destroy_with_parent" gtk_window_get_destroy_with_parent ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window will be destroyed with its transient parent.
    windowGetDestroyWithParent ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window will be destroyed with its transient parent
    windowGetDestroyWithParent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetDestroyWithParent a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_destroy_with_parent window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetDestroyWithParentMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDestroyWithParentMethodInfo a signature where
        overloadedMethod = windowGetDestroyWithParent

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

    #endif

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

    foreign import ccall "gtk_window_get_focus" gtk_window_get_focus ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Retrieves the current focused widget within the window.
    --
    -- Note that this is the widget that would have the focus
    -- if the toplevel window focused; if the toplevel window
    -- is not focused then @gtk_widget_has_focus (widget)@ will
    -- not be false for the widget.
    windowGetFocus ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ the currently focused widget
    windowGetFocus :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Widget)
    windowGetFocus a
    window = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_focus window'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr window
        return maybeResult

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

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

    #endif

    -- method Window::get_focus_visible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_focus_visible" gtk_window_get_focus_visible ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Gets whether “focus rectangles” are supposed to be visible.
    windowGetFocusVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if “focus rectangles” are supposed to be visible
        --   in this window
    windowGetFocusVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetFocusVisible a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_focus_visible window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetFocusVisibleMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetFocusVisibleMethodInfo a signature where
        overloadedMethod = windowGetFocusVisible

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

    #endif

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

    foreign import ccall "gtk_window_get_gravity" gtk_window_get_gravity ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CUInt

    -- | Returns the gravity that is used when changing the window size programmatically.
    --
    -- /Since: 4.20/
    windowGetGravity ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Gtk.Enums.WindowGravity
        -- ^ __Returns:__ the gravity
    windowGetGravity :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m WindowGravity
    windowGetGravity a
    window = IO WindowGravity -> m WindowGravity
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO WindowGravity -> m WindowGravity)
    -> IO WindowGravity -> m WindowGravity
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_gravity window'
        let result' = (Int -> WindowGravity
    forall a. Enum a => Int -> a
    toEnum (Int -> WindowGravity) -> (CUInt -> Int) -> CUInt -> WindowGravity
    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 window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetGravityMethodInfo
    instance (signature ~ (m Gtk.Enums.WindowGravity), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetGravityMethodInfo a signature where
        overloadedMethod = windowGetGravity

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

    #endif

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

    foreign import ccall "gtk_window_get_group" gtk_window_get_group ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Gtk.WindowGroup.WindowGroup)

    -- | Returns the group for the window.
    --
    -- If the window has no group, then the default group is returned.
    windowGetGroup ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        Maybe (a)
        -- ^ /@window@/: a window
        -> m Gtk.WindowGroup.WindowGroup
        -- ^ __Returns:__ the window group for /@window@/
        --   or the default group
    windowGetGroup :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    Maybe a -> m WindowGroup
    windowGetGroup Maybe a
    window = IO WindowGroup -> m WindowGroup
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO WindowGroup -> m WindowGroup)
    -> IO WindowGroup -> m WindowGroup
    forall a b. (a -> b) -> a -> b
    $ do
        maybeWindow <- case Maybe a
    window of
            Maybe a
    Nothing -> Ptr Window -> IO (Ptr Window)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Window
    forall a. Ptr a
    FP.nullPtr
            Just a
    jWindow -> do
                jWindow' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jWindow
                return jWindow'
        result <- gtk_window_get_group maybeWindow
        checkUnexpectedReturnNULL "windowGetGroup" result
        result' <- (newObject Gtk.WindowGroup.WindowGroup) result
        whenJust window touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetGroupMethodInfo
    instance (signature ~ (m Gtk.WindowGroup.WindowGroup), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetGroupMethodInfo a signature where
        overloadedMethod i = windowGetGroup (Just i)

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

    #endif

    -- method Window::get_handle_menubar_accel
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_handle_menubar_accel" gtk_window_get_handle_menubar_accel ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether this window reacts to \<kbd>F10\<\/kbd>
    -- presses by activating a menubar it contains.
    --
    -- /Since: 4.2/
    windowGetHandleMenubarAccel ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window handles \<kbd>F10\<\/kbd>
    windowGetHandleMenubarAccel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetHandleMenubarAccel a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_handle_menubar_accel window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetHandleMenubarAccelMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetHandleMenubarAccelMethodInfo a signature where
        overloadedMethod = windowGetHandleMenubarAccel

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

    #endif

    -- method Window::get_hide_on_close
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_hide_on_close" gtk_window_get_hide_on_close ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window will be hidden instead of destroyed when the close
    -- button is clicked.
    windowGetHideOnClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window will be hidden
    windowGetHideOnClose :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetHideOnClose a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_hide_on_close window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetHideOnCloseMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetHideOnCloseMethodInfo a signature where
        overloadedMethod = windowGetHideOnClose

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

    #endif

    -- method Window::get_icon_name
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_icon_name" gtk_window_get_icon_name ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CString

    -- | Returns the name of the themed icon for the window.
    windowGetIconName ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe T.Text)
        -- ^ __Returns:__ the icon name
    windowGetIconName :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Text)
    windowGetIconName a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_icon_name window'
        maybeResult <- convertIfNonNull result $ \CString
    result' -> do
            result'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result'
            return result''
        touchManagedPtr window
        return maybeResult

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

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

    #endif

    -- method Window::get_mnemonics_visible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_mnemonics_visible" gtk_window_get_mnemonics_visible ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Gets whether mnemonics are supposed to be visible.
    windowGetMnemonicsVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if mnemonics are supposed to be visible
        --   in this window
    windowGetMnemonicsVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetMnemonicsVisible a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_mnemonics_visible window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetMnemonicsVisibleMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetMnemonicsVisibleMethodInfo a signature where
        overloadedMethod = windowGetMnemonicsVisible

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

    #endif

    -- method Window::get_modal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_modal" gtk_window_get_modal ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window is modal.
    windowGetModal ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window is set to be modal and
        --   establishes a grab when shown
    windowGetModal :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetModal a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_modal window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetModalMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetModalMethodInfo a signature where
        overloadedMethod = windowGetModal

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

    #endif

    -- method Window::get_resizable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_resizable" gtk_window_get_resizable ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Gets whether the user can resize the window.
    windowGetResizable ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the user can resize the window
    windowGetResizable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowGetResizable a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_resizable window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowGetResizableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetResizableMethodInfo a signature where
        overloadedMethod = windowGetResizable

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

    #endif

    -- method Window::get_title
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_get_title" gtk_window_get_title ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CString

    -- | Retrieves the title of the window.
    windowGetTitle ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe T.Text)
        -- ^ __Returns:__ the title
    windowGetTitle :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Text)
    windowGetTitle a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_title window'
        maybeResult <- convertIfNonNull result $ \CString
    result' -> do
            result'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result'
            return result''
        touchManagedPtr window
        return maybeResult

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

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

    #endif

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

    foreign import ccall "gtk_window_get_titlebar" gtk_window_get_titlebar ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Returns the titlebar that has been set with
    -- 'GI.Gtk.Objects.Window.windowSetTitlebar'.
    windowGetTitlebar ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ the titlebar
    windowGetTitlebar :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Widget)
    windowGetTitlebar a
    window = IO (Maybe Widget) -> m (Maybe Widget)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Widget) -> m (Maybe Widget))
    -> IO (Maybe Widget) -> m (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_titlebar window'
        maybeResult <- convertIfNonNull result $ \Ptr Widget
    result' -> do
            result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Widget -> Widget
    Gtk.Widget.Widget) Ptr Widget
    result'
            return result''
        touchManagedPtr window
        return maybeResult

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

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

    #endif

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

    foreign import ccall "gtk_window_get_transient_for" gtk_window_get_transient_for ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO (Ptr Window)

    -- | Fetches the transient parent for this window.
    windowGetTransientFor ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m (Maybe Window)
        -- ^ __Returns:__ the transient parent
    windowGetTransientFor :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m (Maybe Window)
    windowGetTransientFor a
    window = IO (Maybe Window) -> m (Maybe Window)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Window) -> m (Maybe Window))
    -> IO (Maybe Window) -> m (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_get_transient_for window'
        maybeResult <- convertIfNonNull result $ \Ptr Window
    result' -> do
            result'' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Window -> Window
    Window) Ptr Window
    result'
            return result''
        touchManagedPtr window
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data WindowGetTransientForMethodInfo
    instance (signature ~ (m (Maybe Window)), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetTransientForMethodInfo a signature where
        overloadedMethod = windowGetTransientFor

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

    #endif

    -- method Window::has_group
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_has_group" gtk_window_has_group ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window has an explicit window group.
    windowHasGroup ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if /@window@/ has an explicit window group
    windowHasGroup :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowHasGroup a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_has_group window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowHasGroupMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowHasGroupMethodInfo a signature where
        overloadedMethod = windowHasGroup

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

    #endif

    -- method Window::is_active
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_is_active" gtk_window_is_active ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Returns whether the window is part of the current active toplevel.
    --
    -- The active toplevel is the window receiving keystrokes.
    --
    -- The return value is 'P.True' if the window is active toplevel itself.
    -- You might use this function if you wanted to draw a widget
    -- differently in an active window from a widget in an inactive window.
    windowIsActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ true if the window part of the current active window.
    windowIsActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowIsActive a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_is_active window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowIsActiveMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsActiveMethodInfo a signature where
        overloadedMethod = windowIsActive

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

    #endif

    -- method Window::is_fullscreen
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_is_fullscreen" gtk_window_is_fullscreen ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Retrieves the current fullscreen state of the window.
    --
    -- Note that since fullscreening is ultimately handled by the window
    -- manager and happens asynchronously to an application request, you
    -- shouldn’t assume the return value of this function changing
    -- immediately (or at all), as an effect of calling
    -- 'GI.Gtk.Objects.Window.windowFullscreen' or 'GI.Gtk.Objects.Window.windowUnfullscreen'.
    --
    -- If the window isn\'t yet mapped, the value returned will whether the
    -- initial requested state is fullscreen.
    windowIsFullscreen ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ whether the window is fullscreen
    windowIsFullscreen :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowIsFullscreen a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_is_fullscreen window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowIsFullscreenMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsFullscreenMethodInfo a signature where
        overloadedMethod = windowIsFullscreen

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

    #endif

    -- method Window::is_maximized
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_is_maximized" gtk_window_is_maximized ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Retrieves the current maximized state of the window.
    --
    -- Note that since maximization is ultimately handled by the window
    -- manager and happens asynchronously to an application request, you
    -- shouldn’t assume the return value of this function changing
    -- immediately (or at all), as an effect of calling
    -- 'GI.Gtk.Objects.Window.windowMaximize' or 'GI.Gtk.Objects.Window.windowUnmaximize'.
    --
    -- If the window isn\'t yet mapped, the value returned will whether the
    -- initial requested state is maximized.
    windowIsMaximized ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ whether the window is maximized
    windowIsMaximized :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowIsMaximized a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_is_maximized window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowIsMaximizedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsMaximizedMethodInfo a signature where
        overloadedMethod = windowIsMaximized

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

    #endif

    -- method Window::is_suspended
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_is_suspended" gtk_window_is_suspended ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO CInt

    -- | Retrieves the current suspended state of the window.
    --
    -- A window being suspended means it\'s currently not visible
    -- to the user, for example by being on a inactive workspace,
    -- minimized, obstructed.
    --
    -- /Since: 4.12/
    windowIsSuspended ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m Bool
        -- ^ __Returns:__ whether the window is suspended
    windowIsSuspended :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m Bool
    windowIsSuspended a
    window = WindowCloseRequestCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (WindowCloseRequestCallback -> m Bool)
    -> WindowCloseRequestCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        result <- gtk_window_is_suspended window'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr window
        return result'

    #if defined(ENABLE_OVERLOADING)
    data WindowIsSuspendedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsSuspendedMethodInfo a signature where
        overloadedMethod = windowIsSuspended

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

    #endif

    -- method Window::maximize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_maximize" gtk_window_maximize ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Asks to maximize the window, so that it fills the screen.
    --
    -- Note that you shouldn’t assume the window is definitely maximized
    -- afterward, because other entities (e.g. the user or window manager)
    -- could unmaximize it again, and not all window managers support
    -- maximization.
    --
    -- It’s permitted to call this function before showing a window,
    -- in which case the window will be maximized when it appears onscreen
    -- initially.
    --
    -- If a window is not explicitly maximized or unmaximized before it is
    -- shown, the initial state is at the window managers discretion. For
    -- example, it might decide to maximize a window that almost fills the
    -- screen.
    --
    -- You can track the result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property, or by listening to
    -- notifications on the [Window:maximized]("GI.Gtk.Objects.Window#g:attr:maximized")
    -- property.
    windowMaximize ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowMaximize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowMaximize a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_maximize window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowMaximizeMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowMaximizeMethodInfo a signature where
        overloadedMethod = windowMaximize

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

    #endif

    -- method Window::minimize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_minimize" gtk_window_minimize ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Asks to minimize the window.
    --
    -- Note that you shouldn’t assume the window is definitely minimized
    -- afterward, because the windowing system might not support this
    -- functionality; other entities (e.g. the user or the window manager)
    -- could unminimize it again, or there may not be a window manager in
    -- which case minimization isn’t possible, etc.
    --
    -- It’s permitted to call this function before showing a window,
    -- in which case the window will be minimized before it ever appears
    -- onscreen.
    --
    -- You can track result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property.
    windowMinimize ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowMinimize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowMinimize a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_minimize window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowMinimizeMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowMinimizeMethodInfo a signature where
        overloadedMethod = windowMinimize

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

    #endif

    -- method Window::present
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_present" gtk_window_present ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Presents a window to the user.
    --
    -- This may mean raising the window in the stacking order,
    -- unminimizing it, moving it to the current desktop and\/or
    -- giving it the keyboard focus (possibly dependent on the user’s
    -- platform, window manager and preferences).
    --
    -- If /@window@/ is hidden, this function also makes it visible.
    windowPresent ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowPresent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowPresent a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_present window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowPresentMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowPresentMethodInfo a signature where
        overloadedMethod = windowPresent

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

    #endif

    -- method Window::present_with_time
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "timestamp"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "guint32"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the timestamp of the user interaction (typically a\n  button or key press event) which triggered this call"
    --                 , 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_present_with_time" gtk_window_present_with_time ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Word32 ->                               -- timestamp : TBasicType TUInt32
        IO ()

    {-# DEPRECATED windowPresentWithTime ["(Since version 4.14)","Use 'GI.Gtk.Objects.Window.windowPresent'"] #-}
    -- | Presents a window to the user in response to an user interaction.
    --
    -- See 'GI.Gtk.Objects.Window.windowPresent' for more details.
    --
    -- The timestamp should be gathered when the window was requested
    -- to be shown (when clicking a link for example), rather than once
    -- the window is ready to be shown.
    windowPresentWithTime ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Word32
        -- ^ /@timestamp@/: the timestamp of the user interaction (typically a
        --   button or key press event) which triggered this call
        -> m ()
    windowPresentWithTime :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Word32 -> m ()
    windowPresentWithTime a
    window Word32
    timestamp = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_present_with_time window' timestamp
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowPresentWithTimeMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowPresentWithTimeMethodInfo a signature where
        overloadedMethod = windowPresentWithTime

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

    #endif

    -- method Window::set_application
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "application"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Application" }
    --           , argCType = Just "GtkApplication*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkApplication`" , 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_set_application" gtk_window_set_application ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gtk.Application.Application ->      -- application : TInterface (Name {namespace = "Gtk", name = "Application"})
        IO ()

    -- | Sets or unsets the application object associated with the window.
    --
    -- The application will be kept alive for at least as long as it has
    -- any windows associated with it (see 'GI.Gio.Objects.Application.applicationHold'
    -- for a way to keep it alive without windows).
    --
    -- Normally, the connection between the application and the window will
    -- remain until the window is destroyed, but you can explicitly remove
    -- it by setting the /@application@/ to 'P.Nothing'.
    --
    -- This is equivalent to calling 'GI.Gtk.Objects.Application.applicationRemoveWindow'
    -- and\/or 'GI.Gtk.Objects.Application.applicationAddWindow' on the old\/new applications
    -- as relevant.
    windowSetApplication ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Application.IsApplication b) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (b)
        -- ^ /@application@/: a @GtkApplication@
        -> m ()
    windowSetApplication :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsApplication b) =>
    a -> Maybe b -> m ()
    windowSetApplication a
    window Maybe b
    application = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeApplication <- case application of
            Maybe b
    Nothing -> Ptr Application -> IO (Ptr Application)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Application
    forall a. Ptr a
    FP.nullPtr
            Just b
    jApplication -> do
                jApplication' <- b -> IO (Ptr Application)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jApplication
                return jApplication'
        gtk_window_set_application window' maybeApplication
        touchManagedPtr window
        whenJust application touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetApplicationMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWindow a, Gtk.Application.IsApplication b) => O.OverloadedMethod WindowSetApplicationMethodInfo a signature where
        overloadedMethod = windowSetApplication

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

    #endif

    -- method Window::set_child
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "child"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the child widget" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_set_child" gtk_window_set_child ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets the child widget of the window.
    windowSetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (b)
        -- ^ /@child@/: the child widget
        -> m ()
    windowSetChild :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
    a -> Maybe b -> m ()
    windowSetChild a
    window Maybe b
    child = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeChild <- case child of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jChild -> do
                jChild' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jChild
                return jChild'
        gtk_window_set_child window' maybeChild
        touchManagedPtr window
        whenJust child touchManagedPtr
        return ()

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

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

    #endif

    -- method Window::set_decorated
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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 decorate the window"
    --                 , 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_set_decorated" gtk_window_set_decorated ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether the window should be decorated.
    --
    -- By default, windows are decorated with a title bar, resize
    -- controls, etc. Some window managers allow GTK to disable these
    -- decorations, creating a borderless window. If you set the decorated
    -- property to false using this function, GTK will do its best to
    -- convince the window manager not to decorate the window. Depending on
    -- the system, this function may not have any effect when called on a
    -- window that is already visible, so you should call it before calling
    -- 'GI.Gtk.Objects.Widget.widgetShow'.
    --
    -- On Windows, this function always works, since there’s no window manager
    -- policy involved.
    windowSetDecorated ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@setting@/: true to decorate the window
        -> m ()
    windowSetDecorated :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetDecorated a
    window 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        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_set_decorated window' setting'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetDecoratedMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDecoratedMethodInfo a signature where
        overloadedMethod = windowSetDecorated

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

    #endif

    -- method Window::set_default_size
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "width in pixels, or -1 to unset the default width"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "height in pixels, or -1 to unset the default height"
    --                 , 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_set_default_size" gtk_window_set_default_size ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Int32 ->                                -- width : TBasicType TInt
        Int32 ->                                -- height : TBasicType TInt
        IO ()

    -- | Sets the default size of a window.
    --
    -- The default size of a window is the size that will be used
    -- if no other constraints apply.
    --
    -- The default size will be updated whenever the window is resized
    -- to reflect the new size, unless the window is forced to a size,
    -- like when it is maximized or fullscreened.
    --
    -- If the window’s minimum size request is larger than
    -- the default, the default will be ignored.
    --
    -- Setting the default size to a value \<= 0 will cause it to be
    -- ignored and the natural size request will be used instead. It
    -- is possible to do this while the window is showing to \"reset\"
    -- it to its initial size.
    --
    -- Unlike 'GI.Gtk.Objects.Widget.widgetSetSizeRequest', which sets a size
    -- request for a widget and thus would keep users from shrinking
    -- the window, this function only sets the initial size, just as
    -- if the user had resized the window themselves. Users can still
    -- shrink the window again as they normally would. Setting a default
    -- size of -1 means to use the “natural” default size (the size request
    -- of the window).
    --
    -- If you use this function to reestablish a previously saved window size,
    -- note that the appropriate size to save is the one returned by
    -- 'GI.Gtk.Objects.Window.windowGetDefaultSize'. Using the window allocation
    -- directly will not work in all circumstances and can lead to growing
    -- or shrinking windows.
    windowSetDefaultSize ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Int32
        -- ^ /@width@/: width in pixels, or -1 to unset the default width
        -> Int32
        -- ^ /@height@/: height in pixels, or -1 to unset the default height
        -> m ()
    windowSetDefaultSize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Int32 -> Int32 -> m ()
    windowSetDefaultSize a
    window Int32
    width Int32
    height = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_set_default_size window' width height
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetDefaultSizeMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDefaultSizeMethodInfo a signature where
        overloadedMethod = windowSetDefaultSize

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

    #endif

    -- method Window::set_default_widget
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "default_widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "widget to be the default"
    --                 , 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_set_default_widget" gtk_window_set_default_widget ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gtk.Widget.Widget ->                -- default_widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets the default widget.
    --
    -- The default widget is the widget that is activated
    -- when the user presses \<kbd>Enter\<\/kbd> in a dialog
    -- (for example).
    windowSetDefaultWidget ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (b)
        -- ^ /@defaultWidget@/: widget to be the default
        -> m ()
    windowSetDefaultWidget :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
    a -> Maybe b -> m ()
    windowSetDefaultWidget a
    window Maybe b
    defaultWidget = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeDefaultWidget <- case defaultWidget of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jDefaultWidget -> do
                jDefaultWidget' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jDefaultWidget
                return jDefaultWidget'
        gtk_window_set_default_widget window' maybeDefaultWidget
        touchManagedPtr window
        whenJust defaultWidget touchManagedPtr
        return ()

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

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

    #endif

    -- method Window::set_deletable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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 decorate the window as deletable"
    --                 , 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_set_deletable" gtk_window_set_deletable ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether the window should be deletable.
    --
    -- By default, windows have a close button in the window frame.
    -- Some  window managers allow GTK to disable this button. If you
    -- set the deletable property to false using this function, GTK
    -- will do its best to convince the window manager not to show a
    -- close button. Depending on the system, this function may not
    -- have any effect when called on a window that is already visible,
    -- so you should call it before calling 'GI.Gtk.Objects.Widget.widgetShow'.
    --
    -- On Windows, this function always works, since there’s no window
    -- manager policy involved.
    windowSetDeletable ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@setting@/: true to decorate the window as deletable
        -> m ()
    windowSetDeletable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetDeletable a
    window 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        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_set_deletable window' setting'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetDeletableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDeletableMethodInfo a signature where
        overloadedMethod = windowSetDeletable

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

    #endif

    -- method Window::set_destroy_with_parent
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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 "whether to destroy the window with its transient parent"
    --                 , 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_set_destroy_with_parent" gtk_window_set_destroy_with_parent ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether to destroy the window when the transient parent is destroyed.
    --
    -- This is useful for dialogs that shouldn’t persist beyond the lifetime
    -- of the main window they are associated with, for example.
    windowSetDestroyWithParent ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@setting@/: whether to destroy the window with its transient parent
        -> m ()
    windowSetDestroyWithParent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetDestroyWithParent a
    window 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        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_set_destroy_with_parent window' setting'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetDestroyWithParentMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDestroyWithParentMethodInfo a signature where
        overloadedMethod = windowSetDestroyWithParent

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

    #endif

    -- method Window::set_display
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "display"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Display" }
    --           , argCType = Just "GdkDisplay*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a display" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_set_display" gtk_window_set_display ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gdk.Display.Display ->              -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
        IO ()

    -- | Sets the display where the window is displayed.
    --
    -- If the window is already mapped, it will be unmapped,
    -- and then remapped on the new display.
    windowSetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gdk.Display.IsDisplay b) =>
        a
        -- ^ /@window@/: a window
        -> b
        -- ^ /@display@/: a display
        -> m ()
    windowSetDisplay :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsDisplay b) =>
    a -> b -> m ()
    windowSetDisplay a
    window b
    display = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        display' <- unsafeManagedPtrCastPtr display
        gtk_window_set_display window' display'
        touchManagedPtr window
        touchManagedPtr display
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetDisplayMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsWindow a, Gdk.Display.IsDisplay b) => O.OverloadedMethod WindowSetDisplayMethodInfo a signature where
        overloadedMethod = windowSetDisplay

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

    #endif

    -- method Window::set_focus
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "focus"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new focus widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_set_focus" gtk_window_set_focus ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gtk.Widget.Widget ->                -- focus : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets the focus widget.
    --
    -- If /@focus@/ is not the current focus widget, and is focusable,
    -- sets it as the focus widget for the window. If /@focus@/ is 'P.Nothing',
    -- unsets the focus widget for this window. To set the focus to a
    -- particular widget in the toplevel, it is usually more convenient
    -- to use 'GI.Gtk.Objects.Widget.widgetGrabFocus' instead of this function.
    windowSetFocus ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (b)
        -- ^ /@focus@/: the new focus widget
        -> m ()
    windowSetFocus :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
    a -> Maybe b -> m ()
    windowSetFocus a
    window Maybe b
    focus = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeFocus <- case focus of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFocus -> do
                jFocus' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jFocus
                return jFocus'
        gtk_window_set_focus window' maybeFocus
        touchManagedPtr window
        whenJust focus touchManagedPtr
        return ()

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

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

    #endif

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

    -- | Sets whether “focus rectangles” are supposed to be visible.
    --
    -- This property is maintained by GTK based on user input,
    -- and should not be set by applications.
    windowSetFocusVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@setting@/: the new value
        -> m ()
    windowSetFocusVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetFocusVisible a
    window 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        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_set_focus_visible window' setting'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetFocusVisibleMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetFocusVisibleMethodInfo a signature where
        overloadedMethod = windowSetFocusVisible

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

    #endif

    -- method Window::set_gravity
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "gravity"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "WindowGravity" }
    --           , argCType = Just "GtkWindowGravity"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new gravity" , 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_set_gravity" gtk_window_set_gravity ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CUInt ->                                -- gravity : TInterface (Name {namespace = "Gtk", name = "WindowGravity"})
        IO ()

    -- | Sets the gravity that is used when changing the window size programmatically.
    --
    -- /Since: 4.20/
    windowSetGravity ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Gtk.Enums.WindowGravity
        -- ^ /@gravity@/: the new gravity
        -> m ()
    windowSetGravity :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> WindowGravity -> m ()
    windowSetGravity a
    window WindowGravity
    gravity = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        let gravity' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (WindowGravity -> Int) -> WindowGravity -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WindowGravity -> Int
    forall a. Enum a => a -> Int
    fromEnum) WindowGravity
    gravity
        gtk_window_set_gravity window' gravity'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetGravityMethodInfo
    instance (signature ~ (Gtk.Enums.WindowGravity -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetGravityMethodInfo a signature where
        overloadedMethod = windowSetGravity

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

    #endif

    -- method Window::set_handle_menubar_accel
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "handle_menubar_accel"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "true to make @window handle <kbd>F10</kbd>"
    --                 , 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_set_handle_menubar_accel" gtk_window_set_handle_menubar_accel ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- handle_menubar_accel : TBasicType TBoolean
        IO ()

    -- | Sets whether this window should react to \<kbd>F10\<\/kbd>
    -- presses by activating a menubar it contains.
    --
    -- /Since: 4.2/
    windowSetHandleMenubarAccel ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@handleMenubarAccel@/: true to make /@window@/ handle \<kbd>F10\<\/kbd>
        -> m ()
    windowSetHandleMenubarAccel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetHandleMenubarAccel a
    window Bool
    handleMenubarAccel = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        let handleMenubarAccel' = (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
    handleMenubarAccel
        gtk_window_set_handle_menubar_accel window' handleMenubarAccel'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetHandleMenubarAccelMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetHandleMenubarAccelMethodInfo a signature where
        overloadedMethod = windowSetHandleMenubarAccel

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

    #endif

    -- method Window::set_hide_on_close
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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 "whether to hide the window when it is closed"
    --                 , 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_set_hide_on_close" gtk_window_set_hide_on_close ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether clicking the close button will hide the window instead
    -- of destroying it.
    windowSetHideOnClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@setting@/: whether to hide the window when it is closed
        -> m ()
    windowSetHideOnClose :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetHideOnClose a
    window 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        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_set_hide_on_close window' setting'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetHideOnCloseMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetHideOnCloseMethodInfo a signature where
        overloadedMethod = windowSetHideOnClose

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

    #endif

    -- method Window::set_icon_name
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the themed icon"
    --                 , 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_set_icon_name" gtk_window_set_icon_name ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CString ->                              -- name : TBasicType TUTF8
        IO ()

    -- | Sets the icon for the window from a named themed icon.
    --
    -- See the docs for t'GI.Gtk.Objects.IconTheme.IconTheme' for more details.
    -- On some platforms, the window icon is not used at all.
    --
    -- Note that this has nothing to do with the WM_ICON_NAME
    -- property which is mentioned in the ICCCM.
    windowSetIconName ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (T.Text)
        -- ^ /@name@/: the name of the themed icon
        -> m ()
    windowSetIconName :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Maybe Text -> m ()
    windowSetIconName a
    window Maybe Text
    name = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeName <- case name 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
    jName -> do
                jName' <- Text -> IO CString
    textToCString Text
    jName
                return jName'
        gtk_window_set_icon_name window' maybeName
        touchManagedPtr window
        freeMem maybeName
        return ()

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

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

    #endif

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

    -- | Sets whether mnemonics are supposed to be visible.
    --
    -- This property is maintained by GTK based on user input,
    -- and should not be set by applications.
    windowSetMnemonicsVisible ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@setting@/: the new value
        -> m ()
    windowSetMnemonicsVisible :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetMnemonicsVisible a
    window 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        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_set_mnemonics_visible window' setting'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetMnemonicsVisibleMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetMnemonicsVisibleMethodInfo a signature where
        overloadedMethod = windowSetMnemonicsVisible

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

    #endif

    -- method Window::set_modal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "modal"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether the window is modal"
    --                 , 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_set_modal" gtk_window_set_modal ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- modal : TBasicType TBoolean
        IO ()

    -- | Sets a window modal or non-modal.
    --
    -- Modal windows prevent interaction with other windows in the same
    -- application. To keep modal dialogs on top of main application windows,
    -- use 'GI.Gtk.Objects.Window.windowSetTransientFor' to make the dialog transient
    -- for the parent; most window managers will then disallow lowering the
    -- dialog below the parent.
    windowSetModal ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@modal@/: whether the window is modal
        -> m ()
    windowSetModal :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetModal a
    window Bool
    modal = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        let modal' = (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
    modal
        gtk_window_set_modal window' modal'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetModalMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetModalMethodInfo a signature where
        overloadedMethod = windowSetModal

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

    #endif

    -- method Window::set_resizable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "resizable"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "true if the user can resize this window"
    --                 , 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_set_resizable" gtk_window_set_resizable ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CInt ->                                 -- resizable : TBasicType TBoolean
        IO ()

    -- | Sets whether the user can resize a window.
    --
    -- Windows are user resizable by default.
    windowSetResizable ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Bool
        -- ^ /@resizable@/: true if the user can resize this window
        -> m ()
    windowSetResizable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Bool -> m ()
    windowSetResizable a
    window Bool
    resizable = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        let resizable' = (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
    resizable
        gtk_window_set_resizable window' resizable'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetResizableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetResizableMethodInfo a signature where
        overloadedMethod = windowSetResizable

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

    #endif

    -- method Window::set_startup_id
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "startup_id"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a string with startup-notification identifier"
    --                 , 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_set_startup_id" gtk_window_set_startup_id ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CString ->                              -- startup_id : TBasicType TUTF8
        IO ()

    -- | Sets the startup notification ID.
    --
    -- Startup notification identifiers are used by desktop environment
    -- to track application startup, to provide user feedback and other
    -- features. This function changes the corresponding property on the
    -- underlying @GdkSurface@.
    --
    -- Normally, startup identifier is managed automatically and you should
    -- only use this function in special cases like transferring focus from
    -- other processes. You should use this function before calling
    -- 'GI.Gtk.Objects.Window.windowPresent' or any equivalent function generating
    -- a window map event.
    --
    -- This function is only useful on Wayland or X11, not with other GDK
    -- backends.
    windowSetStartupId ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> T.Text
        -- ^ /@startupId@/: a string with startup-notification identifier
        -> m ()
    windowSetStartupId :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Text -> m ()
    windowSetStartupId a
    window Text
    startupId = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        startupId' <- textToCString startupId
        gtk_window_set_startup_id window' startupId'
        touchManagedPtr window
        freeMem startupId'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowSetStartupIdMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetStartupIdMethodInfo a signature where
        overloadedMethod = windowSetStartupId

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

    #endif

    -- method Window::set_title
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "title"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "title of the window"
    --                 , 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_set_title" gtk_window_set_title ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        CString ->                              -- title : TBasicType TUTF8
        IO ()

    -- | Sets the title of the window.
    --
    -- The title of a window will be displayed in its title bar; on the
    -- X Window System, the title bar is rendered by the window manager
    -- so exactly how the title appears to users may vary according to a
    -- user’s exact configuration. The title should help a user distinguish
    -- this window from other windows they may have open. A good title might
    -- include the application name and current document filename, for example.
    --
    -- Passing @NULL@ does the same as setting the title to an empty string.
    windowSetTitle ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (T.Text)
        -- ^ /@title@/: title of the window
        -> m ()
    windowSetTitle :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> Maybe Text -> m ()
    windowSetTitle a
    window Maybe Text
    title = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeTitle <- case title 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
    jTitle -> do
                jTitle' <- Text -> IO CString
    textToCString Text
    jTitle
                return jTitle'
        gtk_window_set_title window' maybeTitle
        touchManagedPtr window
        freeMem maybeTitle
        return ()

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

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

    #endif

    -- method Window::set_titlebar
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "titlebar"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the widget to use as titlebar"
    --                 , 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_set_titlebar" gtk_window_set_titlebar ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Gtk.Widget.Widget ->                -- titlebar : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets a custom titlebar for the window.
    --
    -- A typical widget used here is t'GI.Gtk.Objects.HeaderBar.HeaderBar', as it
    -- provides various features expected of a titlebar while allowing
    -- the addition of child widgets to it.
    --
    -- If you set a custom titlebar, GTK will do its best to convince
    -- the window manager not to put its own titlebar on the window.
    -- Depending on the system, this function may not work for a window
    -- that is already visible, so you set the titlebar before calling
    -- 'GI.Gtk.Objects.Widget.widgetShow'.
    windowSetTitlebar ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (b)
        -- ^ /@titlebar@/: the widget to use as titlebar
        -> m ()
    windowSetTitlebar :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
    a -> Maybe b -> m ()
    windowSetTitlebar a
    window Maybe b
    titlebar = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeTitlebar <- case titlebar of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jTitlebar -> do
                jTitlebar' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jTitlebar
                return jTitlebar'
        gtk_window_set_titlebar window' maybeTitlebar
        touchManagedPtr window
        whenJust titlebar touchManagedPtr
        return ()

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

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

    #endif

    -- method Window::set_transient_for
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "parent"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "parent window" , 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_set_transient_for" gtk_window_set_transient_for ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        Ptr Window ->                           -- parent : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Sets a transient parent for the window.
    --
    -- Dialog windows should be set transient for the main application
    -- window they were spawned from. This allows window managers to e.g.
    -- keep the dialog on top of the main window, or center the dialog
    -- over the main window. t'GI.Gtk.Objects.Dialog.Dialog'.@/new_with_buttons/@() and other
    -- convenience functions in GTK will sometimes call this function on
    -- your behalf.
    --
    -- Passing @NULL@ for /@parent@/ unsets the current transient window.
    --
    -- On Windows, this function puts the child window on top of the parent,
    -- much as the window manager would have done on X.
    windowSetTransientFor ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a, IsWindow b) =>
        a
        -- ^ /@window@/: a window
        -> Maybe (b)
        -- ^ /@parent@/: parent window
        -> m ()
    windowSetTransientFor :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsWindow a, IsWindow b) =>
    a -> Maybe b -> m ()
    windowSetTransientFor a
    window Maybe b
    parent = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        maybeParent <- case parent of
            Maybe b
    Nothing -> Ptr Window -> IO (Ptr Window)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Window
    forall a. Ptr a
    FP.nullPtr
            Just b
    jParent -> do
                jParent' <- b -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jParent
                return jParent'
        gtk_window_set_transient_for window' maybeParent
        touchManagedPtr window
        whenJust parent touchManagedPtr
        return ()

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

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

    #endif

    -- method Window::unfullscreen
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_unfullscreen" gtk_window_unfullscreen ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Asks to remove the fullscreen state for the window, and return to
    -- its previous state.
    --
    -- Note that you shouldn’t assume the window is definitely not
    -- fullscreen afterward, because other entities (e.g. the user or
    -- window manager) could fullscreen it again, and not all window
    -- managers honor requests to unfullscreen windows; normally the
    -- window will end up restored to its normal state. Just don’t
    -- write code that crashes if not.
    --
    -- If a window is not explicitly fullscreened or unfullscreened before
    -- it is shown, the initial state is at the window managers discretion.
    --
    -- You can track the result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property, or by listening to
    -- notifications of the [Window:fullscreened]("GI.Gtk.Objects.Window#g:attr:fullscreened") property.
    windowUnfullscreen ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowUnfullscreen :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowUnfullscreen a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_unfullscreen window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowUnfullscreenMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowUnfullscreenMethodInfo a signature where
        overloadedMethod = windowUnfullscreen

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

    #endif

    -- method Window::unmaximize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_unmaximize" gtk_window_unmaximize ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Asks to unmaximize the window.
    --
    -- Note that you shouldn’t assume the window is definitely unmaximized
    -- afterward, because other entities (e.g. the user or window manager)
    -- maximize it again, and not all window managers honor requests to
    -- unmaximize.
    --
    -- If a window is not explicitly maximized or unmaximized before it is
    -- shown, the initial state is at the window managers discretion. For
    -- example, it might decide to maximize a window that almost fills the
    -- screen.
    --
    -- You can track the result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property, or by listening to
    -- notifications on the [Window:maximized]("GI.Gtk.Objects.Window#g:attr:maximized") property.
    windowUnmaximize ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowUnmaximize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowUnmaximize a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_unmaximize window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowUnmaximizeMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowUnmaximizeMethodInfo a signature where
        overloadedMethod = windowUnmaximize

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

    #endif

    -- method Window::unminimize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
    --           , argCType = Just "GtkWindow*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a window" , 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_unminimize" gtk_window_unminimize ::
        Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
        IO ()

    -- | Asks to unminimize the window.
    --
    -- Note that you shouldn’t assume the window is definitely unminimized
    -- afterward, because the windowing system might not support this
    -- functionality; other entities (e.g. the user or the window manager)
    -- could minimize it again, or there may not be a window manager in
    -- which case minimization isn’t possible, etc.
    --
    -- You can track result of this operation via the
    -- [Toplevel:state]("GI.Gdk.Interfaces.Toplevel#g:attr:state") property.
    windowUnminimize ::
        (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
        a
        -- ^ /@window@/: a window
        -> m ()
    windowUnminimize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsWindow a) =>
    a -> m ()
    windowUnminimize a
    window = 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
        window' <- a -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    window
        gtk_window_unminimize window'
        touchManagedPtr window
        return ()

    #if defined(ENABLE_OVERLOADING)
    data WindowUnminimizeMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowUnminimizeMethodInfo a signature where
        overloadedMethod = windowUnminimize

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

    #endif

    -- method Window::get_default_icon_name
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_get_default_icon_name" gtk_window_get_default_icon_name ::
        IO CString

    -- | Returns the fallback icon name for windows.
    --
    -- The returned string is owned by GTK and should not
    -- be modified. It is only valid until the next call to
    -- 'GI.Gtk.Objects.Window.windowSetDefaultIconName'.
    windowGetDefaultIconName ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m (Maybe T.Text)
        -- ^ __Returns:__ the fallback icon name for windows
    windowGetDefaultIconName :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m (Maybe Text)
    windowGetDefaultIconName  = 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
        result <- IO CString
    gtk_window_get_default_icon_name
        maybeResult <- convertIfNonNull result $ \CString
    result' -> do
            result'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result'
            return result''
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Window::get_toplevels
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_get_toplevels" gtk_window_get_toplevels ::
        IO (Ptr Gio.ListModel.ListModel)

    -- | Returns the list of all existing toplevel windows.
    --
    -- If you want to iterate through the list and perform actions involving
    -- callbacks that might destroy the widgets or add new ones, be aware that
    -- the list of toplevels will change and emit the \"items-changed\" signal.
    windowGetToplevels ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Gio.ListModel.ListModel
        -- ^ __Returns:__ the list
        --   of toplevel widgets
    windowGetToplevels :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ListModel
    windowGetToplevels  = IO ListModel -> m ListModel
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr ListModel)
    gtk_window_get_toplevels
        checkUnexpectedReturnNULL "windowGetToplevels" result
        result' <- (newObject Gio.ListModel.ListModel) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Window::list_toplevels
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TGList (TInterface Name { namespace = "Gtk" , name = "Widget" }))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_window_list_toplevels" gtk_window_list_toplevels ::
        IO (Ptr (GList (Ptr Gtk.Widget.Widget)))

    -- | Returns the list of all existing toplevel windows.
    --
    -- The widgets in the list are not individually referenced.
    -- If you want to iterate through the list and perform actions
    -- involving callbacks that might destroy the widgets, you must
    -- call @g_list_foreach (result, (GFunc)g_object_ref, NULL)@ first,
    -- and then unref all the widgets afterwards.
    windowListToplevels ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m [Gtk.Widget.Widget]
        -- ^ __Returns:__ list of
        --   toplevel widgets
    windowListToplevels :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Widget]
    windowListToplevels  = IO [Widget] -> m [Widget]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Widget] -> m [Widget]) -> IO [Widget] -> m [Widget]
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr (GList (Ptr Widget)))
    gtk_window_list_toplevels
        result' <- unpackGList result
        result'' <- mapM (newObject Gtk.Widget.Widget) result'
        g_list_free result
        return result''

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Window::set_auto_startup_notification
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "true to automatically do startup notification"
    --                 , 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_set_auto_startup_notification" gtk_window_set_auto_startup_notification ::
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Sets whether the window should request startup notification.
    --
    -- By default, after showing the first window, GTK calls
    -- 'GI.Gdk.Interfaces.Toplevel.toplevelSetStartupId'. Call this function
    -- to disable the automatic startup notification. You might do this
    -- if your first window is a splash screen, and you want to delay
    -- notification until after your real main window has been shown,
    -- for example.
    --
    -- In that example, you would disable startup notification
    -- temporarily, show your splash screen, then re-enable it so that
    -- showing the main window would automatically result in notification.
    windowSetAutoStartupNotification ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Bool
        -- ^ /@setting@/: true to automatically do startup notification
        -> m ()
    windowSetAutoStartupNotification :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bool -> m ()
    windowSetAutoStartupNotification 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
        let setting' :: CInt
    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
        CInt -> IO ()
    gtk_window_set_auto_startup_notification CInt
    setting'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Window::set_default_icon_name
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the themed icon"
    --                 , 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_set_default_icon_name" gtk_window_set_default_icon_name ::
        CString ->                              -- name : TBasicType TUTF8
        IO ()

    -- | Sets an icon to be used as fallback.
    --
    -- The fallback icon is used for windows that
    -- haven\'t had 'GI.Gtk.Objects.Window.windowSetIconName'
    -- called on them.
    windowSetDefaultIconName ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@name@/: the name of the themed icon
        -> m ()
    windowSetDefaultIconName :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
    windowSetDefaultIconName Text
    name = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        name' <- Text -> IO CString
    textToCString Text
    name
        gtk_window_set_default_icon_name name'
        freeMem name'
        return ()

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Window::set_interactive_debugging
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "enable"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "true to enable interactive debugging"
    --                 , 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_set_interactive_debugging" gtk_window_set_interactive_debugging ::
        CInt ->                                 -- enable : TBasicType TBoolean
        IO ()

    -- | Opens or closes the <https://docs.gtk.org/gtk4/running.html#interactive-debugging interactive debugger>.
    --
    -- The debugger offers access to the widget hierarchy of the application
    -- and to useful debugging tools.
    --
    -- This function allows applications that already use
    -- \<kbd>Ctrl\<\/kbd>+\<kbd>Shift\<\/kbd>+\<kbd>I\<\/kbd>
    -- (or \<kbd>Ctrl\<\/kbd>+\<kbd>Shift\<\/kbd>+\<kbd>D\<\/kbd>)
    -- for their own key shortcuts to add a different shortcut to open the Inspector.
    --
    -- If you are not overriding the default key shortcuts for the Inspector,
    -- you should not use this function.
    windowSetInteractiveDebugging ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Bool
        -- ^ /@enable@/: true to enable interactive debugging
        -> m ()
    windowSetInteractiveDebugging :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bool -> m ()
    windowSetInteractiveDebugging Bool
    enable = 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
        let enable' :: CInt
    enable' = (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
    enable
        CInt -> IO ()
    gtk_window_set_interactive_debugging CInt
    enable'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    #endif