    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- /No description available in the introspection data./

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

    module GI.GObject.Unions.Value_Data_Union_
        (

    -- * Exported types
        Value_Data_Union_(..)                   ,
        newZeroValue_Data_Union_                ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveValue_Data_Union_Method          ,
    #endif

     -- * Properties

    -- ** vDouble #attr:vDouble#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VDouble             ,
        setValue_Data_Union_VDouble             ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vDouble               ,
    #endif

    -- ** vFloat #attr:vFloat#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VFloat              ,
        setValue_Data_Union_VFloat              ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vFloat                ,
    #endif

    -- ** vInt #attr:vInt#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VInt                ,
        setValue_Data_Union_VInt                ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vInt                  ,
    #endif

    -- ** vInt64 #attr:vInt64#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VInt64              ,
        setValue_Data_Union_VInt64              ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vInt64                ,
    #endif

    -- ** vLong #attr:vLong#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VLong               ,
        setValue_Data_Union_VLong               ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vLong                 ,
    #endif

    -- ** vPointer #attr:vPointer#
    -- | /No description available in the introspection data./

        clearValue_Data_Union_VPointer          ,
        getValue_Data_Union_VPointer            ,
        setValue_Data_Union_VPointer            ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vPointer              ,
    #endif

    -- ** vUint #attr:vUint#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VUint               ,
        setValue_Data_Union_VUint               ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vUint                 ,
    #endif

    -- ** vUint64 #attr:vUint64#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VUint64             ,
        setValue_Data_Union_VUint64             ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vUint64               ,
    #endif

    -- ** vUlong #attr:vUlong#
    -- | /No description available in the introspection data./

        getValue_Data_Union_VUlong              ,
        setValue_Data_Union_VUlong              ,
    #if defined(ENABLE_OVERLOADING)
        value_Data_Union__vUlong                ,
    #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.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

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

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

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

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

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

    -- | 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' value_Data_Union_ #vInt
    -- @
    getValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> m Int32
    getValue_Data_Union_VInt :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m Int32
    getValue_Data_Union_VInt Value_Data_Union_
    s = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO Int32) -> IO Int32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO Int32) -> IO Int32)
    -> (Ptr Value_Data_Union_ -> IO Int32) -> IO Int32
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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' value_Data_Union_ [ #vInt 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> Int32 -> m ()
    setValue_Data_Union_VInt :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Int32 -> m ()
    setValue_Data_Union_VInt Value_Data_Union_
    s Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr Int32 -> Int32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Int32
    val :: Int32)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VIntFieldInfo
    instance AttrInfo Value_Data_Union_VIntFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VIntFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Int32
        type AttrTransferTypeConstraint Value_Data_Union_VIntFieldInfo = (~)Int32
        type AttrTransferType Value_Data_Union_VIntFieldInfo = Int32
        type AttrGetType Value_Data_Union_VIntFieldInfo = Int32
        type AttrLabel Value_Data_Union_VIntFieldInfo = "v_int"
        type AttrOrigin Value_Data_Union_VIntFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VInt
        attrSet = setValue_Data_Union_VInt
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vInt"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vInt"
            })

    value_Data_Union__vInt :: AttrLabelProxy "vInt"
    value_Data_Union__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' value_Data_Union_ #vUint
    -- @
    getValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> m Word32
    getValue_Data_Union_VUint :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m Word32
    getValue_Data_Union_VUint Value_Data_Union_
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    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
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO Word32) -> IO Word32)
    -> (Ptr Value_Data_Union_ -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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' value_Data_Union_ [ #vUint 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> Word32 -> m ()
    setValue_Data_Union_VUint :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Word32 -> m ()
    setValue_Data_Union_VUint Value_Data_Union_
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VUintFieldInfo
    instance AttrInfo Value_Data_Union_VUintFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VUintFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Word32
        type AttrTransferTypeConstraint Value_Data_Union_VUintFieldInfo = (~)Word32
        type AttrTransferType Value_Data_Union_VUintFieldInfo = Word32
        type AttrGetType Value_Data_Union_VUintFieldInfo = Word32
        type AttrLabel Value_Data_Union_VUintFieldInfo = "v_uint"
        type AttrOrigin Value_Data_Union_VUintFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VUint
        attrSet = setValue_Data_Union_VUint
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vUint"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vUint"
            })

    value_Data_Union__vUint :: AttrLabelProxy "vUint"
    value_Data_Union__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' value_Data_Union_ #vLong
    -- @
    getValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> m FCT.CLong
    getValue_Data_Union_VLong :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m CLong
    getValue_Data_Union_VLong Value_Data_Union_
    s = IO CLong -> m CLong
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO CLong) -> IO CLong
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO CLong) -> IO CLong)
    -> (Ptr Value_Data_Union_ -> IO CLong) -> IO CLong
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr CLong -> IO CLong
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CLong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO FCT.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' value_Data_Union_ [ #vLong 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> FCT.CLong -> m ()
    setValue_Data_Union_VLong :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> CLong -> m ()
    setValue_Data_Union_VLong Value_Data_Union_
    s CLong
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr CLong -> CLong -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CLong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CLong
    val :: FCT.CLong)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VLongFieldInfo
    instance AttrInfo Value_Data_Union_VLongFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VLongFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VLongFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VLongFieldInfo = (~) FCT.CLong
        type AttrTransferTypeConstraint Value_Data_Union_VLongFieldInfo = (~)FCT.CLong
        type AttrTransferType Value_Data_Union_VLongFieldInfo = FCT.CLong
        type AttrGetType Value_Data_Union_VLongFieldInfo = FCT.CLong
        type AttrLabel Value_Data_Union_VLongFieldInfo = "v_long"
        type AttrOrigin Value_Data_Union_VLongFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VLong
        attrSet = setValue_Data_Union_VLong
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vLong"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vLong"
            })

    value_Data_Union__vLong :: AttrLabelProxy "vLong"
    value_Data_Union__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' value_Data_Union_ #vUlong
    -- @
    getValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> m FCT.CULong
    getValue_Data_Union_VUlong :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m CULong
    getValue_Data_Union_VUlong Value_Data_Union_
    s = IO CULong -> m CULong
    forall a. IO a -> m a
    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
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO CULong) -> IO CULong
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO CULong) -> IO CULong)
    -> (Ptr Value_Data_Union_ -> IO CULong) -> IO CULong
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr CULong -> IO CULong
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO FCT.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' value_Data_Union_ [ #vUlong 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> FCT.CULong -> m ()
    setValue_Data_Union_VUlong :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> CULong -> m ()
    setValue_Data_Union_VUlong Value_Data_Union_
    s CULong
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr CULong -> CULong -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CULong
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CULong
    val :: FCT.CULong)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VUlongFieldInfo
    instance AttrInfo Value_Data_Union_VUlongFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VUlongFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) FCT.CULong
        type AttrTransferTypeConstraint Value_Data_Union_VUlongFieldInfo = (~)FCT.CULong
        type AttrTransferType Value_Data_Union_VUlongFieldInfo = FCT.CULong
        type AttrGetType Value_Data_Union_VUlongFieldInfo = FCT.CULong
        type AttrLabel Value_Data_Union_VUlongFieldInfo = "v_ulong"
        type AttrOrigin Value_Data_Union_VUlongFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VUlong
        attrSet = setValue_Data_Union_VUlong
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vUlong"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vUlong"
            })

    value_Data_Union__vUlong :: AttrLabelProxy "vUlong"
    value_Data_Union__vUlong = 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' value_Data_Union_ #vInt64
    -- @
    getValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> m Int64
    getValue_Data_Union_VInt64 :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m Int64
    getValue_Data_Union_VInt64 Value_Data_Union_
    s = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO Int64) -> IO Int64
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO Int64) -> IO Int64)
    -> (Ptr Value_Data_Union_ -> IO Int64) -> IO Int64
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr Int64 -> IO Int64
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Int64
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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' value_Data_Union_ [ #vInt64 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> Int64 -> m ()
    setValue_Data_Union_VInt64 :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Int64 -> m ()
    setValue_Data_Union_VInt64 Value_Data_Union_
    s Int64
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr Int64 -> Int64 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Int64
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Int64
    val :: Int64)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VInt64FieldInfo
    instance AttrInfo Value_Data_Union_VInt64FieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VInt64FieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Int64
        type AttrTransferTypeConstraint Value_Data_Union_VInt64FieldInfo = (~)Int64
        type AttrTransferType Value_Data_Union_VInt64FieldInfo = Int64
        type AttrGetType Value_Data_Union_VInt64FieldInfo = Int64
        type AttrLabel Value_Data_Union_VInt64FieldInfo = "v_int64"
        type AttrOrigin Value_Data_Union_VInt64FieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VInt64
        attrSet = setValue_Data_Union_VInt64
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vInt64"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vInt64"
            })

    value_Data_Union__vInt64 :: AttrLabelProxy "vInt64"
    value_Data_Union__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' value_Data_Union_ #vUint64
    -- @
    getValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> m Word64
    getValue_Data_Union_VUint64 :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m Word64
    getValue_Data_Union_VUint64 Value_Data_Union_
    s = IO Word64 -> m Word64
    forall a. IO a -> m a
    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
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO Word64) -> IO Word64
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO Word64) -> IO Word64)
    -> (Ptr Value_Data_Union_ -> IO Word64) -> IO Word64
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr Word64 -> IO Word64
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Word64
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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' value_Data_Union_ [ #vUint64 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> Word64 -> m ()
    setValue_Data_Union_VUint64 :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Word64 -> m ()
    setValue_Data_Union_VUint64 Value_Data_Union_
    s Word64
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr Word64 -> Word64 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr Word64
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Word64
    val :: Word64)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VUint64FieldInfo
    instance AttrInfo Value_Data_Union_VUint64FieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VUint64FieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Word64
        type AttrTransferTypeConstraint Value_Data_Union_VUint64FieldInfo = (~)Word64
        type AttrTransferType Value_Data_Union_VUint64FieldInfo = Word64
        type AttrGetType Value_Data_Union_VUint64FieldInfo = Word64
        type AttrLabel Value_Data_Union_VUint64FieldInfo = "v_uint64"
        type AttrOrigin Value_Data_Union_VUint64FieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VUint64
        attrSet = setValue_Data_Union_VUint64
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vUint64"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vUint64"
            })

    value_Data_Union__vUint64 :: AttrLabelProxy "vUint64"
    value_Data_Union__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' value_Data_Union_ #vFloat
    -- @
    getValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> m Float
    getValue_Data_Union_VFloat :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m Float
    getValue_Data_Union_VFloat Value_Data_Union_
    s = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO Float) -> IO Float
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO Float) -> IO Float)
    -> (Ptr Value_Data_Union_ -> IO Float) -> IO Float
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr CFloat -> IO CFloat
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CFloat
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO CFloat
        let val' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    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' value_Data_Union_ [ #vFloat 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> Float -> m ()
    setValue_Data_Union_VFloat :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Float -> m ()
    setValue_Data_Union_VFloat Value_Data_Union_
    s Float
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        let val' :: CFloat
    val' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    val
        Ptr CFloat -> CFloat -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CFloat
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CFloat
    val' :: CFloat)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VFloatFieldInfo
    instance AttrInfo Value_Data_Union_VFloatFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VFloatFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Float
        type AttrTransferTypeConstraint Value_Data_Union_VFloatFieldInfo = (~)Float
        type AttrTransferType Value_Data_Union_VFloatFieldInfo = Float
        type AttrGetType Value_Data_Union_VFloatFieldInfo = Float
        type AttrLabel Value_Data_Union_VFloatFieldInfo = "v_float"
        type AttrOrigin Value_Data_Union_VFloatFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VFloat
        attrSet = setValue_Data_Union_VFloat
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vFloat"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vFloat"
            })

    value_Data_Union__vFloat :: AttrLabelProxy "vFloat"
    value_Data_Union__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' value_Data_Union_ #vDouble
    -- @
    getValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> m Double
    getValue_Data_Union_VDouble :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m Double
    getValue_Data_Union_VDouble Value_Data_Union_
    s = IO Double -> m Double
    forall a. IO a -> m a
    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
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO Double) -> IO Double
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO Double) -> IO Double)
    -> (Ptr Value_Data_Union_ -> IO Double) -> IO Double
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr CDouble -> IO CDouble
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO CDouble
        let val' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    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' value_Data_Union_ [ #vDouble 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> Double -> m ()
    setValue_Data_Union_VDouble :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Double -> m ()
    setValue_Data_Union_VDouble Value_Data_Union_
    s Double
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    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 Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CDouble
    val' :: CDouble)

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VDoubleFieldInfo
    instance AttrInfo Value_Data_Union_VDoubleFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VDoubleFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Double
        type AttrTransferTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~)Double
        type AttrTransferType Value_Data_Union_VDoubleFieldInfo = Double
        type AttrGetType Value_Data_Union_VDoubleFieldInfo = Double
        type AttrLabel Value_Data_Union_VDoubleFieldInfo = "v_double"
        type AttrOrigin Value_Data_Union_VDoubleFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VDouble
        attrSet = setValue_Data_Union_VDouble
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vDouble"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vDouble"
            })

    value_Data_Union__vDouble :: AttrLabelProxy "vDouble"
    value_Data_Union__vDouble = 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' value_Data_Union_ #vPointer
    -- @
    getValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m (Ptr ())
    getValue_Data_Union_VPointer :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m (Ptr ())
    getValue_Data_Union_VPointer Value_Data_Union_
    s = IO (Ptr ()) -> m (Ptr ())
    forall a. IO a -> m a
    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
    $ Value_Data_Union_
    -> (Ptr Value_Data_Union_ -> IO (Ptr ())) -> IO (Ptr ())
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO (Ptr ())) -> IO (Ptr ()))
    -> (Ptr Value_Data_Union_ -> IO (Ptr ())) -> IO (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        val <- Ptr (Ptr ()) -> IO (Ptr ())
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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' value_Data_Union_ [ #vPointer 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> Ptr () -> m ()
    setValue_Data_Union_VPointer :: forall (m :: * -> *).
    MonadIO m =>
    Value_Data_Union_ -> Ptr () -> m ()
    setValue_Data_Union_VPointer Value_Data_Union_
    s Ptr ()
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr (Ptr ()) -> Ptr () -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr ()
    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
    -- @
    clearValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m ()
    clearValue_Data_Union_VPointer :: forall (m :: * -> *). MonadIO m => Value_Data_Union_ -> m ()
    clearValue_Data_Union_VPointer Value_Data_Union_
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Value_Data_Union_
    s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
    -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Value_Data_Union_
    ptr -> do
        Ptr (Ptr ()) -> Ptr () -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Value_Data_Union_
    ptr Ptr Value_Data_Union_ -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr ()
    forall a. Ptr a
    FP.nullPtr :: Ptr ())

    #if defined(ENABLE_OVERLOADING)
    data Value_Data_Union_VPointerFieldInfo
    instance AttrInfo Value_Data_Union_VPointerFieldInfo where
        type AttrBaseTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) Value_Data_Union_
        type AttrAllowedOps Value_Data_Union_VPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) (Ptr ())
        type AttrTransferTypeConstraint Value_Data_Union_VPointerFieldInfo = (~)(Ptr ())
        type AttrTransferType Value_Data_Union_VPointerFieldInfo = (Ptr ())
        type AttrGetType Value_Data_Union_VPointerFieldInfo = Ptr ()
        type AttrLabel Value_Data_Union_VPointerFieldInfo = "v_pointer"
        type AttrOrigin Value_Data_Union_VPointerFieldInfo = Value_Data_Union_
        attrGet = getValue_Data_Union_VPointer
        attrSet = setValue_Data_Union_VPointer
        attrConstruct = undefined
        attrClear = clearValue_Data_Union_VPointer
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Unions.Value_Data_Union_.vPointer"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Unions-Value_Data_Union_.html#g:attr:vPointer"
            })

    value_Data_Union__vPointer :: AttrLabelProxy "vPointer"
    value_Data_Union__vPointer = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Value_Data_Union_
    type instance O.AttributeList Value_Data_Union_ = Value_Data_Union_AttributeList
    type Value_Data_Union_AttributeList = ('[ '("vInt", Value_Data_Union_VIntFieldInfo), '("vUint", Value_Data_Union_VUintFieldInfo), '("vLong", Value_Data_Union_VLongFieldInfo), '("vUlong", Value_Data_Union_VUlongFieldInfo), '("vInt64", Value_Data_Union_VInt64FieldInfo), '("vUint64", Value_Data_Union_VUint64FieldInfo), '("vFloat", Value_Data_Union_VFloatFieldInfo), '("vDouble", Value_Data_Union_VDoubleFieldInfo), '("vPointer", Value_Data_Union_VPointerFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveValue_Data_Union_Method t Value_Data_Union_, O.OverloadedMethod info Value_Data_Union_ p, R.HasField t Value_Data_Union_ p) => R.HasField t Value_Data_Union_ p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif