    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The GObjectConstructParam struct is an auxiliary structure used to hand
    -- t'GI.GObject.Objects.ParamSpec.ParamSpec'\/t'GI.GObject.Structs.Value.Value' pairs to the /@constructor@/ of a t'GI.GObject.Structs.ObjectClass.ObjectClass'.

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

    module GI.GObject.Structs.ObjectConstructParam
        (

    -- * Exported types
        ObjectConstructParam(..)                ,
        newZeroObjectConstructParam             ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveObjectConstructParamMethod       ,
    #endif

     -- * Properties

    -- ** pspec #attr:pspec#
    -- | the t'GI.GObject.Objects.ParamSpec.ParamSpec' of the construct parameter

        clearObjectConstructParamPspec          ,
        getObjectConstructParamPspec            ,
    #if defined(ENABLE_OVERLOADING)
        objectConstructParam_pspec              ,
    #endif
        setObjectConstructParamPspec            ,

    -- ** value #attr:value#
    -- | the value to set the parameter to

        clearObjectConstructParamValue          ,
        getObjectConstructParamValue            ,
    #if defined(ENABLE_OVERLOADING)
        objectConstructParam_value              ,
    #endif
        setObjectConstructParamValue            ,

        ) 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)

    #else

    #endif

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

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

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

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

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

    -- | Get the value of the “@pspec@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' objectConstructParam #pspec
    -- @
    getObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m (Maybe GParamSpec)
    getObjectConstructParamPspec :: forall (m :: * -> *).
    MonadIO m =>
    ObjectConstructParam -> m (Maybe GParamSpec)
    getObjectConstructParamPspec ObjectConstructParam
    s = 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
    $ ObjectConstructParam
    -> (Ptr ObjectConstructParam -> IO (Maybe GParamSpec))
    -> IO (Maybe GParamSpec)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ObjectConstructParam
    s ((Ptr ObjectConstructParam -> IO (Maybe GParamSpec))
     -> IO (Maybe GParamSpec))
    -> (Ptr ObjectConstructParam -> IO (Maybe GParamSpec))
    -> IO (Maybe GParamSpec)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ObjectConstructParam
    ptr -> do
        val <- Ptr (Ptr GParamSpec) -> IO (Ptr GParamSpec)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ObjectConstructParam
    ptr Ptr ObjectConstructParam -> Int -> Ptr (Ptr GParamSpec)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO (Ptr GParamSpec)
        result <- SP.convertIfNonNull val $ \Ptr GParamSpec
    val' -> do
            val'' <- Ptr GParamSpec -> IO GParamSpec
    B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
    val'
            return val''
        return result

    -- | Set the value of the “@pspec@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' objectConstructParam [ #pspec 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> Ptr GParamSpec -> m ()
    setObjectConstructParamPspec :: forall (m :: * -> *).
    MonadIO m =>
    ObjectConstructParam -> Ptr GParamSpec -> m ()
    setObjectConstructParamPspec ObjectConstructParam
    s Ptr GParamSpec
    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
    $ ObjectConstructParam
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ObjectConstructParam
    s ((Ptr ObjectConstructParam -> IO ()) -> IO ())
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ObjectConstructParam
    ptr -> do
        Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ObjectConstructParam
    ptr Ptr ObjectConstructParam -> Int -> Ptr (Ptr GParamSpec)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr GParamSpec
    val :: Ptr GParamSpec)

    -- | Set the value of the “@pspec@” 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' #pspec
    -- @
    clearObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m ()
    clearObjectConstructParamPspec :: forall (m :: * -> *). MonadIO m => ObjectConstructParam -> m ()
    clearObjectConstructParamPspec ObjectConstructParam
    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
    $ ObjectConstructParam
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ObjectConstructParam
    s ((Ptr ObjectConstructParam -> IO ()) -> IO ())
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ObjectConstructParam
    ptr -> do
        Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ObjectConstructParam
    ptr Ptr ObjectConstructParam -> Int -> Ptr (Ptr GParamSpec)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr GParamSpec
    forall a. Ptr a
    FP.nullPtr :: Ptr GParamSpec)

    #if defined(ENABLE_OVERLOADING)
    data ObjectConstructParamPspecFieldInfo
    instance AttrInfo ObjectConstructParamPspecFieldInfo where
        type AttrBaseTypeConstraint ObjectConstructParamPspecFieldInfo = (~) ObjectConstructParam
        type AttrAllowedOps ObjectConstructParamPspecFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectConstructParamPspecFieldInfo = (~) (Ptr GParamSpec)
        type AttrTransferTypeConstraint ObjectConstructParamPspecFieldInfo = (~)(Ptr GParamSpec)
        type AttrTransferType ObjectConstructParamPspecFieldInfo = (Ptr GParamSpec)
        type AttrGetType ObjectConstructParamPspecFieldInfo = Maybe GParamSpec
        type AttrLabel ObjectConstructParamPspecFieldInfo = "pspec"
        type AttrOrigin ObjectConstructParamPspecFieldInfo = ObjectConstructParam
        attrGet = getObjectConstructParamPspec
        attrSet = setObjectConstructParamPspec
        attrConstruct = undefined
        attrClear = clearObjectConstructParamPspec
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.ObjectConstructParam.pspec"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-ObjectConstructParam.html#g:attr:pspec"
            })

    objectConstructParam_pspec :: AttrLabelProxy "pspec"
    objectConstructParam_pspec = AttrLabelProxy

    #endif

    -- | Get the value of the “@value@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' objectConstructParam #value
    -- @
    getObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m (Maybe GValue)
    getObjectConstructParamValue :: forall (m :: * -> *).
    MonadIO m =>
    ObjectConstructParam -> m (Maybe GValue)
    getObjectConstructParamValue ObjectConstructParam
    s = IO (Maybe GValue) -> m (Maybe GValue)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GValue) -> m (Maybe GValue))
    -> IO (Maybe GValue) -> m (Maybe GValue)
    forall a b. (a -> b) -> a -> b
    $ ObjectConstructParam
    -> (Ptr ObjectConstructParam -> IO (Maybe GValue))
    -> IO (Maybe GValue)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ObjectConstructParam
    s ((Ptr ObjectConstructParam -> IO (Maybe GValue))
     -> IO (Maybe GValue))
    -> (Ptr ObjectConstructParam -> IO (Maybe GValue))
    -> IO (Maybe GValue)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ObjectConstructParam
    ptr -> do
        val <- Ptr (Ptr GValue) -> IO (Ptr GValue)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ObjectConstructParam
    ptr Ptr ObjectConstructParam -> Int -> Ptr (Ptr GValue)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO (Ptr GValue)
        result <- SP.convertIfNonNull val $ \Ptr GValue
    val' -> do
            val'' <- Ptr GValue -> IO GValue
    B.GValue.newGValueFromPtr Ptr GValue
    val'
            return val''
        return result

    -- | Set the value of the “@value@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' objectConstructParam [ #value 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> Ptr GValue -> m ()
    setObjectConstructParamValue :: forall (m :: * -> *).
    MonadIO m =>
    ObjectConstructParam -> Ptr GValue -> m ()
    setObjectConstructParamValue ObjectConstructParam
    s Ptr GValue
    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
    $ ObjectConstructParam
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ObjectConstructParam
    s ((Ptr ObjectConstructParam -> IO ()) -> IO ())
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ObjectConstructParam
    ptr -> do
        Ptr (Ptr GValue) -> Ptr GValue -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ObjectConstructParam
    ptr Ptr ObjectConstructParam -> Int -> Ptr (Ptr GValue)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (Ptr GValue
    val :: Ptr GValue)

    -- | Set the value of the “@value@” 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' #value
    -- @
    clearObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m ()
    clearObjectConstructParamValue :: forall (m :: * -> *). MonadIO m => ObjectConstructParam -> m ()
    clearObjectConstructParamValue ObjectConstructParam
    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
    $ ObjectConstructParam
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ObjectConstructParam
    s ((Ptr ObjectConstructParam -> IO ()) -> IO ())
    -> (Ptr ObjectConstructParam -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ObjectConstructParam
    ptr -> do
        Ptr (Ptr GValue) -> Ptr GValue -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ObjectConstructParam
    ptr Ptr ObjectConstructParam -> Int -> Ptr (Ptr GValue)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (Ptr GValue
    forall a. Ptr a
    FP.nullPtr :: Ptr GValue)

    #if defined(ENABLE_OVERLOADING)
    data ObjectConstructParamValueFieldInfo
    instance AttrInfo ObjectConstructParamValueFieldInfo where
        type AttrBaseTypeConstraint ObjectConstructParamValueFieldInfo = (~) ObjectConstructParam
        type AttrAllowedOps ObjectConstructParamValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ObjectConstructParamValueFieldInfo = (~) (Ptr GValue)
        type AttrTransferTypeConstraint ObjectConstructParamValueFieldInfo = (~)(Ptr GValue)
        type AttrTransferType ObjectConstructParamValueFieldInfo = (Ptr GValue)
        type AttrGetType ObjectConstructParamValueFieldInfo = Maybe GValue
        type AttrLabel ObjectConstructParamValueFieldInfo = "value"
        type AttrOrigin ObjectConstructParamValueFieldInfo = ObjectConstructParam
        attrGet = getObjectConstructParamValue
        attrSet = setObjectConstructParamValue
        attrConstruct = undefined
        attrClear = clearObjectConstructParamValue
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.ObjectConstructParam.value"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-ObjectConstructParam.html#g:attr:value"
            })

    objectConstructParam_value :: AttrLabelProxy "value"
    objectConstructParam_value = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList ObjectConstructParam
    type instance O.AttributeList ObjectConstructParam = ObjectConstructParamAttributeList
    type ObjectConstructParamAttributeList = ('[ '("pspec", ObjectConstructParamPspecFieldInfo), '("value", ObjectConstructParamValueFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveObjectConstructParamMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveObjectConstructParamMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif