    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- @GInitable@ is implemented by objects that can fail during
    -- initialization. If an object implements this interface then
    -- it must be initialized as the first thing after construction,
    -- either via 'GI.Gio.Interfaces.Initable.initableInit' or 'GI.Gio.Interfaces.AsyncInitable.asyncInitableInitAsync'
    -- (the latter is only available if it also implements t'GI.Gio.Interfaces.AsyncInitable.AsyncInitable').
    --
    -- If the object is not initialized, or initialization returns with an
    -- error, then all operations on the object except @g_object_ref()@ and
    -- @g_object_unref()@ are considered to be invalid, and have undefined
    -- behaviour. They will often fail with @/GLib.critical/@ or
    -- @/GLib.warning/@, but this must not be relied on.
    --
    -- Users of objects implementing this are not intended to use
    -- the interface method directly, instead it will be used automatically
    -- in various ways. For C applications you generally just call
    -- [func/@gio@/.Initable.new] directly, or indirectly via a @foo_thing_new()@ wrapper.
    -- This will call 'GI.Gio.Interfaces.Initable.initableInit' under the cover, returning @NULL@
    -- and setting a @GError@ on failure (at which point the instance is
    -- unreferenced).
    --
    -- For bindings in languages where the native constructor supports
    -- exceptions the binding could check for objects implementing @GInitable@
    -- during normal construction and automatically initialize them, throwing
    -- an exception on failure.
    --
    -- /Since: 2.22/

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

    module GI.Gio.Interfaces.Initable
        (

    -- * Exported types
        Initable(..)                            ,
        IsInitable                              ,
        toInitable                              ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [init]("GI.Gio.Interfaces.Initable#g:method:init"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveInitableMethod                   ,
    #endif

    -- ** init #method:init#

    #if defined(ENABLE_OVERLOADING)
        InitableInitMethodInfo                  ,
    #endif
        initableInit                            ,

    -- ** newv #method:newv#

        initableNewv                            ,

        ) 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 GI.GObject.Objects.Object as GObject.Object
    import qualified GI.GObject.Structs.Parameter as GObject.Parameter
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable

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

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

    foreign import ccall "g_initable_get_type"
        c_g_initable_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Initable where
        glibType :: IO GType
    glibType = IO GType
    c_g_initable_get_type

    instance B.Types.GObject Initable

    -- | Type class for types which can be safely cast to `Initable`, for instance with `toInitable`.
    class (SP.GObject o, O.IsDescendantOf Initable o) => IsInitable o
    instance (SP.GObject o, O.IsDescendantOf Initable o) => IsInitable o

    instance O.HasParentTypes Initable
    type instance O.ParentTypes Initable = '[GObject.Object.Object]

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

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Initable
    type instance O.AttributeList Initable = InitableAttributeList
    type InitableAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveInitableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveInitableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveInitableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveInitableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveInitableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveInitableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveInitableMethod "init" o = InitableInitMethodInfo
        ResolveInitableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveInitableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveInitableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveInitableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveInitableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveInitableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveInitableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveInitableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveInitableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveInitableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveInitableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveInitableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveInitableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveInitableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveInitableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveInitableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveInitableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveInitableMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- method Initable::init
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "initable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Initable" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GInitable." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_initable_init" g_initable_init ::
        Ptr Initable ->                         -- initable : TInterface (Name {namespace = "Gio", name = "Initable"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Initializes the object implementing the interface.
    --
    -- This method is intended for language bindings. If writing in C,
    -- @/g_initable_new()/@ should typically be used instead.
    --
    -- The object must be initialized before any real use after initial
    -- construction, either with this function or 'GI.Gio.Interfaces.AsyncInitable.asyncInitableInitAsync'.
    --
    -- Implementations may also support cancellation. If /@cancellable@/ is not 'P.Nothing',
    -- then initialization can be cancelled by triggering the cancellable object
    -- from another thread. If the operation was cancelled, the error
    -- 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned. If /@cancellable@/ is not 'P.Nothing' and
    -- the object doesn\'t support cancellable initialization the error
    -- 'GI.Gio.Enums.IOErrorEnumNotSupported' will be returned.
    --
    -- If the object is not initialized, or initialization returns with an
    -- error, then all operations on the object except 'GI.GObject.Objects.Object.objectRef' and
    -- 'GI.GObject.Objects.Object.objectUnref' are considered to be invalid, and have undefined
    -- behaviour. See the [introduction][ginitable] for more details.
    --
    -- Callers should not assume that a class which implements t'GI.Gio.Interfaces.Initable.Initable' can be
    -- initialized multiple times, unless the class explicitly documents itself as
    -- supporting this. Generally, a class’ implementation of @/init()/@ can assume
    -- (and assert) that it will only be called once. Previously, this documentation
    -- recommended all t'GI.Gio.Interfaces.Initable.Initable' implementations should be idempotent; that
    -- recommendation was relaxed in GLib 2.54.
    --
    -- If a class explicitly supports being initialized multiple times, it is
    -- recommended that the method is idempotent: multiple calls with the same
    -- arguments should return the same results. Only the first call initializes
    -- the object; further calls return the result of the first call.
    --
    -- One reason why a class might need to support idempotent initialization is if
    -- it is designed to be used via the singleton pattern, with a
    -- t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/constructor/@ that sometimes returns an existing instance.
    -- In this pattern, a caller would expect to be able to call 'GI.Gio.Interfaces.Initable.initableInit'
    -- on the result of @/g_object_new()/@, regardless of whether it is in fact a new
    -- instance.
    --
    -- /Since: 2.22/
    initableInit ::
        (B.CallStack.HasCallStack, MonadIO m, IsInitable a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@initable@/: a t'GI.Gio.Interfaces.Initable.Initable'.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    initableInit :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInitable a, IsCancellable b) =>
    a -> Maybe b -> m ()
    initableInit a
    initable Maybe b
    cancellable = 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
        Ptr Initable
    initable' <- a -> IO (Ptr Initable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    initable
        Ptr Cancellable
    maybeCancellable <- case Maybe b
    cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just b
    jCancellable -> do
                Ptr Cancellable
    jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCancellable'
        IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO a
    onException (do
            CInt
    _ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
    -> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ Ptr Initable -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
    g_initable_init Ptr Initable
    initable' Ptr Cancellable
    maybeCancellable
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    initable
            Maybe b -> (b -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe b
    cancellable b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
            () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         ) (do
            () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data InitableInitMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsInitable a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InitableInitMethodInfo a signature where
        overloadedMethod = initableInit

    instance O.OverloadedMethodInfo InitableInitMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Interfaces.Initable.initableInit",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Interfaces-Initable.html#v:initableInit"
            })

    #endif

    -- method Initable::newv
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "object_type"
    --           , argType = TBasicType TGType
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GType supporting #GInitable."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_parameters"
    --           , argType = TBasicType TUInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of parameters in @parameters"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "parameters"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 1
    --                 (TInterface Name { namespace = "GObject" , name = "Parameter" })
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the parameters to use to construct the object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_parameters"
    --              , argType = TBasicType TUInt
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of parameters in @parameters"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_initable_newv" g_initable_newv ::
        CGType ->                               -- object_type : TBasicType TGType
        Word32 ->                               -- n_parameters : TBasicType TUInt
        Ptr GObject.Parameter.Parameter ->      -- parameters : TCArray False (-1) 1 (TInterface (Name {namespace = "GObject", name = "Parameter"}))
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr GObject.Object.Object)

    {-# DEPRECATED initableNewv ["(Since version 2.54)","Use @/g_object_new_with_properties()/@ and","'GI.Gio.Interfaces.Initable.initableInit' instead. See t'GI.GObject.Structs.Parameter.Parameter' for more information."] #-}
    -- | Helper function for constructing t'GI.Gio.Interfaces.Initable.Initable' object. This is
    -- similar to 'GI.GObject.Objects.Object.objectNewv' but also initializes the object
    -- and returns 'P.Nothing', setting an error on failure.
    --
    -- /Since: 2.22/
    initableNewv ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
        GType
        -- ^ /@objectType@/: a t'GType' supporting t'GI.Gio.Interfaces.Initable.Initable'.
        -> [GObject.Parameter.Parameter]
        -- ^ /@parameters@/: the parameters to use to construct the object
        -> Maybe (a)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> m GObject.Object.Object
        -- ^ __Returns:__ a newly allocated
        --      t'GI.GObject.Objects.Object.Object', or 'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
    initableNewv :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCancellable a) =>
    GType -> [Parameter] -> Maybe a -> m Object
    initableNewv GType
    objectType [Parameter]
    parameters Maybe a
    cancellable = IO Object -> m Object
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Object -> m Object) -> IO Object -> m Object
    forall a b. (a -> b) -> a -> b
    $ do
        let nParameters :: Word32
    nParameters = Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word32) -> Int -> Word32
    forall a b. (a -> b) -> a -> b
    $ [Parameter] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [Parameter]
    parameters
        let objectType' :: CGType
    objectType' = GType -> CGType
    gtypeToCGType GType
    objectType
        [Ptr Parameter]
    parameters' <- (Parameter -> IO (Ptr Parameter))
    -> [Parameter] -> IO [Ptr Parameter]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Parameter -> IO (Ptr Parameter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr [Parameter]
    parameters
        Ptr Parameter
    parameters'' <- Int -> [Ptr Parameter] -> IO (Ptr Parameter)
    forall a. Int -> [Ptr a] -> IO (Ptr a)
    packBlockArray Int
    32 [Ptr Parameter]
    parameters'
        Ptr Cancellable
    maybeCancellable <- case Maybe a
    cancellable of
            Maybe a
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just a
    jCancellable -> do
                Ptr Cancellable
    jCancellable' <- a -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCancellable'
        IO Object -> IO () -> IO Object
    forall a b. IO a -> IO b -> IO a
    onException (do
            Ptr Object
    result <- (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object))
    -> (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
    forall a b. (a -> b) -> a -> b
    $ CGType
    -> Word32
    -> Ptr Parameter
    -> Ptr Cancellable
    -> Ptr (Ptr GError)
    -> IO (Ptr Object)
    g_initable_newv CGType
    objectType' Word32
    nParameters Ptr Parameter
    parameters'' Ptr Cancellable
    maybeCancellable
            Text -> Ptr Object -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "initableNewv" Ptr Object
    result
            Object
    result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Object -> Object
    GObject.Object.Object) Ptr Object
    result
            (Parameter -> IO ()) -> [Parameter] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ Parameter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr [Parameter]
    parameters
            Maybe a -> (a -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe a
    cancellable a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
            Ptr Parameter -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Parameter
    parameters''
            Object -> IO Object
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Object
    result'
         ) (do
            Ptr Parameter -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Parameter
    parameters''
         )

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Initable = InitableSignalList
    type InitableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif