{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

Stores an argument of varying type
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.GIRepository.Unions.Argument
    ( 

-- * Exported types
    Argument(..)                            ,
    newZeroArgument                         ,
    noArgument                              ,


 -- * Properties
-- ** vBoolean #attr:vBoolean#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vBoolean                       ,
#endif
    getArgumentVBoolean                     ,
    setArgumentVBoolean                     ,


-- ** vDouble #attr:vDouble#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vDouble                        ,
#endif
    getArgumentVDouble                      ,
    setArgumentVDouble                      ,


-- ** vFloat #attr:vFloat#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vFloat                         ,
#endif
    getArgumentVFloat                       ,
    setArgumentVFloat                       ,


-- ** vInt #attr:vInt#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vInt                           ,
#endif
    getArgumentVInt                         ,
    setArgumentVInt                         ,


-- ** vInt16 #attr:vInt16#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vInt16                         ,
#endif
    getArgumentVInt16                       ,
    setArgumentVInt16                       ,


-- ** vInt32 #attr:vInt32#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vInt32                         ,
#endif
    getArgumentVInt32                       ,
    setArgumentVInt32                       ,


-- ** vInt64 #attr:vInt64#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vInt64                         ,
#endif
    getArgumentVInt64                       ,
    setArgumentVInt64                       ,


-- ** vInt8 #attr:vInt8#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vInt8                          ,
#endif
    getArgumentVInt8                        ,
    setArgumentVInt8                        ,


-- ** vLong #attr:vLong#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vLong                          ,
#endif
    getArgumentVLong                        ,
    setArgumentVLong                        ,


-- ** vPointer #attr:vPointer#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vPointer                       ,
#endif
    clearArgumentVPointer                   ,
    getArgumentVPointer                     ,
    setArgumentVPointer                     ,


-- ** vShort #attr:vShort#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vShort                         ,
#endif
    getArgumentVShort                       ,
    setArgumentVShort                       ,


-- ** vSize #attr:vSize#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vSize                          ,
#endif
    getArgumentVSize                        ,
    setArgumentVSize                        ,


-- ** vSsize #attr:vSsize#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vSsize                         ,
#endif
    getArgumentVSsize                       ,
    setArgumentVSsize                       ,


-- ** vString #attr:vString#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vString                        ,
#endif
    clearArgumentVString                    ,
    getArgumentVString                      ,
    setArgumentVString                      ,


-- ** vUint #attr:vUint#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUint                          ,
#endif
    getArgumentVUint                        ,
    setArgumentVUint                        ,


-- ** vUint16 #attr:vUint16#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUint16                        ,
#endif
    getArgumentVUint16                      ,
    setArgumentVUint16                      ,


-- ** vUint32 #attr:vUint32#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUint32                        ,
#endif
    getArgumentVUint32                      ,
    setArgumentVUint32                      ,


-- ** vUint64 #attr:vUint64#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUint64                        ,
#endif
    getArgumentVUint64                      ,
    setArgumentVUint64                      ,


-- ** vUint8 #attr:vUint8#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUint8                         ,
#endif
    getArgumentVUint8                       ,
    setArgumentVUint8                       ,


-- ** vUlong #attr:vUlong#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUlong                         ,
#endif
    getArgumentVUlong                       ,
    setArgumentVUlong                       ,


-- ** vUshort #attr:vUshort#
{- | TODO
-}
#if ENABLE_OVERLOADING
    argument_vUshort                        ,
#endif
    getArgumentVUshort                      ,
    setArgumentVUshort                      ,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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.Text as T
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


-- | Memory-managed wrapper type.
newtype Argument = Argument (ManagedPtr Argument)
instance WrappedPtr Argument where
    wrappedPtrCalloc = callocBytes 8
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 8 >=> wrapPtr Argument)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `Argument` struct initialized to zero.
newZeroArgument :: MonadIO m => m Argument
newZeroArgument = liftIO $ wrappedPtrCalloc >>= wrapPtr Argument

instance tag ~ 'AttrSet => Constructible Argument tag where
    new _ attrs = do
        o <- newZeroArgument
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `Argument`.
noArgument :: Maybe Argument
noArgument = Nothing

{- |
Get the value of the “@v_boolean@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vBoolean
@
-}
getArgumentVBoolean :: MonadIO m => Argument -> m Bool
getArgumentVBoolean s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CInt
    let val' = (/= 0) val
    return val'

{- |
Set the value of the “@v_boolean@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vBoolean 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVBoolean :: MonadIO m => Argument -> Bool -> m ()
setArgumentVBoolean s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 0) (val' :: CInt)

#if ENABLE_OVERLOADING
data ArgumentVBooleanFieldInfo
instance AttrInfo ArgumentVBooleanFieldInfo where
    type AttrAllowedOps ArgumentVBooleanFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVBooleanFieldInfo = (~) Bool
    type AttrBaseTypeConstraint ArgumentVBooleanFieldInfo = (~) Argument
    type AttrGetType ArgumentVBooleanFieldInfo = Bool
    type AttrLabel ArgumentVBooleanFieldInfo = "v_boolean"
    type AttrOrigin ArgumentVBooleanFieldInfo = Argument
    attrGet _ = getArgumentVBoolean
    attrSet _ = setArgumentVBoolean
    attrConstruct = undefined
    attrClear _ = undefined

argument_vBoolean :: AttrLabelProxy "vBoolean"
argument_vBoolean = AttrLabelProxy

#endif


{- |
Get the value of the “@v_int8@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vInt8
@
-}
getArgumentVInt8 :: MonadIO m => Argument -> m Int8
getArgumentVInt8 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int8
    return val

{- |
Set the value of the “@v_int8@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vInt8 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVInt8 :: MonadIO m => Argument -> Int8 -> m ()
setArgumentVInt8 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int8)

#if ENABLE_OVERLOADING
data ArgumentVInt8FieldInfo
instance AttrInfo ArgumentVInt8FieldInfo where
    type AttrAllowedOps ArgumentVInt8FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt8FieldInfo = (~) Int8
    type AttrBaseTypeConstraint ArgumentVInt8FieldInfo = (~) Argument
    type AttrGetType ArgumentVInt8FieldInfo = Int8
    type AttrLabel ArgumentVInt8FieldInfo = "v_int8"
    type AttrOrigin ArgumentVInt8FieldInfo = Argument
    attrGet _ = getArgumentVInt8
    attrSet _ = setArgumentVInt8
    attrConstruct = undefined
    attrClear _ = undefined

argument_vInt8 :: AttrLabelProxy "vInt8"
argument_vInt8 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_uint8@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUint8
@
-}
getArgumentVUint8 :: MonadIO m => Argument -> m Word8
getArgumentVUint8 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word8
    return val

{- |
Set the value of the “@v_uint8@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUint8 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUint8 :: MonadIO m => Argument -> Word8 -> m ()
setArgumentVUint8 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word8)

#if ENABLE_OVERLOADING
data ArgumentVUint8FieldInfo
instance AttrInfo ArgumentVUint8FieldInfo where
    type AttrAllowedOps ArgumentVUint8FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint8FieldInfo = (~) Word8
    type AttrBaseTypeConstraint ArgumentVUint8FieldInfo = (~) Argument
    type AttrGetType ArgumentVUint8FieldInfo = Word8
    type AttrLabel ArgumentVUint8FieldInfo = "v_uint8"
    type AttrOrigin ArgumentVUint8FieldInfo = Argument
    attrGet _ = getArgumentVUint8
    attrSet _ = setArgumentVUint8
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUint8 :: AttrLabelProxy "vUint8"
argument_vUint8 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_int16@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vInt16
@
-}
getArgumentVInt16 :: MonadIO m => Argument -> m Int16
getArgumentVInt16 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int16
    return val

{- |
Set the value of the “@v_int16@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vInt16 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVInt16 :: MonadIO m => Argument -> Int16 -> m ()
setArgumentVInt16 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int16)

#if ENABLE_OVERLOADING
data ArgumentVInt16FieldInfo
instance AttrInfo ArgumentVInt16FieldInfo where
    type AttrAllowedOps ArgumentVInt16FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt16FieldInfo = (~) Int16
    type AttrBaseTypeConstraint ArgumentVInt16FieldInfo = (~) Argument
    type AttrGetType ArgumentVInt16FieldInfo = Int16
    type AttrLabel ArgumentVInt16FieldInfo = "v_int16"
    type AttrOrigin ArgumentVInt16FieldInfo = Argument
    attrGet _ = getArgumentVInt16
    attrSet _ = setArgumentVInt16
    attrConstruct = undefined
    attrClear _ = undefined

argument_vInt16 :: AttrLabelProxy "vInt16"
argument_vInt16 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_uint16@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUint16
@
-}
getArgumentVUint16 :: MonadIO m => Argument -> m Word16
getArgumentVUint16 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word16
    return val

{- |
Set the value of the “@v_uint16@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUint16 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUint16 :: MonadIO m => Argument -> Word16 -> m ()
setArgumentVUint16 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word16)

#if ENABLE_OVERLOADING
data ArgumentVUint16FieldInfo
instance AttrInfo ArgumentVUint16FieldInfo where
    type AttrAllowedOps ArgumentVUint16FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint16FieldInfo = (~) Word16
    type AttrBaseTypeConstraint ArgumentVUint16FieldInfo = (~) Argument
    type AttrGetType ArgumentVUint16FieldInfo = Word16
    type AttrLabel ArgumentVUint16FieldInfo = "v_uint16"
    type AttrOrigin ArgumentVUint16FieldInfo = Argument
    attrGet _ = getArgumentVUint16
    attrSet _ = setArgumentVUint16
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUint16 :: AttrLabelProxy "vUint16"
argument_vUint16 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_int32@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vInt32
@
-}
getArgumentVInt32 :: MonadIO m => Argument -> m Int32
getArgumentVInt32 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

{- |
Set the value of the “@v_int32@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vInt32 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVInt32 :: MonadIO m => Argument -> Int32 -> m ()
setArgumentVInt32 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

#if ENABLE_OVERLOADING
data ArgumentVInt32FieldInfo
instance AttrInfo ArgumentVInt32FieldInfo where
    type AttrAllowedOps ArgumentVInt32FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt32FieldInfo = (~) Int32
    type AttrBaseTypeConstraint ArgumentVInt32FieldInfo = (~) Argument
    type AttrGetType ArgumentVInt32FieldInfo = Int32
    type AttrLabel ArgumentVInt32FieldInfo = "v_int32"
    type AttrOrigin ArgumentVInt32FieldInfo = Argument
    attrGet _ = getArgumentVInt32
    attrSet _ = setArgumentVInt32
    attrConstruct = undefined
    attrClear _ = undefined

argument_vInt32 :: AttrLabelProxy "vInt32"
argument_vInt32 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_uint32@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUint32
@
-}
getArgumentVUint32 :: MonadIO m => Argument -> m Word32
getArgumentVUint32 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

{- |
Set the value of the “@v_uint32@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUint32 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUint32 :: MonadIO m => Argument -> Word32 -> m ()
setArgumentVUint32 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if ENABLE_OVERLOADING
data ArgumentVUint32FieldInfo
instance AttrInfo ArgumentVUint32FieldInfo where
    type AttrAllowedOps ArgumentVUint32FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint32FieldInfo = (~) Word32
    type AttrBaseTypeConstraint ArgumentVUint32FieldInfo = (~) Argument
    type AttrGetType ArgumentVUint32FieldInfo = Word32
    type AttrLabel ArgumentVUint32FieldInfo = "v_uint32"
    type AttrOrigin ArgumentVUint32FieldInfo = Argument
    attrGet _ = getArgumentVUint32
    attrSet _ = setArgumentVUint32
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUint32 :: AttrLabelProxy "vUint32"
argument_vUint32 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_int64@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vInt64
@
-}
getArgumentVInt64 :: MonadIO m => Argument -> m Int64
getArgumentVInt64 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int64
    return val

{- |
Set the value of the “@v_int64@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vInt64 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVInt64 :: MonadIO m => Argument -> Int64 -> m ()
setArgumentVInt64 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int64)

#if ENABLE_OVERLOADING
data ArgumentVInt64FieldInfo
instance AttrInfo ArgumentVInt64FieldInfo where
    type AttrAllowedOps ArgumentVInt64FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt64FieldInfo = (~) Int64
    type AttrBaseTypeConstraint ArgumentVInt64FieldInfo = (~) Argument
    type AttrGetType ArgumentVInt64FieldInfo = Int64
    type AttrLabel ArgumentVInt64FieldInfo = "v_int64"
    type AttrOrigin ArgumentVInt64FieldInfo = Argument
    attrGet _ = getArgumentVInt64
    attrSet _ = setArgumentVInt64
    attrConstruct = undefined
    attrClear _ = undefined

argument_vInt64 :: AttrLabelProxy "vInt64"
argument_vInt64 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_uint64@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUint64
@
-}
getArgumentVUint64 :: MonadIO m => Argument -> m Word64
getArgumentVUint64 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

{- |
Set the value of the “@v_uint64@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUint64 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUint64 :: MonadIO m => Argument -> Word64 -> m ()
setArgumentVUint64 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word64)

#if ENABLE_OVERLOADING
data ArgumentVUint64FieldInfo
instance AttrInfo ArgumentVUint64FieldInfo where
    type AttrAllowedOps ArgumentVUint64FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint64FieldInfo = (~) Word64
    type AttrBaseTypeConstraint ArgumentVUint64FieldInfo = (~) Argument
    type AttrGetType ArgumentVUint64FieldInfo = Word64
    type AttrLabel ArgumentVUint64FieldInfo = "v_uint64"
    type AttrOrigin ArgumentVUint64FieldInfo = Argument
    attrGet _ = getArgumentVUint64
    attrSet _ = setArgumentVUint64
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUint64 :: AttrLabelProxy "vUint64"
argument_vUint64 = AttrLabelProxy

#endif


{- |
Get the value of the “@v_float@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vFloat
@
-}
getArgumentVFloat :: MonadIO m => Argument -> m Float
getArgumentVFloat s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CFloat
    let val' = realToFrac val
    return val'

{- |
Set the value of the “@v_float@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vFloat 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVFloat :: MonadIO m => Argument -> Float -> m ()
setArgumentVFloat s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 0) (val' :: CFloat)

#if ENABLE_OVERLOADING
data ArgumentVFloatFieldInfo
instance AttrInfo ArgumentVFloatFieldInfo where
    type AttrAllowedOps ArgumentVFloatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVFloatFieldInfo = (~) Float
    type AttrBaseTypeConstraint ArgumentVFloatFieldInfo = (~) Argument
    type AttrGetType ArgumentVFloatFieldInfo = Float
    type AttrLabel ArgumentVFloatFieldInfo = "v_float"
    type AttrOrigin ArgumentVFloatFieldInfo = Argument
    attrGet _ = getArgumentVFloat
    attrSet _ = setArgumentVFloat
    attrConstruct = undefined
    attrClear _ = undefined

argument_vFloat :: AttrLabelProxy "vFloat"
argument_vFloat = AttrLabelProxy

#endif


{- |
Get the value of the “@v_double@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vDouble
@
-}
getArgumentVDouble :: MonadIO m => Argument -> m Double
getArgumentVDouble s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CDouble
    let val' = realToFrac val
    return val'

{- |
Set the value of the “@v_double@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vDouble 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVDouble :: MonadIO m => Argument -> Double -> m ()
setArgumentVDouble s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 0) (val' :: CDouble)

#if ENABLE_OVERLOADING
data ArgumentVDoubleFieldInfo
instance AttrInfo ArgumentVDoubleFieldInfo where
    type AttrAllowedOps ArgumentVDoubleFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVDoubleFieldInfo = (~) Double
    type AttrBaseTypeConstraint ArgumentVDoubleFieldInfo = (~) Argument
    type AttrGetType ArgumentVDoubleFieldInfo = Double
    type AttrLabel ArgumentVDoubleFieldInfo = "v_double"
    type AttrOrigin ArgumentVDoubleFieldInfo = Argument
    attrGet _ = getArgumentVDouble
    attrSet _ = setArgumentVDouble
    attrConstruct = undefined
    attrClear _ = undefined

argument_vDouble :: AttrLabelProxy "vDouble"
argument_vDouble = AttrLabelProxy

#endif


{- |
Get the value of the “@v_short@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vShort
@
-}
getArgumentVShort :: MonadIO m => Argument -> m Int16
getArgumentVShort s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int16
    return val

{- |
Set the value of the “@v_short@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vShort 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVShort :: MonadIO m => Argument -> Int16 -> m ()
setArgumentVShort s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int16)

#if ENABLE_OVERLOADING
data ArgumentVShortFieldInfo
instance AttrInfo ArgumentVShortFieldInfo where
    type AttrAllowedOps ArgumentVShortFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVShortFieldInfo = (~) Int16
    type AttrBaseTypeConstraint ArgumentVShortFieldInfo = (~) Argument
    type AttrGetType ArgumentVShortFieldInfo = Int16
    type AttrLabel ArgumentVShortFieldInfo = "v_short"
    type AttrOrigin ArgumentVShortFieldInfo = Argument
    attrGet _ = getArgumentVShort
    attrSet _ = setArgumentVShort
    attrConstruct = undefined
    attrClear _ = undefined

argument_vShort :: AttrLabelProxy "vShort"
argument_vShort = AttrLabelProxy

#endif


{- |
Get the value of the “@v_ushort@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUshort
@
-}
getArgumentVUshort :: MonadIO m => Argument -> m Word16
getArgumentVUshort s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word16
    return val

{- |
Set the value of the “@v_ushort@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUshort 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUshort :: MonadIO m => Argument -> Word16 -> m ()
setArgumentVUshort s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word16)

#if ENABLE_OVERLOADING
data ArgumentVUshortFieldInfo
instance AttrInfo ArgumentVUshortFieldInfo where
    type AttrAllowedOps ArgumentVUshortFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUshortFieldInfo = (~) Word16
    type AttrBaseTypeConstraint ArgumentVUshortFieldInfo = (~) Argument
    type AttrGetType ArgumentVUshortFieldInfo = Word16
    type AttrLabel ArgumentVUshortFieldInfo = "v_ushort"
    type AttrOrigin ArgumentVUshortFieldInfo = Argument
    attrGet _ = getArgumentVUshort
    attrSet _ = setArgumentVUshort
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUshort :: AttrLabelProxy "vUshort"
argument_vUshort = AttrLabelProxy

#endif


{- |
Get the value of the “@v_int@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vInt
@
-}
getArgumentVInt :: MonadIO m => Argument -> m Int32
getArgumentVInt s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

{- |
Set the value of the “@v_int@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vInt 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVInt :: MonadIO m => Argument -> Int32 -> m ()
setArgumentVInt s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

#if ENABLE_OVERLOADING
data ArgumentVIntFieldInfo
instance AttrInfo ArgumentVIntFieldInfo where
    type AttrAllowedOps ArgumentVIntFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVIntFieldInfo = (~) Int32
    type AttrBaseTypeConstraint ArgumentVIntFieldInfo = (~) Argument
    type AttrGetType ArgumentVIntFieldInfo = Int32
    type AttrLabel ArgumentVIntFieldInfo = "v_int"
    type AttrOrigin ArgumentVIntFieldInfo = Argument
    attrGet _ = getArgumentVInt
    attrSet _ = setArgumentVInt
    attrConstruct = undefined
    attrClear _ = undefined

argument_vInt :: AttrLabelProxy "vInt"
argument_vInt = AttrLabelProxy

#endif


{- |
Get the value of the “@v_uint@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUint
@
-}
getArgumentVUint :: MonadIO m => Argument -> m Word32
getArgumentVUint s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

{- |
Set the value of the “@v_uint@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUint 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUint :: MonadIO m => Argument -> Word32 -> m ()
setArgumentVUint s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if ENABLE_OVERLOADING
data ArgumentVUintFieldInfo
instance AttrInfo ArgumentVUintFieldInfo where
    type AttrAllowedOps ArgumentVUintFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUintFieldInfo = (~) Word32
    type AttrBaseTypeConstraint ArgumentVUintFieldInfo = (~) Argument
    type AttrGetType ArgumentVUintFieldInfo = Word32
    type AttrLabel ArgumentVUintFieldInfo = "v_uint"
    type AttrOrigin ArgumentVUintFieldInfo = Argument
    attrGet _ = getArgumentVUint
    attrSet _ = setArgumentVUint
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUint :: AttrLabelProxy "vUint"
argument_vUint = AttrLabelProxy

#endif


{- |
Get the value of the “@v_long@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vLong
@
-}
getArgumentVLong :: MonadIO m => Argument -> m CLong
getArgumentVLong s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CLong
    return val

{- |
Set the value of the “@v_long@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vLong 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVLong :: MonadIO m => Argument -> CLong -> m ()
setArgumentVLong s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CLong)

#if ENABLE_OVERLOADING
data ArgumentVLongFieldInfo
instance AttrInfo ArgumentVLongFieldInfo where
    type AttrAllowedOps ArgumentVLongFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVLongFieldInfo = (~) CLong
    type AttrBaseTypeConstraint ArgumentVLongFieldInfo = (~) Argument
    type AttrGetType ArgumentVLongFieldInfo = CLong
    type AttrLabel ArgumentVLongFieldInfo = "v_long"
    type AttrOrigin ArgumentVLongFieldInfo = Argument
    attrGet _ = getArgumentVLong
    attrSet _ = setArgumentVLong
    attrConstruct = undefined
    attrClear _ = undefined

argument_vLong :: AttrLabelProxy "vLong"
argument_vLong = AttrLabelProxy

#endif


{- |
Get the value of the “@v_ulong@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vUlong
@
-}
getArgumentVUlong :: MonadIO m => Argument -> m CULong
getArgumentVUlong s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CULong
    return val

{- |
Set the value of the “@v_ulong@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vUlong 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVUlong :: MonadIO m => Argument -> CULong -> m ()
setArgumentVUlong s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CULong)

#if ENABLE_OVERLOADING
data ArgumentVUlongFieldInfo
instance AttrInfo ArgumentVUlongFieldInfo where
    type AttrAllowedOps ArgumentVUlongFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUlongFieldInfo = (~) CULong
    type AttrBaseTypeConstraint ArgumentVUlongFieldInfo = (~) Argument
    type AttrGetType ArgumentVUlongFieldInfo = CULong
    type AttrLabel ArgumentVUlongFieldInfo = "v_ulong"
    type AttrOrigin ArgumentVUlongFieldInfo = Argument
    attrGet _ = getArgumentVUlong
    attrSet _ = setArgumentVUlong
    attrConstruct = undefined
    attrClear _ = undefined

argument_vUlong :: AttrLabelProxy "vUlong"
argument_vUlong = AttrLabelProxy

#endif


{- |
Get the value of the “@v_ssize@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vSsize
@
-}
getArgumentVSsize :: MonadIO m => Argument -> m Int64
getArgumentVSsize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int64
    return val

{- |
Set the value of the “@v_ssize@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vSsize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVSsize :: MonadIO m => Argument -> Int64 -> m ()
setArgumentVSsize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int64)

#if ENABLE_OVERLOADING
data ArgumentVSsizeFieldInfo
instance AttrInfo ArgumentVSsizeFieldInfo where
    type AttrAllowedOps ArgumentVSsizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVSsizeFieldInfo = (~) Int64
    type AttrBaseTypeConstraint ArgumentVSsizeFieldInfo = (~) Argument
    type AttrGetType ArgumentVSsizeFieldInfo = Int64
    type AttrLabel ArgumentVSsizeFieldInfo = "v_ssize"
    type AttrOrigin ArgumentVSsizeFieldInfo = Argument
    attrGet _ = getArgumentVSsize
    attrSet _ = setArgumentVSsize
    attrConstruct = undefined
    attrClear _ = undefined

argument_vSsize :: AttrLabelProxy "vSsize"
argument_vSsize = AttrLabelProxy

#endif


{- |
Get the value of the “@v_size@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vSize
@
-}
getArgumentVSize :: MonadIO m => Argument -> m Word64
getArgumentVSize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

{- |
Set the value of the “@v_size@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vSize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVSize :: MonadIO m => Argument -> Word64 -> m ()
setArgumentVSize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word64)

#if ENABLE_OVERLOADING
data ArgumentVSizeFieldInfo
instance AttrInfo ArgumentVSizeFieldInfo where
    type AttrAllowedOps ArgumentVSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVSizeFieldInfo = (~) Word64
    type AttrBaseTypeConstraint ArgumentVSizeFieldInfo = (~) Argument
    type AttrGetType ArgumentVSizeFieldInfo = Word64
    type AttrLabel ArgumentVSizeFieldInfo = "v_size"
    type AttrOrigin ArgumentVSizeFieldInfo = Argument
    attrGet _ = getArgumentVSize
    attrSet _ = setArgumentVSize
    attrConstruct = undefined
    attrClear _ = undefined

argument_vSize :: AttrLabelProxy "vSize"
argument_vSize = AttrLabelProxy

#endif


{- |
Get the value of the “@v_string@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vString
@
-}
getArgumentVString :: MonadIO m => Argument -> m (Maybe T.Text)
getArgumentVString s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

{- |
Set the value of the “@v_string@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vString 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVString :: MonadIO m => Argument -> CString -> m ()
setArgumentVString s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CString)

{- |
Set the value of the “@v_string@” 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' #vString
@
-}
clearArgumentVString :: MonadIO m => Argument -> m ()
clearArgumentVString s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
data ArgumentVStringFieldInfo
instance AttrInfo ArgumentVStringFieldInfo where
    type AttrAllowedOps ArgumentVStringFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentVStringFieldInfo = (~) CString
    type AttrBaseTypeConstraint ArgumentVStringFieldInfo = (~) Argument
    type AttrGetType ArgumentVStringFieldInfo = Maybe T.Text
    type AttrLabel ArgumentVStringFieldInfo = "v_string"
    type AttrOrigin ArgumentVStringFieldInfo = Argument
    attrGet _ = getArgumentVString
    attrSet _ = setArgumentVString
    attrConstruct = undefined
    attrClear _ = clearArgumentVString

argument_vString :: AttrLabelProxy "vString"
argument_vString = AttrLabelProxy

#endif


{- |
Get the value of the “@v_pointer@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' argument #vPointer
@
-}
getArgumentVPointer :: MonadIO m => Argument -> m (Ptr ())
getArgumentVPointer s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
    return val

{- |
Set the value of the “@v_pointer@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' argument [ #vPointer 'Data.GI.Base.Attributes.:=' value ]
@
-}
setArgumentVPointer :: MonadIO m => Argument -> Ptr () -> m ()
setArgumentVPointer s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr ())

{- |
Set the value of the “@v_pointer@” 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' #vPointer
@
-}
clearArgumentVPointer :: MonadIO m => Argument -> m ()
clearArgumentVPointer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())

#if ENABLE_OVERLOADING
data ArgumentVPointerFieldInfo
instance AttrInfo ArgumentVPointerFieldInfo where
    type AttrAllowedOps ArgumentVPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentVPointerFieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint ArgumentVPointerFieldInfo = (~) Argument
    type AttrGetType ArgumentVPointerFieldInfo = Ptr ()
    type AttrLabel ArgumentVPointerFieldInfo = "v_pointer"
    type AttrOrigin ArgumentVPointerFieldInfo = Argument
    attrGet _ = getArgumentVPointer
    attrSet _ = setArgumentVPointer
    attrConstruct = undefined
    attrClear _ = clearArgumentVPointer

argument_vPointer :: AttrLabelProxy "vPointer"
argument_vPointer = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList Argument
type instance O.AttributeList Argument = ArgumentAttributeList
type ArgumentAttributeList = ('[ '("vBoolean", ArgumentVBooleanFieldInfo), '("vInt8", ArgumentVInt8FieldInfo), '("vUint8", ArgumentVUint8FieldInfo), '("vInt16", ArgumentVInt16FieldInfo), '("vUint16", ArgumentVUint16FieldInfo), '("vInt32", ArgumentVInt32FieldInfo), '("vUint32", ArgumentVUint32FieldInfo), '("vInt64", ArgumentVInt64FieldInfo), '("vUint64", ArgumentVUint64FieldInfo), '("vFloat", ArgumentVFloatFieldInfo), '("vDouble", ArgumentVDoubleFieldInfo), '("vShort", ArgumentVShortFieldInfo), '("vUshort", ArgumentVUshortFieldInfo), '("vInt", ArgumentVIntFieldInfo), '("vUint", ArgumentVUintFieldInfo), '("vLong", ArgumentVLongFieldInfo), '("vUlong", ArgumentVUlongFieldInfo), '("vSsize", ArgumentVSsizeFieldInfo), '("vSize", ArgumentVSizeFieldInfo), '("vString", ArgumentVStringFieldInfo), '("vPointer", ArgumentVPointerFieldInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
type family ResolveArgumentMethod (t :: Symbol) (o :: *) :: * where
    ResolveArgumentMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveArgumentMethod t Argument, O.MethodInfo info Argument p) => OL.IsLabel t (Argument -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif