    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A single child container with a popover.
    --
    -- You should use @GtkPopoverBin@ whenever you need to present a t'GI.Gtk.Objects.Popover.Popover'
    -- to the user.
    --
    -- == Actions
    --
    -- @GtkPopoverBin@ defines the @menu.popup@ action, which can be activated
    -- to present the popover to the user.
    --
    -- == CSS nodes
    --
    -- @GtkPopoverBin@ has a single CSS node with the name @popoverbin@.
    --
    -- /Since: 4.22/

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

    module GI.Gtk.Objects.PopoverBin
        (

    -- * Exported types
        PopoverBin(..)                          ,
        IsPopoverBin                            ,
        toPopoverBin                            ,

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

    #if defined(ENABLE_OVERLOADING)
        ResolvePopoverBinMethod                 ,
    #endif

    -- ** getChild #method:getChild#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinGetChildMethodInfo            ,
    #endif
        popoverBinGetChild                      ,

    -- ** getHandleInput #method:getHandleInput#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinGetHandleInputMethodInfo      ,
    #endif
        popoverBinGetHandleInput                ,

    -- ** getMenuModel #method:getMenuModel#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinGetMenuModelMethodInfo        ,
    #endif
        popoverBinGetMenuModel                  ,

    -- ** getPopover #method:getPopover#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinGetPopoverMethodInfo          ,
    #endif
        popoverBinGetPopover                    ,

    -- ** new #method:new#

        popoverBinNew                           ,

    -- ** popdown #method:popdown#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinPopdownMethodInfo             ,
    #endif
        popoverBinPopdown                       ,

    -- ** popup #method:popup#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinPopupMethodInfo               ,
    #endif
        popoverBinPopup                         ,

    -- ** setChild #method:setChild#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinSetChildMethodInfo            ,
    #endif
        popoverBinSetChild                      ,

    -- ** setHandleInput #method:setHandleInput#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinSetHandleInputMethodInfo      ,
    #endif
        popoverBinSetHandleInput                ,

    -- ** setMenuModel #method:setMenuModel#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinSetMenuModelMethodInfo        ,
    #endif
        popoverBinSetMenuModel                  ,

    -- ** setPopover #method:setPopover#

    #if defined(ENABLE_OVERLOADING)
        PopoverBinSetPopoverMethodInfo          ,
    #endif
        popoverBinSetPopover                    ,

     -- * Properties

    -- ** child #attr:child#
    -- | The child widget of the popover bin.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        PopoverBinChildPropertyInfo             ,
    #endif
        clearPopoverBinChild                    ,
        constructPopoverBinChild                ,
        getPopoverBinChild                      ,
    #if defined(ENABLE_OVERLOADING)
        popoverBinChild                         ,
    #endif
        setPopoverBinChild                      ,

    -- ** handleInput #attr:handleInput#
    -- | Whether the popover bin will handle input
    -- to trigger the popup.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        PopoverBinHandleInputPropertyInfo       ,
    #endif
        constructPopoverBinHandleInput          ,
        getPopoverBinHandleInput                ,
    #if defined(ENABLE_OVERLOADING)
        popoverBinHandleInput                   ,
    #endif
        setPopoverBinHandleInput                ,

    -- ** menuModel #attr:menuModel#
    -- | The @GMenuModel@ from which the popup will be created.
    --
    -- See 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel' for the interaction
    -- with the [PopoverBin:popover]("GI.Gtk.Objects.PopoverBin#g:attr:popover") property.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        PopoverBinMenuModelPropertyInfo         ,
    #endif
        clearPopoverBinMenuModel                ,
        constructPopoverBinMenuModel            ,
        getPopoverBinMenuModel                  ,
    #if defined(ENABLE_OVERLOADING)
        popoverBinMenuModel                     ,
    #endif
        setPopoverBinMenuModel                  ,

    -- ** popover #attr:popover#
    -- | The @GtkPopover@ that will be popped up when calling
    -- 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        PopoverBinPopoverPropertyInfo           ,
    #endif
        clearPopoverBinPopover                  ,
        constructPopoverBinPopover              ,
        getPopoverBinPopover                    ,
    #if defined(ENABLE_OVERLOADING)
        popoverBinPopover                       ,
    #endif
        setPopoverBinPopover                    ,

        ) where

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

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

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
    import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import qualified GI.Gdk.Objects.Device as Gdk.Device
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.Event as Gdk.Event
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
    import qualified GI.Gdk.Objects.Surface as Gdk.Surface
    import qualified GI.Gdk.Objects.Texture as Gdk.Texture
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.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.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.Popover as Gtk.Popover
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Objects.Context as Pango.Context
    import qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import qualified GI.Pango.Objects.Layout as Pango.Layout

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

    #endif

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

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

    foreign import ccall "gtk_popover_bin_get_type"
        c_gtk_popover_bin_get_type :: IO B.Types.GType

    instance B.Types.TypedObject PopoverBin where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_popover_bin_get_type

    instance B.Types.GObject PopoverBin

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

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

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

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

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

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

    #endif

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

    #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' popoverBin #child
    -- @
    getPopoverBinChild :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe Gtk.Widget.Widget)
    getPopoverBinChild :: forall (m :: * -> *) o.
    (MonadIO m, IsPopoverBin o) =>
    o -> m (Maybe Widget)
    getPopoverBinChild 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' popoverBin [ #child 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setPopoverBinChild :: (MonadIO m, IsPopoverBin o, Gtk.Widget.IsWidget a) => o -> a -> m ()
    setPopoverBinChild :: forall (m :: * -> *) o a.
    (MonadIO m, IsPopoverBin o, IsWidget a) =>
    o -> a -> m ()
    setPopoverBinChild 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`.
    constructPopoverBinChild :: (IsPopoverBin o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
    constructPopoverBinChild :: forall o (m :: * -> *) a.
    (IsPopoverBin o, MonadIO m, IsWidget a) =>
    a -> m (GValueConstruct o)
    constructPopoverBinChild 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
    -- @
    clearPopoverBinChild :: (MonadIO m, IsPopoverBin o) => o -> m ()
    clearPopoverBinChild :: forall (m :: * -> *) o. (MonadIO m, IsPopoverBin o) => o -> m ()
    clearPopoverBinChild 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 PopoverBinChildPropertyInfo
    instance AttrInfo PopoverBinChildPropertyInfo where
        type AttrAllowedOps PopoverBinChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint PopoverBinChildPropertyInfo = IsPopoverBin
        type AttrSetTypeConstraint PopoverBinChildPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferTypeConstraint PopoverBinChildPropertyInfo = Gtk.Widget.IsWidget
        type AttrTransferType PopoverBinChildPropertyInfo = Gtk.Widget.Widget
        type AttrGetType PopoverBinChildPropertyInfo = (Maybe Gtk.Widget.Widget)
        type AttrLabel PopoverBinChildPropertyInfo = "child"
        type AttrOrigin PopoverBinChildPropertyInfo = PopoverBin
        attrGet = getPopoverBinChild
        attrSet = setPopoverBinChild
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Widget.Widget v
        attrConstruct = constructPopoverBinChild
        attrClear = clearPopoverBinChild
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.child"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:child"
            })
    #endif

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

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

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

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

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

    -- VVV Prop "menu-model"
       -- Type: TInterface (Name {namespace = "Gio", name = "MenuModel"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just True,Just True)

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

    -- | Set the value of the “@menu-model@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' popoverBin [ #menuModel 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o, Gio.MenuModel.IsMenuModel a) => o -> a -> m ()
    setPopoverBinMenuModel :: forall (m :: * -> *) o a.
    (MonadIO m, IsPopoverBin o, IsMenuModel a) =>
    o -> a -> m ()
    setPopoverBinMenuModel 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
    "menu-model" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

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

    -- | Set the value of the “@menu-model@” 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' #menuModel
    -- @
    clearPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o) => o -> m ()
    clearPopoverBinMenuModel :: forall (m :: * -> *) o. (MonadIO m, IsPopoverBin o) => o -> m ()
    clearPopoverBinMenuModel 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 MenuModel -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "menu-model" (Maybe MenuModel
    forall a. Maybe a
    Nothing :: Maybe Gio.MenuModel.MenuModel)

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinMenuModelPropertyInfo
    instance AttrInfo PopoverBinMenuModelPropertyInfo where
        type AttrAllowedOps PopoverBinMenuModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint PopoverBinMenuModelPropertyInfo = IsPopoverBin
        type AttrSetTypeConstraint PopoverBinMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
        type AttrTransferTypeConstraint PopoverBinMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
        type AttrTransferType PopoverBinMenuModelPropertyInfo = Gio.MenuModel.MenuModel
        type AttrGetType PopoverBinMenuModelPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
        type AttrLabel PopoverBinMenuModelPropertyInfo = "menu-model"
        type AttrOrigin PopoverBinMenuModelPropertyInfo = PopoverBin
        attrGet = getPopoverBinMenuModel
        attrSet = setPopoverBinMenuModel
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gio.MenuModel.MenuModel v
        attrConstruct = constructPopoverBinMenuModel
        attrClear = clearPopoverBinMenuModel
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.menuModel"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:menuModel"
            })
    #endif

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinPopoverPropertyInfo
    instance AttrInfo PopoverBinPopoverPropertyInfo where
        type AttrAllowedOps PopoverBinPopoverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint PopoverBinPopoverPropertyInfo = IsPopoverBin
        type AttrSetTypeConstraint PopoverBinPopoverPropertyInfo = Gtk.Popover.IsPopover
        type AttrTransferTypeConstraint PopoverBinPopoverPropertyInfo = Gtk.Popover.IsPopover
        type AttrTransferType PopoverBinPopoverPropertyInfo = Gtk.Popover.Popover
        type AttrGetType PopoverBinPopoverPropertyInfo = (Maybe Gtk.Popover.Popover)
        type AttrLabel PopoverBinPopoverPropertyInfo = "popover"
        type AttrOrigin PopoverBinPopoverPropertyInfo = PopoverBin
        attrGet = getPopoverBinPopover
        attrSet = setPopoverBinPopover
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.Popover.Popover v
        attrConstruct = constructPopoverBinPopover
        attrClear = clearPopoverBinPopover
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popover"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:popover"
            })
    #endif

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

    #if defined(ENABLE_OVERLOADING)
    popoverBinChild :: AttrLabelProxy "child"
    popoverBinChild = AttrLabelProxy

    popoverBinHandleInput :: AttrLabelProxy "handleInput"
    popoverBinHandleInput = AttrLabelProxy

    popoverBinMenuModel :: AttrLabelProxy "menuModel"
    popoverBinMenuModel = AttrLabelProxy

    popoverBinPopover :: AttrLabelProxy "popover"
    popoverBinPopover = AttrLabelProxy

    #endif

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

    #endif

    -- method PopoverBin::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "PopoverBin" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_popover_bin_new" gtk_popover_bin_new ::
        IO (Ptr PopoverBin)

    -- | Creates a new popover bin widget.
    --
    -- /Since: 4.22/
    popoverBinNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m PopoverBin
        -- ^ __Returns:__ the newly created popover bin
    popoverBinNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m PopoverBin
    popoverBinNew  = IO PopoverBin -> m PopoverBin
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO PopoverBin -> m PopoverBin) -> IO PopoverBin -> m PopoverBin
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr PopoverBin)
    gtk_popover_bin_new
        checkUnexpectedReturnNULL "popoverBinNew" result
        result' <- (newObject PopoverBin) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method PopoverBin::get_child
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , 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_popover_bin_get_child" gtk_popover_bin_get_child ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        IO (Ptr Gtk.Widget.Widget)

    -- | Retrieves the child widget of the popover bin.
    --
    -- /Since: 4.22/
    popoverBinGetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -- ^ /@self@/: a popover bin
        -> m (Maybe Gtk.Widget.Widget)
        -- ^ __Returns:__ the child widget
    popoverBinGetChild :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> m (Maybe Widget)
    popoverBinGetChild a
    self = 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
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_popover_bin_get_child self'
        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 self
        return maybeResult

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

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

    #endif

    -- method PopoverBin::get_handle_input
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , 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_popover_bin_get_handle_input" gtk_popover_bin_get_handle_input ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        IO CInt

    -- | /No description available in the introspection data./
    popoverBinGetHandleInput ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -> m Bool
    popoverBinGetHandleInput :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> m Bool
    popoverBinGetHandleInput a
    self = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_popover_bin_get_handle_input self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinGetHandleInputMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinGetHandleInputMethodInfo a signature where
        overloadedMethod = popoverBinGetHandleInput

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

    #endif

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

    foreign import ccall "gtk_popover_bin_get_menu_model" gtk_popover_bin_get_menu_model ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        IO (Ptr Gio.MenuModel.MenuModel)

    -- | Retrieves the menu model set using 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel'.
    --
    -- /Since: 4.22/
    popoverBinGetMenuModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -- ^ /@self@/: a popover bin
        -> m (Maybe Gio.MenuModel.MenuModel)
        -- ^ __Returns:__ the menu model for the popover
    popoverBinGetMenuModel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> m (Maybe MenuModel)
    popoverBinGetMenuModel a
    self = IO (Maybe MenuModel) -> m (Maybe MenuModel)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
    -> IO (Maybe MenuModel) -> m (Maybe MenuModel)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_popover_bin_get_menu_model self'
        maybeResult <- convertIfNonNull result $ \Ptr MenuModel
    result' -> do
            result'' <- ((ManagedPtr MenuModel -> MenuModel)
    -> Ptr MenuModel -> IO MenuModel
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr MenuModel -> MenuModel
    Gio.MenuModel.MenuModel) Ptr MenuModel
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinGetMenuModelMethodInfo
    instance (signature ~ (m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinGetMenuModelMethodInfo a signature where
        overloadedMethod = popoverBinGetMenuModel

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

    #endif

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

    foreign import ccall "gtk_popover_bin_get_popover" gtk_popover_bin_get_popover ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        IO (Ptr Gtk.Popover.Popover)

    -- | Retrieves the @GtkPopover@ set using 'GI.Gtk.Objects.PopoverBin.popoverBinSetPopover'.
    --
    -- /Since: 4.22/
    popoverBinGetPopover ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -- ^ /@self@/: a popover bin
        -> m (Maybe Gtk.Popover.Popover)
        -- ^ __Returns:__ a popover widget
    popoverBinGetPopover :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> m (Maybe Popover)
    popoverBinGetPopover a
    self = IO (Maybe Popover) -> m (Maybe Popover)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Popover) -> m (Maybe Popover))
    -> IO (Maybe Popover) -> m (Maybe Popover)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_popover_bin_get_popover self'
        maybeResult <- convertIfNonNull result $ \Ptr Popover
    result' -> do
            result'' <- ((ManagedPtr Popover -> Popover) -> Ptr Popover -> IO Popover
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Popover -> Popover
    Gtk.Popover.Popover) Ptr Popover
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinGetPopoverMethodInfo
    instance (signature ~ (m (Maybe Gtk.Popover.Popover)), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinGetPopoverMethodInfo a signature where
        overloadedMethod = popoverBinGetPopover

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

    #endif

    -- method PopoverBin::popdown
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , 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_popover_bin_popdown" gtk_popover_bin_popdown ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        IO ()

    -- | Hides the popover from the user.
    --
    -- See: 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'
    --
    -- /Since: 4.22/
    popoverBinPopdown ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -- ^ /@self@/: a popover bin
        -> m ()
    popoverBinPopdown :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> m ()
    popoverBinPopdown a
    self = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_popover_bin_popdown self'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinPopdownMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinPopdownMethodInfo a signature where
        overloadedMethod = popoverBinPopdown

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

    #endif

    -- method PopoverBin::popup
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , 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_popover_bin_popup" gtk_popover_bin_popup ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        IO ()

    -- | Presents the popover to the user.
    --
    -- Use 'GI.Gtk.Objects.PopoverBin.popoverBinSetPopover' or
    -- 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel' to define the popover.
    --
    -- See: 'GI.Gtk.Objects.PopoverBin.popoverBinPopdown'
    --
    -- /Since: 4.22/
    popoverBinPopup ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -- ^ /@self@/: a popover bin
        -> m ()
    popoverBinPopup :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> m ()
    popoverBinPopup a
    self = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_popover_bin_popup self'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinPopupMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinPopupMethodInfo a signature where
        overloadedMethod = popoverBinPopup

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

    #endif

    -- method PopoverBin::set_child
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , 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 of the popover bin"
    --                 , 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_popover_bin_set_child" gtk_popover_bin_set_child ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
        IO ()

    -- | Sets the child of the popover bin.
    --
    -- /Since: 4.22/
    popoverBinSetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@self@/: a popover bin
        -> Maybe (b)
        -- ^ /@child@/: the child of the popover bin
        -> m ()
    popoverBinSetChild :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsPopoverBin a, IsWidget b) =>
    a -> Maybe b -> m ()
    popoverBinSetChild a
    self 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
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        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_popover_bin_set_child self' maybeChild
        touchManagedPtr self
        whenJust child touchManagedPtr
        return ()

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

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

    #endif

    -- method PopoverBin::set_handle_input
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "handle_input"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to handle input"
    --                 , 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_popover_bin_set_handle_input" gtk_popover_bin_set_handle_input ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        CInt ->                                 -- handle_input : TBasicType TBoolean
        IO ()

    -- | Enables or disables input handling.
    --
    -- If enabled, the popover bin will pop up the
    -- popover on right-click or long press, as expected
    -- for a context menu.
    --
    -- /Since: 4.22/
    popoverBinSetHandleInput ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
        a
        -- ^ /@self@/: a popover bin
        -> Bool
        -- ^ /@handleInput@/: whether to handle input
        -> m ()
    popoverBinSetHandleInput :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsPopoverBin a) =>
    a -> Bool -> m ()
    popoverBinSetHandleInput a
    self Bool
    handleInput = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let handleInput' = (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
    handleInput
        gtk_popover_bin_set_handle_input self' handleInput'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinSetHandleInputMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinSetHandleInputMethodInfo a signature where
        overloadedMethod = popoverBinSetHandleInput

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

    #endif

    -- method PopoverBin::set_menu_model
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "model"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "MenuModel" }
    --           , argCType = Just "GMenuModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a menu model" , 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_popover_bin_set_menu_model" gtk_popover_bin_set_menu_model ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        Ptr Gio.MenuModel.MenuModel ->          -- model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
        IO ()

    -- | Sets the menu model used to create the popover that will be
    -- presented when calling 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'.
    --
    -- If /@model@/ is @NULL@, the popover will be unset.
    --
    -- A t'GI.Gtk.Objects.Popover.Popover' will be created from the menu model with
    -- 'GI.Gtk.Objects.PopoverMenu.popoverMenuNewFromModel'. Actions will be connected
    -- as documented for this function.
    --
    -- If [PopoverBin:popover]("GI.Gtk.Objects.PopoverBin#g:attr:popover") is already set, it will be
    -- dissociated from the popover bin, and the property is set to @NULL@.
    --
    -- See: 'GI.Gtk.Objects.PopoverBin.popoverBinSetPopover'
    --
    -- /Since: 4.22/
    popoverBinSetMenuModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a, Gio.MenuModel.IsMenuModel b) =>
        a
        -- ^ /@self@/: a popover bin
        -> Maybe (b)
        -- ^ /@model@/: a menu model
        -> m ()
    popoverBinSetMenuModel :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsPopoverBin a, IsMenuModel b) =>
    a -> Maybe b -> m ()
    popoverBinSetMenuModel a
    self Maybe b
    model = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeModel <- case model of
            Maybe b
    Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr MenuModel
    forall a. Ptr a
    FP.nullPtr
            Just b
    jModel -> do
                jModel' <- b -> IO (Ptr MenuModel)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jModel
                return jModel'
        gtk_popover_bin_set_menu_model self' maybeModel
        touchManagedPtr self
        whenJust model touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinSetMenuModelMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsPopoverBin a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod PopoverBinSetMenuModelMethodInfo a signature where
        overloadedMethod = popoverBinSetMenuModel

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

    #endif

    -- method PopoverBin::set_popover
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
    --           , argCType = Just "GtkPopoverBin*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "popover"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Popover" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkPopover`" , 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_popover_bin_set_popover" gtk_popover_bin_set_popover ::
        Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
        Ptr Gtk.Popover.Popover ->              -- popover : TInterface (Name {namespace = "Gtk", name = "Popover"})
        IO ()

    -- | Sets the @GtkPopover@ that will be presented when calling
    -- 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'.
    --
    -- If /@popover@/ is @NULL@, the popover will be unset.
    --
    -- If [PopoverBin:menuModel]("GI.Gtk.Objects.PopoverBin#g:attr:menuModel") is set before calling
    -- this function, then the menu model property will be unset.
    --
    -- See: 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel'
    --
    -- /Since: 4.22/
    popoverBinSetPopover ::
        (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a, Gtk.Popover.IsPopover b) =>
        a
        -- ^ /@self@/: a popover bin
        -> Maybe (b)
        -- ^ /@popover@/: a @GtkPopover@
        -> m ()
    popoverBinSetPopover :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsPopoverBin a, IsPopover b) =>
    a -> Maybe b -> m ()
    popoverBinSetPopover a
    self Maybe b
    popover = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr PopoverBin)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybePopover <- case popover of
            Maybe b
    Nothing -> Ptr Popover -> IO (Ptr Popover)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Popover
    forall a. Ptr a
    FP.nullPtr
            Just b
    jPopover -> do
                jPopover' <- b -> IO (Ptr Popover)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jPopover
                return jPopover'
        gtk_popover_bin_set_popover self' maybePopover
        touchManagedPtr self
        whenJust popover touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data PopoverBinSetPopoverMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsPopoverBin a, Gtk.Popover.IsPopover b) => O.OverloadedMethod PopoverBinSetPopoverMethodInfo a signature where
        overloadedMethod = popoverBinSetPopover

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

    #endif