    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Base class for containers.

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

    module GI.Gtk.Structs.ContainerClass
        (

    -- * Exported types
        ContainerClass(..)                      ,
        newZeroContainerClass                   ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [findChildProperty]("GI.Gtk.Structs.ContainerClass#g:method:findChildProperty"), [handleBorderWidth]("GI.Gtk.Structs.ContainerClass#g:method:handleBorderWidth"), [installChildProperty]("GI.Gtk.Structs.ContainerClass#g:method:installChildProperty").
    --
    -- ==== Getters
    -- /None/.
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveContainerClassMethod             ,
    #endif

    -- ** findChildProperty #method:findChildProperty#

    #if defined(ENABLE_OVERLOADING)
        ContainerClassFindChildPropertyMethodInfo,
    #endif
        containerClassFindChildProperty         ,

    -- ** handleBorderWidth #method:handleBorderWidth#

    #if defined(ENABLE_OVERLOADING)
        ContainerClassHandleBorderWidthMethodInfo,
    #endif
        containerClassHandleBorderWidth         ,

    -- ** installChildProperty #method:installChildProperty#

    #if defined(ENABLE_OVERLOADING)
        ContainerClassInstallChildPropertyMethodInfo,
    #endif
        containerClassInstallChildProperty      ,

     -- * Properties

    -- ** add #attr:add#
    -- | Signal emitted when a widget is added to container.

        clearContainerClassAdd                  ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_add                      ,
    #endif
        getContainerClassAdd                    ,
        setContainerClassAdd                    ,

    -- ** checkResize #attr:checkResize#
    -- | Signal emitted when a size recalculation is needed.

        clearContainerClassCheckResize          ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_checkResize              ,
    #endif
        getContainerClassCheckResize            ,
        setContainerClassCheckResize            ,

    -- ** childType #attr:childType#
    -- | Returns the type of the children supported by the container.

        clearContainerClassChildType            ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_childType                ,
    #endif
        getContainerClassChildType              ,
        setContainerClassChildType              ,

    -- ** compositeName #attr:compositeName#
    -- | Gets a widget’s composite name. Deprecated: 3.10.

        clearContainerClassCompositeName        ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_compositeName            ,
    #endif
        getContainerClassCompositeName          ,
        setContainerClassCompositeName          ,

    -- ** forall #attr:forall#
    -- | Invokes callback on each child of container. The callback handler
    --    may remove the child.

        clearContainerClassForall               ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_forall                   ,
    #endif
        getContainerClassForall                 ,
        setContainerClassForall                 ,

    -- ** getChildProperty #attr:getChildProperty#
    -- | Get a property from a child of container.

        clearContainerClassGetChildProperty     ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_getChildProperty         ,
    #endif
        getContainerClassGetChildProperty       ,
        setContainerClassGetChildProperty       ,

    -- ** getPathForChild #attr:getPathForChild#
    -- | Get path representing entire widget hierarchy
    --    from the toplevel down to and including /@child@/.

        clearContainerClassGetPathForChild      ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_getPathForChild          ,
    #endif
        getContainerClassGetPathForChild        ,
        setContainerClassGetPathForChild        ,

    -- ** parentClass #attr:parentClass#
    -- | The parent class.

    #if defined(ENABLE_OVERLOADING)
        containerClass_parentClass              ,
    #endif
        getContainerClassParentClass            ,

    -- ** remove #attr:remove#
    -- | Signal emitted when a widget is removed from container.

        clearContainerClassRemove               ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_remove                   ,
    #endif
        getContainerClassRemove                 ,
        setContainerClassRemove                 ,

    -- ** setChildProperty #attr:setChildProperty#
    -- | Set a property on a child of container.

        clearContainerClassSetChildProperty     ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_setChildProperty         ,
    #endif
        getContainerClassSetChildProperty       ,
        setContainerClassSetChildProperty       ,

    -- ** setFocusChild #attr:setFocusChild#
    -- | Sets the focused child of container.

        clearContainerClassSetFocusChild        ,
    #if defined(ENABLE_OVERLOADING)
        containerClass_setFocusChild            ,
    #endif
        getContainerClassSetFocusChild          ,
        setContainerClassSetFocusChild          ,

        ) 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.Atk.Enums as Atk.Enums
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Callbacks as GObject.Callbacks
    import qualified GI.GObject.Structs.InitiallyUnownedClass as GObject.InitiallyUnownedClass
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetClass as Gtk.WidgetClass

    #else
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetClass as Gtk.WidgetClass

    #endif

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

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

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

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

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

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

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

    containerClass_parentClass :: AttrLabelProxy "parentClass"
    containerClass_parentClass = AttrLabelProxy

    #endif

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassAddFieldInfo
    instance AttrInfo ContainerClassAddFieldInfo where
        type AttrBaseTypeConstraint ContainerClassAddFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassAddFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassAddFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
        type AttrTransferTypeConstraint ContainerClassAddFieldInfo = (~)Gtk.Callbacks.ContainerClassAddFieldCallback
        type AttrTransferType ContainerClassAddFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
        type AttrGetType ContainerClassAddFieldInfo = Maybe Gtk.Callbacks.ContainerClassAddFieldCallback
        type AttrLabel ContainerClassAddFieldInfo = "add"
        type AttrOrigin ContainerClassAddFieldInfo = ContainerClass
        attrGet = getContainerClassAdd
        attrSet = setContainerClassAdd
        attrConstruct = undefined
        attrClear = clearContainerClassAdd
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassAddFieldCallback (Gtk.Callbacks.wrap_ContainerClassAddFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.add"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:add"
            })

    containerClass_add :: AttrLabelProxy "add"
    containerClass_add = AttrLabelProxy

    #endif

    -- | Get the value of the “@remove@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #remove
    -- @
    getContainerClassRemove :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassRemoveFieldCallback)
    getContainerClassRemove :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
    getContainerClassRemove ContainerClass
    s = IO (Maybe ContainerClassAddFieldCallback)
    -> m (Maybe ContainerClassAddFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassAddFieldCallback)
     -> m (Maybe ContainerClassAddFieldCallback))
    -> IO (Maybe ContainerClassAddFieldCallback)
    -> m (Maybe ContainerClassAddFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassAddFieldCallback))
    -> IO (Maybe ContainerClassAddFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO (Maybe ContainerClassAddFieldCallback))
     -> IO (Maybe ContainerClassAddFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassAddFieldCallback))
    -> IO (Maybe ContainerClassAddFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassAddFieldCallback)
    -> IO (FunPtr C_ContainerClassAddFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    832) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassAddFieldCallback
    val' -> do
            let val'' :: ContainerClassAddFieldCallback
    val'' = FunPtr C_ContainerClassAddFieldCallback
    -> ContainerClassAddFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
    FunPtr C_ContainerClassAddFieldCallback -> a -> b -> m ()
    Gtk.Callbacks.dynamic_ContainerClassRemoveFieldCallback FunPtr C_ContainerClassAddFieldCallback
    val'
            ContainerClassAddFieldCallback -> IO ContainerClassAddFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassAddFieldCallback
    val''
        return result

    -- | Set the value of the “@remove@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #remove 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback -> m ()
    setContainerClassRemove :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
    setContainerClassRemove ContainerClass
    s FunPtr C_ContainerClassAddFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassAddFieldCallback)
    -> FunPtr C_ContainerClassAddFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    832) (FunPtr C_ContainerClassAddFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassRemoveFieldInfo
    instance AttrInfo ContainerClassRemoveFieldInfo where
        type AttrBaseTypeConstraint ContainerClassRemoveFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassRemoveFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassRemoveFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
        type AttrTransferTypeConstraint ContainerClassRemoveFieldInfo = (~)Gtk.Callbacks.ContainerClassRemoveFieldCallback
        type AttrTransferType ContainerClassRemoveFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
        type AttrGetType ContainerClassRemoveFieldInfo = Maybe Gtk.Callbacks.ContainerClassRemoveFieldCallback
        type AttrLabel ContainerClassRemoveFieldInfo = "remove"
        type AttrOrigin ContainerClassRemoveFieldInfo = ContainerClass
        attrGet = getContainerClassRemove
        attrSet = setContainerClassRemove
        attrConstruct = undefined
        attrClear = clearContainerClassRemove
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassRemoveFieldCallback (Gtk.Callbacks.wrap_ContainerClassRemoveFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.remove"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:remove"
            })

    containerClass_remove :: AttrLabelProxy "remove"
    containerClass_remove = AttrLabelProxy

    #endif

    -- | Get the value of the “@check_resize@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #checkResize
    -- @
    getContainerClassCheckResize :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback)
    getContainerClassCheckResize :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass -> m (Maybe ContainerClassCheckResizeFieldCallback)
    getContainerClassCheckResize ContainerClass
    s = IO (Maybe ContainerClassCheckResizeFieldCallback)
    -> m (Maybe ContainerClassCheckResizeFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassCheckResizeFieldCallback)
     -> m (Maybe ContainerClassCheckResizeFieldCallback))
    -> IO (Maybe ContainerClassCheckResizeFieldCallback)
    -> m (Maybe ContainerClassCheckResizeFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassCheckResizeFieldCallback))
    -> IO (Maybe ContainerClassCheckResizeFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassCheckResizeFieldCallback))
     -> IO (Maybe ContainerClassCheckResizeFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassCheckResizeFieldCallback))
    -> IO (Maybe ContainerClassCheckResizeFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
    -> IO (FunPtr C_ContainerClassCheckResizeFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    840) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassCheckResizeFieldCallback
    val' -> do
            let val'' :: ContainerClassCheckResizeFieldCallback
    val'' = FunPtr C_ContainerClassCheckResizeFieldCallback
    -> ContainerClassCheckResizeFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContainer a) =>
    FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m ()
    Gtk.Callbacks.dynamic_ContainerClassCheckResizeFieldCallback FunPtr C_ContainerClassCheckResizeFieldCallback
    val'
            ContainerClassCheckResizeFieldCallback
    -> IO ContainerClassCheckResizeFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassCheckResizeFieldCallback
    val''
        return result

    -- | Set the value of the “@check_resize@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #checkResize 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassCheckResize :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback -> m ()
    setContainerClassCheckResize :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> FunPtr C_ContainerClassCheckResizeFieldCallback -> m ()
    setContainerClassCheckResize ContainerClass
    s FunPtr C_ContainerClassCheckResizeFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
    -> FunPtr C_ContainerClassCheckResizeFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    840) (FunPtr C_ContainerClassCheckResizeFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassCheckResizeFieldInfo
    instance AttrInfo ContainerClassCheckResizeFieldInfo where
        type AttrBaseTypeConstraint ContainerClassCheckResizeFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassCheckResizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassCheckResizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
        type AttrTransferTypeConstraint ContainerClassCheckResizeFieldInfo = (~)Gtk.Callbacks.ContainerClassCheckResizeFieldCallback
        type AttrTransferType ContainerClassCheckResizeFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
        type AttrGetType ContainerClassCheckResizeFieldInfo = Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback
        type AttrLabel ContainerClassCheckResizeFieldInfo = "check_resize"
        type AttrOrigin ContainerClassCheckResizeFieldInfo = ContainerClass
        attrGet = getContainerClassCheckResize
        attrSet = setContainerClassCheckResize
        attrConstruct = undefined
        attrClear = clearContainerClassCheckResize
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassCheckResizeFieldCallback (Gtk.Callbacks.wrap_ContainerClassCheckResizeFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.checkResize"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:checkResize"
            })

    containerClass_checkResize :: AttrLabelProxy "checkResize"
    containerClass_checkResize = AttrLabelProxy

    #endif

    -- | Get the value of the “@forall@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #forall
    -- @
    getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures)
    getContainerClassForall :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> m (Maybe ContainerClassForallFieldCallback_WithClosures)
    getContainerClassForall ContainerClass
    s = IO (Maybe ContainerClassForallFieldCallback_WithClosures)
    -> m (Maybe ContainerClassForallFieldCallback_WithClosures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassForallFieldCallback_WithClosures)
     -> m (Maybe ContainerClassForallFieldCallback_WithClosures))
    -> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
    -> m (Maybe ContainerClassForallFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
    -> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
     -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
    -> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassForallFieldCallback)
    -> IO (FunPtr C_ContainerClassForallFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassForallFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    848) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassForallFieldCallback
    val' -> do
            let val'' :: ContainerClassForallFieldCallback_WithClosures
    val'' = FunPtr C_ContainerClassForallFieldCallback
    -> ContainerClassForallFieldCallback_WithClosures
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContainer a) =>
    FunPtr C_ContainerClassForallFieldCallback
    -> a -> Bool -> Callback_WithClosures -> Ptr () -> m ()
    Gtk.Callbacks.dynamic_ContainerClassForallFieldCallback FunPtr C_ContainerClassForallFieldCallback
    val'
            ContainerClassForallFieldCallback_WithClosures
    -> IO ContainerClassForallFieldCallback_WithClosures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassForallFieldCallback_WithClosures
    val''
        return result

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

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassForallFieldInfo
    instance AttrInfo ContainerClassForallFieldInfo where
        type AttrBaseTypeConstraint ContainerClassForallFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassForallFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassForallFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
        type AttrTransferTypeConstraint ContainerClassForallFieldInfo = (~)Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures
        type AttrTransferType ContainerClassForallFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
        type AttrGetType ContainerClassForallFieldInfo = Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures
        type AttrLabel ContainerClassForallFieldInfo = "forall"
        type AttrOrigin ContainerClassForallFieldInfo = ContainerClass
        attrGet = getContainerClassForall
        attrSet = setContainerClassForall
        attrConstruct = undefined
        attrClear = clearContainerClassForall
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassForallFieldCallback (Gtk.Callbacks.wrap_ContainerClassForallFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.forall"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:forall"
            })

    containerClass_forall :: AttrLabelProxy "forall"
    containerClass_forall = AttrLabelProxy

    #endif

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassSetFocusChildFieldInfo
    instance AttrInfo ContainerClassSetFocusChildFieldInfo where
        type AttrBaseTypeConstraint ContainerClassSetFocusChildFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassSetFocusChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassSetFocusChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
        type AttrTransferTypeConstraint ContainerClassSetFocusChildFieldInfo = (~)Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback
        type AttrTransferType ContainerClassSetFocusChildFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
        type AttrGetType ContainerClassSetFocusChildFieldInfo = Maybe Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback
        type AttrLabel ContainerClassSetFocusChildFieldInfo = "set_focus_child"
        type AttrOrigin ContainerClassSetFocusChildFieldInfo = ContainerClass
        attrGet = getContainerClassSetFocusChild
        attrSet = setContainerClassSetFocusChild
        attrConstruct = undefined
        attrClear = clearContainerClassSetFocusChild
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassSetFocusChildFieldCallback (Gtk.Callbacks.wrap_ContainerClassSetFocusChildFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.setFocusChild"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:setFocusChild"
            })

    containerClass_setFocusChild :: AttrLabelProxy "setFocusChild"
    containerClass_setFocusChild = AttrLabelProxy

    #endif

    -- | Get the value of the “@child_type@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #childType
    -- @
    getContainerClassChildType :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassChildTypeFieldCallback)
    getContainerClassChildType :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass -> m (Maybe ContainerClassChildTypeFieldCallback)
    getContainerClassChildType ContainerClass
    s = IO (Maybe ContainerClassChildTypeFieldCallback)
    -> m (Maybe ContainerClassChildTypeFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassChildTypeFieldCallback)
     -> m (Maybe ContainerClassChildTypeFieldCallback))
    -> IO (Maybe ContainerClassChildTypeFieldCallback)
    -> m (Maybe ContainerClassChildTypeFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassChildTypeFieldCallback))
    -> IO (Maybe ContainerClassChildTypeFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassChildTypeFieldCallback))
     -> IO (Maybe ContainerClassChildTypeFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassChildTypeFieldCallback))
    -> IO (Maybe ContainerClassChildTypeFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
    -> IO (FunPtr C_ContainerClassChildTypeFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    864) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassChildTypeFieldCallback
    val' -> do
            let val'' :: ContainerClassChildTypeFieldCallback
    val'' = FunPtr C_ContainerClassChildTypeFieldCallback
    -> ContainerClassChildTypeFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContainer a) =>
    FunPtr C_ContainerClassChildTypeFieldCallback -> a -> m GType
    Gtk.Callbacks.dynamic_ContainerClassChildTypeFieldCallback FunPtr C_ContainerClassChildTypeFieldCallback
    val'
            ContainerClassChildTypeFieldCallback
    -> IO ContainerClassChildTypeFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassChildTypeFieldCallback
    val''
        return result

    -- | Set the value of the “@child_type@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #childType 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback -> m ()
    setContainerClassChildType :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> FunPtr C_ContainerClassChildTypeFieldCallback -> m ()
    setContainerClassChildType ContainerClass
    s FunPtr C_ContainerClassChildTypeFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
    -> FunPtr C_ContainerClassChildTypeFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    864) (FunPtr C_ContainerClassChildTypeFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassChildTypeFieldInfo
    instance AttrInfo ContainerClassChildTypeFieldInfo where
        type AttrBaseTypeConstraint ContainerClassChildTypeFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassChildTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassChildTypeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
        type AttrTransferTypeConstraint ContainerClassChildTypeFieldInfo = (~)Gtk.Callbacks.ContainerClassChildTypeFieldCallback
        type AttrTransferType ContainerClassChildTypeFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
        type AttrGetType ContainerClassChildTypeFieldInfo = Maybe Gtk.Callbacks.ContainerClassChildTypeFieldCallback
        type AttrLabel ContainerClassChildTypeFieldInfo = "child_type"
        type AttrOrigin ContainerClassChildTypeFieldInfo = ContainerClass
        attrGet = getContainerClassChildType
        attrSet = setContainerClassChildType
        attrConstruct = undefined
        attrClear = clearContainerClassChildType
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassChildTypeFieldCallback (Gtk.Callbacks.wrap_ContainerClassChildTypeFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.childType"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:childType"
            })

    containerClass_childType :: AttrLabelProxy "childType"
    containerClass_childType = AttrLabelProxy

    #endif

    -- | Get the value of the “@composite_name@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #compositeName
    -- @
    getContainerClassCompositeName :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback)
    getContainerClassCompositeName :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> m (Maybe ContainerClassCompositeNameFieldCallback)
    getContainerClassCompositeName ContainerClass
    s = IO (Maybe ContainerClassCompositeNameFieldCallback)
    -> m (Maybe ContainerClassCompositeNameFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassCompositeNameFieldCallback)
     -> m (Maybe ContainerClassCompositeNameFieldCallback))
    -> IO (Maybe ContainerClassCompositeNameFieldCallback)
    -> m (Maybe ContainerClassCompositeNameFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassCompositeNameFieldCallback))
    -> IO (Maybe ContainerClassCompositeNameFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassCompositeNameFieldCallback))
     -> IO (Maybe ContainerClassCompositeNameFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassCompositeNameFieldCallback))
    -> IO (Maybe ContainerClassCompositeNameFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
    -> IO (FunPtr C_ContainerClassCompositeNameFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    872) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassCompositeNameFieldCallback
    val' -> do
            let val'' :: ContainerClassCompositeNameFieldCallback
    val'' = FunPtr C_ContainerClassCompositeNameFieldCallback
    -> ContainerClassCompositeNameFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
    FunPtr C_ContainerClassCompositeNameFieldCallback
    -> a -> b -> m Text
    Gtk.Callbacks.dynamic_ContainerClassCompositeNameFieldCallback FunPtr C_ContainerClassCompositeNameFieldCallback
    val'
            ContainerClassCompositeNameFieldCallback
    -> IO ContainerClassCompositeNameFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassCompositeNameFieldCallback
    val''
        return result

    -- | Set the value of the “@composite_name@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #compositeName 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassCompositeName :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback -> m ()
    setContainerClassCompositeName :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> FunPtr C_ContainerClassCompositeNameFieldCallback -> m ()
    setContainerClassCompositeName ContainerClass
    s FunPtr C_ContainerClassCompositeNameFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
    -> FunPtr C_ContainerClassCompositeNameFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    872) (FunPtr C_ContainerClassCompositeNameFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassCompositeNameFieldInfo
    instance AttrInfo ContainerClassCompositeNameFieldInfo where
        type AttrBaseTypeConstraint ContainerClassCompositeNameFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassCompositeNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassCompositeNameFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
        type AttrTransferTypeConstraint ContainerClassCompositeNameFieldInfo = (~)Gtk.Callbacks.ContainerClassCompositeNameFieldCallback
        type AttrTransferType ContainerClassCompositeNameFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
        type AttrGetType ContainerClassCompositeNameFieldInfo = Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback
        type AttrLabel ContainerClassCompositeNameFieldInfo = "composite_name"
        type AttrOrigin ContainerClassCompositeNameFieldInfo = ContainerClass
        attrGet = getContainerClassCompositeName
        attrSet = setContainerClassCompositeName
        attrConstruct = undefined
        attrClear = clearContainerClassCompositeName
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassCompositeNameFieldCallback (Gtk.Callbacks.wrap_ContainerClassCompositeNameFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.compositeName"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:compositeName"
            })

    containerClass_compositeName :: AttrLabelProxy "compositeName"
    containerClass_compositeName = AttrLabelProxy

    #endif

    -- | Get the value of the “@set_child_property@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #setChildProperty
    -- @
    getContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback)
    getContainerClassSetChildProperty :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> m (Maybe ContainerClassSetChildPropertyFieldCallback)
    getContainerClassSetChildProperty ContainerClass
    s = IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    -> m (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassSetChildPropertyFieldCallback)
     -> m (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    -> m (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
     -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int
    -> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    880) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val' -> do
            let val'' :: ContainerClassSetChildPropertyFieldCallback
    val'' = FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> ContainerClassSetChildPropertyFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
    FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()
    Gtk.Callbacks.dynamic_ContainerClassSetChildPropertyFieldCallback FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val'
            ContainerClassSetChildPropertyFieldCallback
    -> IO ContainerClassSetChildPropertyFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassSetChildPropertyFieldCallback
    val''
        return result

    -- | Set the value of the “@set_child_property@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #setChildProperty 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassSetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback -> m ()
    setContainerClassSetChildProperty :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()
    setContainerClassSetChildProperty ContainerClass
    s FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    -> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int
    -> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    880) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassSetChildPropertyFieldInfo
    instance AttrInfo ContainerClassSetChildPropertyFieldInfo where
        type AttrBaseTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassSetChildPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
        type AttrTransferTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~)Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback
        type AttrTransferType ContainerClassSetChildPropertyFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
        type AttrGetType ContainerClassSetChildPropertyFieldInfo = Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback
        type AttrLabel ContainerClassSetChildPropertyFieldInfo = "set_child_property"
        type AttrOrigin ContainerClassSetChildPropertyFieldInfo = ContainerClass
        attrGet = getContainerClassSetChildProperty
        attrSet = setContainerClassSetChildProperty
        attrConstruct = undefined
        attrClear = clearContainerClassSetChildProperty
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassSetChildPropertyFieldCallback (Gtk.Callbacks.wrap_ContainerClassSetChildPropertyFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.setChildProperty"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:setChildProperty"
            })

    containerClass_setChildProperty :: AttrLabelProxy "setChildProperty"
    containerClass_setChildProperty = AttrLabelProxy

    #endif

    -- | Get the value of the “@get_child_property@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #getChildProperty
    -- @
    getContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback)
    getContainerClassGetChildProperty :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> m (Maybe ContainerClassSetChildPropertyFieldCallback)
    getContainerClassGetChildProperty ContainerClass
    s = IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    -> m (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassSetChildPropertyFieldCallback)
     -> m (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    -> m (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
     -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int
    -> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    888) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val' -> do
            let val'' :: ContainerClassSetChildPropertyFieldCallback
    val'' = FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> ContainerClassSetChildPropertyFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
    FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()
    Gtk.Callbacks.dynamic_ContainerClassGetChildPropertyFieldCallback FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val'
            ContainerClassSetChildPropertyFieldCallback
    -> IO ContainerClassSetChildPropertyFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassSetChildPropertyFieldCallback
    val''
        return result

    -- | Set the value of the “@get_child_property@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #getChildProperty 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassGetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback -> m ()
    setContainerClassGetChildProperty :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()
    setContainerClassGetChildProperty ContainerClass
    s FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    -> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int
    -> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    888) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassGetChildPropertyFieldInfo
    instance AttrInfo ContainerClassGetChildPropertyFieldInfo where
        type AttrBaseTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassGetChildPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
        type AttrTransferTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~)Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback
        type AttrTransferType ContainerClassGetChildPropertyFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
        type AttrGetType ContainerClassGetChildPropertyFieldInfo = Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback
        type AttrLabel ContainerClassGetChildPropertyFieldInfo = "get_child_property"
        type AttrOrigin ContainerClassGetChildPropertyFieldInfo = ContainerClass
        attrGet = getContainerClassGetChildProperty
        attrSet = setContainerClassGetChildProperty
        attrConstruct = undefined
        attrClear = clearContainerClassGetChildProperty
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassGetChildPropertyFieldCallback (Gtk.Callbacks.wrap_ContainerClassGetChildPropertyFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.getChildProperty"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:getChildProperty"
            })

    containerClass_getChildProperty :: AttrLabelProxy "getChildProperty"
    containerClass_getChildProperty = AttrLabelProxy

    #endif

    -- | Get the value of the “@get_path_for_child@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' containerClass #getPathForChild
    -- @
    getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback)
    getContainerClassGetPathForChild :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> m (Maybe ContainerClassGetPathForChildFieldCallback)
    getContainerClassGetPathForChild ContainerClass
    s = IO (Maybe ContainerClassGetPathForChildFieldCallback)
    -> m (Maybe ContainerClassGetPathForChildFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ContainerClassGetPathForChildFieldCallback)
     -> m (Maybe ContainerClassGetPathForChildFieldCallback))
    -> IO (Maybe ContainerClassGetPathForChildFieldCallback)
    -> m (Maybe ContainerClassGetPathForChildFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ ContainerClass
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
    -> IO (Maybe ContainerClassGetPathForChildFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass
      -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
     -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
    -> (Ptr ContainerClass
        -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
    -> IO (Maybe ContainerClassGetPathForChildFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        val <- Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
    -> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    896) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ContainerClassGetPathForChildFieldCallback
    val' -> do
            let val'' :: ContainerClassGetPathForChildFieldCallback
    val'' = FunPtr C_ContainerClassGetPathForChildFieldCallback
    -> ContainerClassGetPathForChildFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
    FunPtr C_ContainerClassGetPathForChildFieldCallback
    -> a -> b -> m WidgetPath
    Gtk.Callbacks.dynamic_ContainerClassGetPathForChildFieldCallback FunPtr C_ContainerClassGetPathForChildFieldCallback
    val'
            ContainerClassGetPathForChildFieldCallback
    -> IO ContainerClassGetPathForChildFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ContainerClassGetPathForChildFieldCallback
    val''
        return result

    -- | Set the value of the “@get_path_for_child@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' containerClass [ #getPathForChild 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback -> m ()
    setContainerClassGetPathForChild :: forall (m :: * -> *).
    MonadIO m =>
    ContainerClass
    -> FunPtr C_ContainerClassGetPathForChildFieldCallback -> m ()
    setContainerClassGetPathForChild ContainerClass
    s FunPtr C_ContainerClassGetPathForChildFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ContainerClass
    s ((Ptr ContainerClass -> IO ()) -> IO ())
    -> (Ptr ContainerClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ContainerClass
    ptr -> do
        Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
    -> FunPtr C_ContainerClassGetPathForChildFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ContainerClass
    ptr Ptr ContainerClass
    -> Int -> Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    896) (FunPtr C_ContainerClassGetPathForChildFieldCallback
    val :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)

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

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassGetPathForChildFieldInfo
    instance AttrInfo ContainerClassGetPathForChildFieldInfo where
        type AttrBaseTypeConstraint ContainerClassGetPathForChildFieldInfo = (~) ContainerClass
        type AttrAllowedOps ContainerClassGetPathForChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ContainerClassGetPathForChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
        type AttrTransferTypeConstraint ContainerClassGetPathForChildFieldInfo = (~)Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback
        type AttrTransferType ContainerClassGetPathForChildFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
        type AttrGetType ContainerClassGetPathForChildFieldInfo = Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback
        type AttrLabel ContainerClassGetPathForChildFieldInfo = "get_path_for_child"
        type AttrOrigin ContainerClassGetPathForChildFieldInfo = ContainerClass
        attrGet = getContainerClassGetPathForChild
        attrSet = setContainerClassGetPathForChild
        attrConstruct = undefined
        attrClear = clearContainerClassGetPathForChild
        attrTransfer _ v = do
            Gtk.Callbacks.mk_ContainerClassGetPathForChildFieldCallback (Gtk.Callbacks.wrap_ContainerClassGetPathForChildFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.getPathForChild"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:getPathForChild"
            })

    containerClass_getPathForChild :: AttrLabelProxy "getPathForChild"
    containerClass_getPathForChild = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList ContainerClass
    type instance O.AttributeList ContainerClass = ContainerClassAttributeList
    type ContainerClassAttributeList = ('[ '("parentClass", ContainerClassParentClassFieldInfo), '("add", ContainerClassAddFieldInfo), '("remove", ContainerClassRemoveFieldInfo), '("checkResize", ContainerClassCheckResizeFieldInfo), '("forall", ContainerClassForallFieldInfo), '("setFocusChild", ContainerClassSetFocusChildFieldInfo), '("childType", ContainerClassChildTypeFieldInfo), '("compositeName", ContainerClassCompositeNameFieldInfo), '("setChildProperty", ContainerClassSetChildPropertyFieldInfo), '("getChildProperty", ContainerClassGetChildPropertyFieldInfo), '("getPathForChild", ContainerClassGetPathForChildFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    -- method ContainerClass::find_child_property
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cclass"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ContainerClass" }
    --           , argCType = Just "GObjectClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkContainerClass"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const gchar*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the child property to find"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just TParamSpec
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_container_class_find_child_property" gtk_container_class_find_child_property ::
        Ptr ContainerClass ->                   -- cclass : TInterface (Name {namespace = "Gtk", name = "ContainerClass"})
        CString ->                              -- property_name : TBasicType TUTF8
        IO (Ptr GParamSpec)

    -- | Finds a child property of a container class by name.
    containerClassFindChildProperty ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        ContainerClass
        -- ^ /@cclass@/: a t'GI.Gtk.Structs.ContainerClass.ContainerClass'
        -> T.Text
        -- ^ /@propertyName@/: the name of the child property to find
        -> m (Maybe GParamSpec)
        -- ^ __Returns:__ the t'GI.GObject.Objects.ParamSpec.ParamSpec' of the child
        --     property or 'P.Nothing' if /@class@/ has no child property with that
        --     name.
    containerClassFindChildProperty :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    ContainerClass -> Text -> m (Maybe GParamSpec)
    containerClassFindChildProperty ContainerClass
    cclass Text
    propertyName = IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GParamSpec) -> m (Maybe GParamSpec))
    -> IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
    forall a b. (a -> b) -> a -> b
    $ do
        cclass' <- ContainerClass -> IO (Ptr ContainerClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr ContainerClass
    cclass
        propertyName' <- textToCString propertyName
        result <- gtk_container_class_find_child_property cclass' propertyName'
        maybeResult <- convertIfNonNull result $ \Ptr GParamSpec
    result' -> do
            result'' <- Ptr GParamSpec -> IO GParamSpec
    B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
    result'
            return result''
        touchManagedPtr cclass
        freeMem propertyName'
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassFindChildPropertyMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GParamSpec)), MonadIO m) => O.OverloadedMethod ContainerClassFindChildPropertyMethodInfo ContainerClass signature where
        overloadedMethod = containerClassFindChildProperty

    instance O.OverloadedMethodInfo ContainerClassFindChildPropertyMethodInfo ContainerClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.containerClassFindChildProperty",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#v:containerClassFindChildProperty"
            })

    #endif

    -- method ContainerClass::handle_border_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "klass"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ContainerClass" }
    --           , argCType = Just "GtkContainerClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the class struct of a #GtkContainer subclass"
    --                 , 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_container_class_handle_border_width" gtk_container_class_handle_border_width ::
        Ptr ContainerClass ->                   -- klass : TInterface (Name {namespace = "Gtk", name = "ContainerClass"})
        IO ()

    -- | Modifies a subclass of t'GI.Gtk.Structs.ContainerClass.ContainerClass' to automatically add and
    -- remove the border-width setting on GtkContainer.  This allows the
    -- subclass to ignore the border width in its size request and
    -- allocate methods. The intent is for a subclass to invoke this
    -- in its class_init function.
    --
    -- 'GI.Gtk.Structs.ContainerClass.containerClassHandleBorderWidth' is necessary because it
    -- would break API too badly to make this behavior the default. So
    -- subclasses must “opt in” to the parent class handling border_width
    -- for them.
    containerClassHandleBorderWidth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        ContainerClass
        -- ^ /@klass@/: the class struct of a t'GI.Gtk.Objects.Container.Container' subclass
        -> m ()
    containerClassHandleBorderWidth :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    ContainerClass -> m ()
    containerClassHandleBorderWidth ContainerClass
    klass = 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
        klass' <- ContainerClass -> IO (Ptr ContainerClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr ContainerClass
    klass
        gtk_container_class_handle_border_width klass'
        touchManagedPtr klass
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassHandleBorderWidthMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ContainerClassHandleBorderWidthMethodInfo ContainerClass signature where
        overloadedMethod = containerClassHandleBorderWidth

    instance O.OverloadedMethodInfo ContainerClassHandleBorderWidthMethodInfo ContainerClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.containerClassHandleBorderWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#v:containerClassHandleBorderWidth"
            })

    #endif

    -- XXX Could not generate method ContainerClass::install_child_properties
    -- Not implemented: Don't know how to pack C array of type TCArray False (-1) 1 TParamSpec
    -- method ContainerClass::install_child_property
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cclass"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ContainerClass" }
    --           , argCType = Just "GtkContainerClass*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkContainerClass"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property_id"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the id for the property"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pspec"
    --           , argType = TParamSpec
    --           , argCType = Just "GParamSpec*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GParamSpec for the property"
    --                 , 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_container_class_install_child_property" gtk_container_class_install_child_property ::
        Ptr ContainerClass ->                   -- cclass : TInterface (Name {namespace = "Gtk", name = "ContainerClass"})
        Word32 ->                               -- property_id : TBasicType TUInt
        Ptr GParamSpec ->                       -- pspec : TParamSpec
        IO ()

    -- | Installs a child property on a container class.
    containerClassInstallChildProperty ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        ContainerClass
        -- ^ /@cclass@/: a t'GI.Gtk.Structs.ContainerClass.ContainerClass'
        -> Word32
        -- ^ /@propertyId@/: the id for the property
        -> GParamSpec
        -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the property
        -> m ()
    containerClassInstallChildProperty :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    ContainerClass -> Word32 -> GParamSpec -> m ()
    containerClassInstallChildProperty ContainerClass
    cclass Word32
    propertyId GParamSpec
    pspec = 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
        cclass' <- ContainerClass -> IO (Ptr ContainerClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr ContainerClass
    cclass
        pspec' <- unsafeManagedPtrGetPtr pspec
        gtk_container_class_install_child_property cclass' propertyId pspec'
        touchManagedPtr cclass
        touchManagedPtr pspec
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ContainerClassInstallChildPropertyMethodInfo
    instance (signature ~ (Word32 -> GParamSpec -> m ()), MonadIO m) => O.OverloadedMethod ContainerClassInstallChildPropertyMethodInfo ContainerClass signature where
        overloadedMethod = containerClassInstallChildProperty

    instance O.OverloadedMethodInfo ContainerClassInstallChildPropertyMethodInfo ContainerClass where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.containerClassInstallChildProperty",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-ContainerClass.html#v:containerClassInstallChildProperty"
            })

    #endif

    -- XXX Could not generate method ContainerClass::list_child_properties
    -- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
    #if defined(ENABLE_OVERLOADING)
    type family ResolveContainerClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveContainerClassMethod "findChildProperty" o = ContainerClassFindChildPropertyMethodInfo
        ResolveContainerClassMethod "handleBorderWidth" o = ContainerClassHandleBorderWidthMethodInfo
        ResolveContainerClassMethod "installChildProperty" o = ContainerClassInstallChildPropertyMethodInfo
        ResolveContainerClassMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif