    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A union holding the value of the token.

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

    module GI.GLib.Unions.TokenValue
        (

    -- * Exported types
        TokenValue(..)                          ,
        newZeroTokenValue                       ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveTokenValueMethod                 ,
    #endif

     -- * Properties
    -- ** vBinary #attr:vBinary#
    -- | token binary integer value

        getTokenValueVBinary                    ,
        setTokenValueVBinary                    ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vBinary                      ,
    #endif

    -- ** vChar #attr:vChar#
    -- | character value

        getTokenValueVChar                      ,
        setTokenValueVChar                      ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vChar                        ,
    #endif

    -- ** vComment #attr:vComment#
    -- | comment value

        clearTokenValueVComment                 ,
        getTokenValueVComment                   ,
        setTokenValueVComment                   ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vComment                     ,
    #endif

    -- ** vError #attr:vError#
    -- | error value

        getTokenValueVError                     ,
        setTokenValueVError                     ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vError                       ,
    #endif

    -- ** vFloat #attr:vFloat#
    -- | floating point value

        getTokenValueVFloat                     ,
        setTokenValueVFloat                     ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vFloat                       ,
    #endif

    -- ** vHex #attr:vHex#
    -- | hex integer value

        getTokenValueVHex                       ,
        setTokenValueVHex                       ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vHex                         ,
    #endif

    -- ** vIdentifier #attr:vIdentifier#
    -- | token identifier value

        clearTokenValueVIdentifier              ,
        getTokenValueVIdentifier                ,
        setTokenValueVIdentifier                ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vIdentifier                  ,
    #endif

    -- ** vInt #attr:vInt#
    -- | integer value

        getTokenValueVInt                       ,
        setTokenValueVInt                       ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vInt                         ,
    #endif

    -- ** vInt64 #attr:vInt64#
    -- | 64-bit integer value

        getTokenValueVInt64                     ,
        setTokenValueVInt64                     ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vInt64                       ,
    #endif

    -- ** vOctal #attr:vOctal#
    -- | octal integer value

        getTokenValueVOctal                     ,
        setTokenValueVOctal                     ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vOctal                       ,
    #endif

    -- ** vString #attr:vString#
    -- | string value

        clearTokenValueVString                  ,
        getTokenValueVString                    ,
        setTokenValueVString                    ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vString                      ,
    #endif

    -- ** vSymbol #attr:vSymbol#
    -- | token symbol value

        clearTokenValueVSymbol                  ,
        getTokenValueVSymbol                    ,
        setTokenValueVSymbol                    ,
    #if defined(ENABLE_OVERLOADING)
        tokenValue_vSymbol                      ,
    #endif

        ) 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.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.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 TokenValue = TokenValue (SP.ManagedPtr TokenValue)
        deriving (TokenValue -> TokenValue -> Bool
    (TokenValue -> TokenValue -> Bool)
    -> (TokenValue -> TokenValue -> Bool) -> Eq TokenValue
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TokenValue -> TokenValue -> Bool
    $c/= :: TokenValue -> TokenValue -> Bool
    == :: TokenValue -> TokenValue -> Bool
    $c== :: TokenValue -> TokenValue -> Bool
    Eq)

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

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

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

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

    -- | Get the value of the “@v_symbol@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vSymbol
    -- @
    getTokenValueVSymbol :: MonadIO m => TokenValue -> m (Ptr ())
    getTokenValueVSymbol :: TokenValue -> m (Ptr ())
    getTokenValueVSymbol s :: TokenValue
    s = IO (Ptr ()) -> m (Ptr ())
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO (Ptr ())) -> IO (Ptr ())
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO (Ptr ())) -> IO (Ptr ()))
    -> (Ptr TokenValue -> IO (Ptr ())) -> IO (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Ptr ()
    val <- Ptr (Ptr ()) -> IO (Ptr ())
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO (Ptr ())
        Ptr () -> IO (Ptr ())
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ()
    val

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

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVSymbolFieldInfo
    instance AttrInfo TokenValueVSymbolFieldInfo where
        type AttrBaseTypeConstraint TokenValueVSymbolFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVSymbolFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint TokenValueVSymbolFieldInfo = (~) (Ptr ())
        type AttrTransferTypeConstraint TokenValueVSymbolFieldInfo = (~)(Ptr ())
        type AttrTransferType TokenValueVSymbolFieldInfo = (Ptr ())
        type AttrGetType TokenValueVSymbolFieldInfo = Ptr ()
        type AttrLabel TokenValueVSymbolFieldInfo = "v_symbol"
        type AttrOrigin TokenValueVSymbolFieldInfo = TokenValue
        attrGet = getTokenValueVSymbol
        attrSet = setTokenValueVSymbol
        attrConstruct = undefined
        attrClear = clearTokenValueVSymbol
        attrTransfer _ v = do
            return v

    tokenValue_vSymbol :: AttrLabelProxy "vSymbol"
    tokenValue_vSymbol = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_identifier@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vIdentifier
    -- @
    getTokenValueVIdentifier :: MonadIO m => TokenValue -> m (Maybe T.Text)
    getTokenValueVIdentifier :: TokenValue -> m (Maybe Text)
    getTokenValueVIdentifier s :: TokenValue
    s = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ TokenValue
    -> (Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CString
    val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CString
        Maybe Text
    result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull CString
    val ((CString -> IO Text) -> IO (Maybe Text))
    -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \val' :: CString
    val' -> do
            Text
    val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    val''
        Maybe Text -> IO (Maybe Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    result

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

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVIdentifierFieldInfo
    instance AttrInfo TokenValueVIdentifierFieldInfo where
        type AttrBaseTypeConstraint TokenValueVIdentifierFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVIdentifierFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint TokenValueVIdentifierFieldInfo = (~) CString
        type AttrTransferTypeConstraint TokenValueVIdentifierFieldInfo = (~)CString
        type AttrTransferType TokenValueVIdentifierFieldInfo = CString
        type AttrGetType TokenValueVIdentifierFieldInfo = Maybe T.Text
        type AttrLabel TokenValueVIdentifierFieldInfo = "v_identifier"
        type AttrOrigin TokenValueVIdentifierFieldInfo = TokenValue
        attrGet = getTokenValueVIdentifier
        attrSet = setTokenValueVIdentifier
        attrConstruct = undefined
        attrClear = clearTokenValueVIdentifier
        attrTransfer _ v = do
            return v

    tokenValue_vIdentifier :: AttrLabelProxy "vIdentifier"
    tokenValue_vIdentifier = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_binary@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vBinary
    -- @
    getTokenValueVBinary :: MonadIO m => TokenValue -> m CULong
    getTokenValueVBinary :: TokenValue -> m CULong
    getTokenValueVBinary s :: TokenValue
    s = IO CULong -> m CULong
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO CULong) -> IO CULong)
    -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CULong
    val <- Ptr CULong -> IO CULong
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CULong
        CULong -> IO CULong
    forall (m :: * -> *) a. Monad m => a -> m a
    return CULong
    val

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVBinaryFieldInfo
    instance AttrInfo TokenValueVBinaryFieldInfo where
        type AttrBaseTypeConstraint TokenValueVBinaryFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVBinaryFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVBinaryFieldInfo = (~) CULong
        type AttrTransferTypeConstraint TokenValueVBinaryFieldInfo = (~)CULong
        type AttrTransferType TokenValueVBinaryFieldInfo = CULong
        type AttrGetType TokenValueVBinaryFieldInfo = CULong
        type AttrLabel TokenValueVBinaryFieldInfo = "v_binary"
        type AttrOrigin TokenValueVBinaryFieldInfo = TokenValue
        attrGet = getTokenValueVBinary
        attrSet = setTokenValueVBinary
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vBinary :: AttrLabelProxy "vBinary"
    tokenValue_vBinary = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_octal@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vOctal
    -- @
    getTokenValueVOctal :: MonadIO m => TokenValue -> m CULong
    getTokenValueVOctal :: TokenValue -> m CULong
    getTokenValueVOctal s :: TokenValue
    s = IO CULong -> m CULong
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO CULong) -> IO CULong)
    -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CULong
    val <- Ptr CULong -> IO CULong
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CULong
        CULong -> IO CULong
    forall (m :: * -> *) a. Monad m => a -> m a
    return CULong
    val

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVOctalFieldInfo
    instance AttrInfo TokenValueVOctalFieldInfo where
        type AttrBaseTypeConstraint TokenValueVOctalFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVOctalFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVOctalFieldInfo = (~) CULong
        type AttrTransferTypeConstraint TokenValueVOctalFieldInfo = (~)CULong
        type AttrTransferType TokenValueVOctalFieldInfo = CULong
        type AttrGetType TokenValueVOctalFieldInfo = CULong
        type AttrLabel TokenValueVOctalFieldInfo = "v_octal"
        type AttrOrigin TokenValueVOctalFieldInfo = TokenValue
        attrGet = getTokenValueVOctal
        attrSet = setTokenValueVOctal
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vOctal :: AttrLabelProxy "vOctal"
    tokenValue_vOctal = 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' tokenValue #vInt
    -- @
    getTokenValueVInt :: MonadIO m => TokenValue -> m CULong
    getTokenValueVInt :: TokenValue -> m CULong
    getTokenValueVInt s :: TokenValue
    s = IO CULong -> m CULong
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO CULong) -> IO CULong)
    -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CULong
    val <- Ptr CULong -> IO CULong
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CULong
        CULong -> IO CULong
    forall (m :: * -> *) a. Monad m => a -> m a
    return CULong
    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' tokenValue [ #vInt 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTokenValueVInt :: MonadIO m => TokenValue -> CULong -> m ()
    setTokenValueVInt :: TokenValue -> CULong -> m ()
    setTokenValueVInt s :: TokenValue
    s val :: CULong
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO ()) -> IO ())
    -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Ptr CULong -> CULong -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (CULong
    val :: CULong)

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVIntFieldInfo
    instance AttrInfo TokenValueVIntFieldInfo where
        type AttrBaseTypeConstraint TokenValueVIntFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVIntFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVIntFieldInfo = (~) CULong
        type AttrTransferTypeConstraint TokenValueVIntFieldInfo = (~)CULong
        type AttrTransferType TokenValueVIntFieldInfo = CULong
        type AttrGetType TokenValueVIntFieldInfo = CULong
        type AttrLabel TokenValueVIntFieldInfo = "v_int"
        type AttrOrigin TokenValueVIntFieldInfo = TokenValue
        attrGet = getTokenValueVInt
        attrSet = setTokenValueVInt
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vInt :: AttrLabelProxy "vInt"
    tokenValue_vInt = 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' tokenValue #vInt64
    -- @
    getTokenValueVInt64 :: MonadIO m => TokenValue -> m Word64
    getTokenValueVInt64 :: TokenValue -> m Word64
    getTokenValueVInt64 s :: TokenValue
    s = IO Word64 -> m Word64
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO Word64) -> IO Word64
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO Word64) -> IO Word64)
    -> (Ptr TokenValue -> IO Word64) -> IO Word64
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Word64
    val <- Ptr Word64 -> IO Word64
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr Word64
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO Word64
        Word64 -> IO Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word64
    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' tokenValue [ #vInt64 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTokenValueVInt64 :: MonadIO m => TokenValue -> Word64 -> m ()
    setTokenValueVInt64 :: TokenValue -> Word64 -> m ()
    setTokenValueVInt64 s :: TokenValue
    s val :: Word64
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO ()) -> IO ())
    -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Ptr Word64 -> Word64 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr Word64
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (Word64
    val :: Word64)

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVInt64FieldInfo
    instance AttrInfo TokenValueVInt64FieldInfo where
        type AttrBaseTypeConstraint TokenValueVInt64FieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVInt64FieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVInt64FieldInfo = (~) Word64
        type AttrTransferTypeConstraint TokenValueVInt64FieldInfo = (~)Word64
        type AttrTransferType TokenValueVInt64FieldInfo = Word64
        type AttrGetType TokenValueVInt64FieldInfo = Word64
        type AttrLabel TokenValueVInt64FieldInfo = "v_int64"
        type AttrOrigin TokenValueVInt64FieldInfo = TokenValue
        attrGet = getTokenValueVInt64
        attrSet = setTokenValueVInt64
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vInt64 :: AttrLabelProxy "vInt64"
    tokenValue_vInt64 = 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' tokenValue #vFloat
    -- @
    getTokenValueVFloat :: MonadIO m => TokenValue -> m Double
    getTokenValueVFloat :: TokenValue -> m Double
    getTokenValueVFloat s :: TokenValue
    s = IO Double -> m Double
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO Double) -> IO Double
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO Double) -> IO Double)
    -> (Ptr TokenValue -> IO Double) -> IO Double
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CDouble
    val <- Ptr CDouble -> IO CDouble
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CDouble
        let val' :: Double
    val' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    val
        Double -> IO Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return Double
    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' tokenValue [ #vFloat 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTokenValueVFloat :: MonadIO m => TokenValue -> Double -> m ()
    setTokenValueVFloat :: TokenValue -> Double -> m ()
    setTokenValueVFloat s :: TokenValue
    s val :: Double
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO ()) -> IO ())
    -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        let val' :: CDouble
    val' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    val
        Ptr CDouble -> CDouble -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (CDouble
    val' :: CDouble)

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVFloatFieldInfo
    instance AttrInfo TokenValueVFloatFieldInfo where
        type AttrBaseTypeConstraint TokenValueVFloatFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVFloatFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVFloatFieldInfo = (~) Double
        type AttrTransferTypeConstraint TokenValueVFloatFieldInfo = (~)Double
        type AttrTransferType TokenValueVFloatFieldInfo = Double
        type AttrGetType TokenValueVFloatFieldInfo = Double
        type AttrLabel TokenValueVFloatFieldInfo = "v_float"
        type AttrOrigin TokenValueVFloatFieldInfo = TokenValue
        attrGet = getTokenValueVFloat
        attrSet = setTokenValueVFloat
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vFloat :: AttrLabelProxy "vFloat"
    tokenValue_vFloat = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_hex@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vHex
    -- @
    getTokenValueVHex :: MonadIO m => TokenValue -> m CULong
    getTokenValueVHex :: TokenValue -> m CULong
    getTokenValueVHex s :: TokenValue
    s = IO CULong -> m CULong
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO CULong) -> IO CULong)
    -> (Ptr TokenValue -> IO CULong) -> IO CULong
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CULong
    val <- Ptr CULong -> IO CULong
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CULong
        CULong -> IO CULong
    forall (m :: * -> *) a. Monad m => a -> m a
    return CULong
    val

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVHexFieldInfo
    instance AttrInfo TokenValueVHexFieldInfo where
        type AttrBaseTypeConstraint TokenValueVHexFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVHexFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVHexFieldInfo = (~) CULong
        type AttrTransferTypeConstraint TokenValueVHexFieldInfo = (~)CULong
        type AttrTransferType TokenValueVHexFieldInfo = CULong
        type AttrGetType TokenValueVHexFieldInfo = CULong
        type AttrLabel TokenValueVHexFieldInfo = "v_hex"
        type AttrOrigin TokenValueVHexFieldInfo = TokenValue
        attrGet = getTokenValueVHex
        attrSet = setTokenValueVHex
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vHex :: AttrLabelProxy "vHex"
    tokenValue_vHex = 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' tokenValue #vString
    -- @
    getTokenValueVString :: MonadIO m => TokenValue -> m (Maybe T.Text)
    getTokenValueVString :: TokenValue -> m (Maybe Text)
    getTokenValueVString s :: TokenValue
    s = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ TokenValue
    -> (Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CString
    val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CString
        Maybe Text
    result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull CString
    val ((CString -> IO Text) -> IO (Maybe Text))
    -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \val' :: CString
    val' -> do
            Text
    val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    val''
        Maybe Text -> IO (Maybe Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    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' tokenValue [ #vString 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTokenValueVString :: MonadIO m => TokenValue -> CString -> m ()
    setTokenValueVString :: TokenValue -> CString -> m ()
    setTokenValueVString s :: TokenValue
    s val :: CString
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO ()) -> IO ())
    -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (CString
    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
    -- @
    clearTokenValueVString :: MonadIO m => TokenValue -> m ()
    clearTokenValueVString :: TokenValue -> m ()
    clearTokenValueVString s :: TokenValue
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO ()) -> IO ())
    -> (Ptr TokenValue -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (CString
    forall a. Ptr a
    FP.nullPtr :: CString)

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVStringFieldInfo
    instance AttrInfo TokenValueVStringFieldInfo where
        type AttrBaseTypeConstraint TokenValueVStringFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVStringFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint TokenValueVStringFieldInfo = (~) CString
        type AttrTransferTypeConstraint TokenValueVStringFieldInfo = (~)CString
        type AttrTransferType TokenValueVStringFieldInfo = CString
        type AttrGetType TokenValueVStringFieldInfo = Maybe T.Text
        type AttrLabel TokenValueVStringFieldInfo = "v_string"
        type AttrOrigin TokenValueVStringFieldInfo = TokenValue
        attrGet = getTokenValueVString
        attrSet = setTokenValueVString
        attrConstruct = undefined
        attrClear = clearTokenValueVString
        attrTransfer _ v = do
            return v

    tokenValue_vString :: AttrLabelProxy "vString"
    tokenValue_vString = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_comment@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vComment
    -- @
    getTokenValueVComment :: MonadIO m => TokenValue -> m (Maybe T.Text)
    getTokenValueVComment :: TokenValue -> m (Maybe Text)
    getTokenValueVComment s :: TokenValue
    s = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ TokenValue
    -> (Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr TokenValue -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        CString
    val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO CString
        Maybe Text
    result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull CString
    val ((CString -> IO Text) -> IO (Maybe Text))
    -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \val' :: CString
    val' -> do
            Text
    val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    val''
        Maybe Text -> IO (Maybe Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    result

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

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVCommentFieldInfo
    instance AttrInfo TokenValueVCommentFieldInfo where
        type AttrBaseTypeConstraint TokenValueVCommentFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVCommentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint TokenValueVCommentFieldInfo = (~) CString
        type AttrTransferTypeConstraint TokenValueVCommentFieldInfo = (~)CString
        type AttrTransferType TokenValueVCommentFieldInfo = CString
        type AttrGetType TokenValueVCommentFieldInfo = Maybe T.Text
        type AttrLabel TokenValueVCommentFieldInfo = "v_comment"
        type AttrOrigin TokenValueVCommentFieldInfo = TokenValue
        attrGet = getTokenValueVComment
        attrSet = setTokenValueVComment
        attrConstruct = undefined
        attrClear = clearTokenValueVComment
        attrTransfer _ v = do
            return v

    tokenValue_vComment :: AttrLabelProxy "vComment"
    tokenValue_vComment = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_char@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vChar
    -- @
    getTokenValueVChar :: MonadIO m => TokenValue -> m Word8
    getTokenValueVChar :: TokenValue -> m Word8
    getTokenValueVChar s :: TokenValue
    s = IO Word8 -> m Word8
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO Word8) -> IO Word8
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO Word8) -> IO Word8)
    -> (Ptr TokenValue -> IO Word8) -> IO Word8
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Word8
    val <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO Word8
        Word8 -> IO Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word8
    val

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVCharFieldInfo
    instance AttrInfo TokenValueVCharFieldInfo where
        type AttrBaseTypeConstraint TokenValueVCharFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVCharFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVCharFieldInfo = (~) Word8
        type AttrTransferTypeConstraint TokenValueVCharFieldInfo = (~)Word8
        type AttrTransferType TokenValueVCharFieldInfo = Word8
        type AttrGetType TokenValueVCharFieldInfo = Word8
        type AttrLabel TokenValueVCharFieldInfo = "v_char"
        type AttrOrigin TokenValueVCharFieldInfo = TokenValue
        attrGet = getTokenValueVChar
        attrSet = setTokenValueVChar
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vChar :: AttrLabelProxy "vChar"
    tokenValue_vChar = AttrLabelProxy

    #endif

    -- | Get the value of the “@v_error@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tokenValue #vError
    -- @
    getTokenValueVError :: MonadIO m => TokenValue -> m Word32
    getTokenValueVError :: TokenValue -> m Word32
    getTokenValueVError s :: TokenValue
    s = IO Word32 -> m Word32
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ TokenValue -> (Ptr TokenValue -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TokenValue
    s ((Ptr TokenValue -> IO Word32) -> IO Word32)
    -> (Ptr TokenValue -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr TokenValue
    ptr -> do
        Word32
    val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TokenValue
    ptr Ptr TokenValue -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO Word32
        Word32 -> IO Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    val

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

    #if defined(ENABLE_OVERLOADING)
    data TokenValueVErrorFieldInfo
    instance AttrInfo TokenValueVErrorFieldInfo where
        type AttrBaseTypeConstraint TokenValueVErrorFieldInfo = (~) TokenValue
        type AttrAllowedOps TokenValueVErrorFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TokenValueVErrorFieldInfo = (~) Word32
        type AttrTransferTypeConstraint TokenValueVErrorFieldInfo = (~)Word32
        type AttrTransferType TokenValueVErrorFieldInfo = Word32
        type AttrGetType TokenValueVErrorFieldInfo = Word32
        type AttrLabel TokenValueVErrorFieldInfo = "v_error"
        type AttrOrigin TokenValueVErrorFieldInfo = TokenValue
        attrGet = getTokenValueVError
        attrSet = setTokenValueVError
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    tokenValue_vError :: AttrLabelProxy "vError"
    tokenValue_vError = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList TokenValue
    type instance O.AttributeList TokenValue = TokenValueAttributeList
    type TokenValueAttributeList = ('[ '("vSymbol", TokenValueVSymbolFieldInfo), '("vIdentifier", TokenValueVIdentifierFieldInfo), '("vBinary", TokenValueVBinaryFieldInfo), '("vOctal", TokenValueVOctalFieldInfo), '("vInt", TokenValueVIntFieldInfo), '("vInt64", TokenValueVInt64FieldInfo), '("vFloat", TokenValueVFloatFieldInfo), '("vHex", TokenValueVHexFieldInfo), '("vString", TokenValueVStringFieldInfo), '("vComment", TokenValueVCommentFieldInfo), '("vChar", TokenValueVCharFieldInfo), '("vError", TokenValueVErrorFieldInfo)] :: [(Symbol, *)])
    #endif

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

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

    #endif