    {-# 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.Vte.Structs.Uuid
        (

    -- * Exported types
        Uuid(..)                                ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [dup]("GI.Vte.Structs.Uuid#g:method:dup"), [equal]("GI.Vte.Structs.Uuid#g:method:equal"), [free]("GI.Vte.Structs.Uuid#g:method:free"), [freeToString]("GI.Vte.Structs.Uuid#g:method:freeToString"), [newV5]("GI.Vte.Structs.Uuid#g:method:newV5"), [toString]("GI.Vte.Structs.Uuid#g:method:toString").
    --
    -- ==== Getters
    -- /None/.
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveUuidMethod                       ,
    #endif

    -- ** dup #method:dup#

    #if defined(ENABLE_OVERLOADING)
        UuidDupMethodInfo                       ,
    #endif
        uuidDup                                 ,

    -- ** equal #method:equal#

    #if defined(ENABLE_OVERLOADING)
        UuidEqualMethodInfo                     ,
    #endif
        uuidEqual                               ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        UuidFreeMethodInfo                      ,
    #endif
        uuidFree                                ,

    -- ** freeToString #method:freeToString#

    #if defined(ENABLE_OVERLOADING)
        UuidFreeToStringMethodInfo              ,
    #endif
        uuidFreeToString                        ,

    -- ** newFromString #method:newFromString#

        uuidNewFromString                       ,

    -- ** newV4 #method:newV4#

        uuidNewV4                               ,

    -- ** newV5 #method:newV5#

    #if defined(ENABLE_OVERLOADING)
        UuidNewV5MethodInfo                     ,
    #endif
        uuidNewV5                               ,

    -- ** toString #method:toString#

    #if defined(ENABLE_OVERLOADING)
        UuidToStringMethodInfo                  ,
    #endif
        uuidToString                            ,

    -- ** validateString #method:validateString#

        uuidValidateString                      ,

        ) 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)
    import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags

    #else
    import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags

    #endif

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

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

    foreign import ccall "vte_uuid_get_type" c_vte_uuid_get_type ::
        IO GType

    type instance O.ParentTypes Uuid = '[]
    instance O.HasParentTypes Uuid

    instance B.Types.TypedObject Uuid where
        glibType :: IO GType
    glibType = IO GType
    c_vte_uuid_get_type

    instance B.Types.GBoxed Uuid

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

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

    -- method Uuid::new_from_string
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "str"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "len"
    --           , argType = TBasicType TSSize
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "fmt"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "UuidFormat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Uuid" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_new_from_string" vte_uuid_new_from_string ::
        CString ->                              -- str : TBasicType TUTF8
        DI.Int64 ->                             -- len : TBasicType TSSize
        CUInt ->                                -- fmt : TInterface (Name {namespace = "Vte", name = "UuidFormat"})
        IO (Ptr Uuid)

    -- | /No description available in the introspection data./
    uuidNewFromString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -> DI.Int64
        -> [Vte.Flags.UuidFormat]
        -> m Uuid
    uuidNewFromString :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Int64 -> [UuidFormat] -> m Uuid
    uuidNewFromString Text
    str Int64
    len [UuidFormat]
    fmt = IO Uuid -> m Uuid
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Uuid -> m Uuid) -> IO Uuid -> m Uuid
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    str' <- Text -> IO CString
    textToCString Text
    str
        let fmt' :: CUInt
    fmt' = [UuidFormat] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [UuidFormat]
    fmt
        Ptr Uuid
    result <- CString -> Int64 -> CUInt -> IO (Ptr Uuid)
    vte_uuid_new_from_string CString
    str' Int64
    len CUInt
    fmt'
        Text -> Ptr Uuid -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "uuidNewFromString" Ptr Uuid
    result
        Uuid
    result' <- ((ManagedPtr Uuid -> Uuid) -> Ptr Uuid -> IO Uuid
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Uuid -> Uuid
    Uuid) Ptr Uuid
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    str'
        Uuid -> IO Uuid
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Uuid
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Uuid::new_v4
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Uuid" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_new_v4" vte_uuid_new_v4 ::
        IO (Ptr Uuid)

    -- | /No description available in the introspection data./
    uuidNewV4 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Uuid
    uuidNewV4 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Uuid
    uuidNewV4  = IO Uuid -> m Uuid
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Uuid -> m Uuid) -> IO Uuid -> m Uuid
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    result <- IO (Ptr Uuid)
    vte_uuid_new_v4
        Text -> Ptr Uuid -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "uuidNewV4" Ptr Uuid
    result
        Uuid
    result' <- ((ManagedPtr Uuid -> Uuid) -> Ptr Uuid -> IO Uuid
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Uuid -> Uuid
    Uuid) Ptr Uuid
    result
        Uuid -> IO Uuid
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Uuid
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Uuid::dup
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "uuid"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Uuid" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_dup" vte_uuid_dup ::
        Ptr Uuid ->                             -- uuid : TInterface (Name {namespace = "Vte", name = "Uuid"})
        IO (Ptr Uuid)

    -- | /No description available in the introspection data./
    uuidDup ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Uuid
        -> m Uuid
    uuidDup :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Uuid -> m Uuid
    uuidDup Uuid
    uuid = IO Uuid -> m Uuid
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Uuid -> m Uuid) -> IO Uuid -> m Uuid
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    uuid' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    uuid
        Ptr Uuid
    result <- Ptr Uuid -> IO (Ptr Uuid)
    vte_uuid_dup Ptr Uuid
    uuid'
        Text -> Ptr Uuid -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "uuidDup" Ptr Uuid
    result
        Uuid
    result' <- ((ManagedPtr Uuid -> Uuid) -> Ptr Uuid -> IO Uuid
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Uuid -> Uuid
    Uuid) Ptr Uuid
    result
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    uuid
        Uuid -> IO Uuid
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Uuid
    result'

    #if defined(ENABLE_OVERLOADING)
    data UuidDupMethodInfo
    instance (signature ~ (m Uuid), MonadIO m) => O.OverloadedMethod UuidDupMethodInfo Uuid signature where
        overloadedMethod = uuidDup

    instance O.OverloadedMethodInfo UuidDupMethodInfo Uuid where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Uuid.uuidDup",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Structs-Uuid.html#v:uuidDup"
            })

    #endif

    -- method Uuid::equal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "uuid"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "other"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_equal" vte_uuid_equal ::
        Ptr Uuid ->                             -- uuid : TInterface (Name {namespace = "Vte", name = "Uuid"})
        Ptr Uuid ->                             -- other : TInterface (Name {namespace = "Vte", name = "Uuid"})
        IO CInt

    -- | /No description available in the introspection data./
    uuidEqual ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Uuid
        -> Uuid
        -> m Bool
    uuidEqual :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Uuid -> Uuid -> m Bool
    uuidEqual Uuid
    uuid Uuid
    other = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    uuid' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    uuid
        Ptr Uuid
    other' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    other
        CInt
    result <- Ptr Uuid -> Ptr Uuid -> IO CInt
    vte_uuid_equal Ptr Uuid
    uuid' Ptr Uuid
    other'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    uuid
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    other
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data UuidEqualMethodInfo
    instance (signature ~ (Uuid -> m Bool), MonadIO m) => O.OverloadedMethod UuidEqualMethodInfo Uuid signature where
        overloadedMethod = uuidEqual

    instance O.OverloadedMethodInfo UuidEqualMethodInfo Uuid where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Uuid.uuidEqual",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Structs-Uuid.html#v:uuidEqual"
            })

    #endif

    -- method Uuid::free
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "uuid"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_free" vte_uuid_free ::
        Ptr Uuid ->                             -- uuid : TInterface (Name {namespace = "Vte", name = "Uuid"})
        IO ()

    -- | /No description available in the introspection data./
    uuidFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Uuid
        -> m ()
    uuidFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Uuid -> m ()
    uuidFree Uuid
    uuid = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    uuid' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    uuid
        Ptr Uuid -> IO ()
    vte_uuid_free Ptr Uuid
    uuid'
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    uuid
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data UuidFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod UuidFreeMethodInfo Uuid signature where
        overloadedMethod = uuidFree

    instance O.OverloadedMethodInfo UuidFreeMethodInfo Uuid where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Uuid.uuidFree",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Structs-Uuid.html#v:uuidFree"
            })

    #endif

    -- method Uuid::free_to_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "uuid"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "fmt"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "UuidFormat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "len"
    --           , argType = TBasicType TSize
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_free_to_string" vte_uuid_free_to_string ::
        Ptr Uuid ->                             -- uuid : TInterface (Name {namespace = "Vte", name = "Uuid"})
        CUInt ->                                -- fmt : TInterface (Name {namespace = "Vte", name = "UuidFormat"})
        FCT.CSize ->                            -- len : TBasicType TSize
        IO CString

    -- | /No description available in the introspection data./
    uuidFreeToString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Uuid
        -> [Vte.Flags.UuidFormat]
        -> FCT.CSize
        -> m T.Text
    uuidFreeToString :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Uuid -> [UuidFormat] -> CSize -> m Text
    uuidFreeToString Uuid
    uuid [UuidFormat]
    fmt CSize
    len = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    uuid' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    uuid
        let fmt' :: CUInt
    fmt' = [UuidFormat] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [UuidFormat]
    fmt
        CString
    result <- Ptr Uuid -> CUInt -> CSize -> IO CString
    vte_uuid_free_to_string Ptr Uuid
    uuid' CUInt
    fmt' CSize
    len
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "uuidFreeToString" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    uuid
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data UuidFreeToStringMethodInfo
    instance (signature ~ ([Vte.Flags.UuidFormat] -> FCT.CSize -> m T.Text), MonadIO m) => O.OverloadedMethod UuidFreeToStringMethodInfo Uuid signature where
        overloadedMethod = uuidFreeToString

    instance O.OverloadedMethodInfo UuidFreeToStringMethodInfo Uuid where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Uuid.uuidFreeToString",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Structs-Uuid.html#v:uuidFreeToString"
            })

    #endif

    -- method Uuid::new_v5
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "ns"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "data"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "len"
    --           , argType = TBasicType TSSize
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Uuid" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_new_v5" vte_uuid_new_v5 ::
        Ptr Uuid ->                             -- ns : TInterface (Name {namespace = "Vte", name = "Uuid"})
        CString ->                              -- data : TBasicType TUTF8
        DI.Int64 ->                             -- len : TBasicType TSSize
        IO (Ptr Uuid)

    -- | /No description available in the introspection data./
    uuidNewV5 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Uuid
        -> T.Text
        -> DI.Int64
        -> m Uuid
    uuidNewV5 :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Uuid -> Text -> Int64 -> m Uuid
    uuidNewV5 Uuid
    ns Text
    data_ Int64
    len = IO Uuid -> m Uuid
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Uuid -> m Uuid) -> IO Uuid -> m Uuid
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    ns' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    ns
        CString
    data_' <- Text -> IO CString
    textToCString Text
    data_
        Ptr Uuid
    result <- Ptr Uuid -> CString -> Int64 -> IO (Ptr Uuid)
    vte_uuid_new_v5 Ptr Uuid
    ns' CString
    data_' Int64
    len
        Text -> Ptr Uuid -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "uuidNewV5" Ptr Uuid
    result
        Uuid
    result' <- ((ManagedPtr Uuid -> Uuid) -> Ptr Uuid -> IO Uuid
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Uuid -> Uuid
    Uuid) Ptr Uuid
    result
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    ns
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    data_'
        Uuid -> IO Uuid
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Uuid
    result'

    #if defined(ENABLE_OVERLOADING)
    data UuidNewV5MethodInfo
    instance (signature ~ (T.Text -> DI.Int64 -> m Uuid), MonadIO m) => O.OverloadedMethod UuidNewV5MethodInfo Uuid signature where
        overloadedMethod = uuidNewV5

    instance O.OverloadedMethodInfo UuidNewV5MethodInfo Uuid where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Uuid.uuidNewV5",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Structs-Uuid.html#v:uuidNewV5"
            })

    #endif

    -- method Uuid::to_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "uuid"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Uuid" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "fmt"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "UuidFormat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "len"
    --           , argType = TBasicType TSize
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_to_string" vte_uuid_to_string ::
        Ptr Uuid ->                             -- uuid : TInterface (Name {namespace = "Vte", name = "Uuid"})
        CUInt ->                                -- fmt : TInterface (Name {namespace = "Vte", name = "UuidFormat"})
        FCT.CSize ->                            -- len : TBasicType TSize
        IO CString

    -- | /No description available in the introspection data./
    uuidToString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Uuid
        -> [Vte.Flags.UuidFormat]
        -> FCT.CSize
        -> m T.Text
    uuidToString :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Uuid -> [UuidFormat] -> CSize -> m Text
    uuidToString Uuid
    uuid [UuidFormat]
    fmt CSize
    len = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Uuid
    uuid' <- Uuid -> IO (Ptr Uuid)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Uuid
    uuid
        let fmt' :: CUInt
    fmt' = [UuidFormat] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [UuidFormat]
    fmt
        CString
    result <- Ptr Uuid -> CUInt -> CSize -> IO CString
    vte_uuid_to_string Ptr Uuid
    uuid' CUInt
    fmt' CSize
    len
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "uuidToString" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        Uuid -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Uuid
    uuid
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data UuidToStringMethodInfo
    instance (signature ~ ([Vte.Flags.UuidFormat] -> FCT.CSize -> m T.Text), MonadIO m) => O.OverloadedMethod UuidToStringMethodInfo Uuid signature where
        overloadedMethod = uuidToString

    instance O.OverloadedMethodInfo UuidToStringMethodInfo Uuid where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Uuid.uuidToString",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Structs-Uuid.html#v:uuidToString"
            })

    #endif

    -- method Uuid::validate_string
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "str"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "len"
    --           , argType = TBasicType TSSize
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "fmt"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "UuidFormat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_uuid_validate_string" vte_uuid_validate_string ::
        CString ->                              -- str : TBasicType TUTF8
        DI.Int64 ->                             -- len : TBasicType TSSize
        CUInt ->                                -- fmt : TInterface (Name {namespace = "Vte", name = "UuidFormat"})
        IO CInt

    -- | /No description available in the introspection data./
    uuidValidateString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -> DI.Int64
        -> [Vte.Flags.UuidFormat]
        -> m Bool
    uuidValidateString :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Int64 -> [UuidFormat] -> m Bool
    uuidValidateString Text
    str Int64
    len [UuidFormat]
    fmt = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    str' <- Text -> IO CString
    textToCString Text
    str
        let fmt' :: CUInt
    fmt' = [UuidFormat] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [UuidFormat]
    fmt
        CInt
    result <- CString -> Int64 -> CUInt -> IO CInt
    vte_uuid_validate_string CString
    str' Int64
    len CUInt
    fmt'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    str'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveUuidMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveUuidMethod "dup" o = UuidDupMethodInfo
        ResolveUuidMethod "equal" o = UuidEqualMethodInfo
        ResolveUuidMethod "free" o = UuidFreeMethodInfo
        ResolveUuidMethod "freeToString" o = UuidFreeToStringMethodInfo
        ResolveUuidMethod "newV5" o = UuidNewV5MethodInfo
        ResolveUuidMethod "toString" o = UuidToStringMethodInfo
        ResolveUuidMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif