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

    Holds a password used in TLS.

    /Since: 2.30/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.TlsPassword
        (

    -- * Exported types
        TlsPassword(..)                         ,
        IsTlsPassword                           ,
        toTlsPassword                           ,
        noTlsPassword                           ,

     -- * Methods
    -- ** getDescription #method:getDescription#

    #if ENABLE_OVERLOADING
        TlsPasswordGetDescriptionMethodInfo     ,
    #endif
        tlsPasswordGetDescription               ,

    -- ** getFlags #method:getFlags#

    #if ENABLE_OVERLOADING
        TlsPasswordGetFlagsMethodInfo           ,
    #endif
        tlsPasswordGetFlags                     ,

    -- ** getWarning #method:getWarning#

    #if ENABLE_OVERLOADING
        TlsPasswordGetWarningMethodInfo         ,
    #endif
        tlsPasswordGetWarning                   ,

    -- ** new #method:new#

        tlsPasswordNew                          ,

    -- ** setDescription #method:setDescription#

    #if ENABLE_OVERLOADING
        TlsPasswordSetDescriptionMethodInfo     ,
    #endif
        tlsPasswordSetDescription               ,

    -- ** setFlags #method:setFlags#

    #if ENABLE_OVERLOADING
        TlsPasswordSetFlagsMethodInfo           ,
    #endif
        tlsPasswordSetFlags                     ,

    -- ** setValue #method:setValue#

    #if ENABLE_OVERLOADING
        TlsPasswordSetValueMethodInfo           ,
    #endif
        tlsPasswordSetValue                     ,

    -- ** setValueFull #method:setValueFull#

    #if ENABLE_OVERLOADING
        TlsPasswordSetValueFullMethodInfo       ,
    #endif
        tlsPasswordSetValueFull                 ,

    -- ** setWarning #method:setWarning#

    #if ENABLE_OVERLOADING
        TlsPasswordSetWarningMethodInfo         ,
    #endif
        tlsPasswordSetWarning                   ,

     -- * Properties
    -- ** description #attr:description#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        TlsPasswordDescriptionPropertyInfo      ,
    #endif
        constructTlsPasswordDescription         ,
        getTlsPasswordDescription               ,
        setTlsPasswordDescription               ,
    #if ENABLE_OVERLOADING
        tlsPasswordDescription                  ,
    #endif

    -- ** flags #attr:flags#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        TlsPasswordFlagsPropertyInfo            ,
    #endif
        constructTlsPasswordFlags               ,
        getTlsPasswordFlags                     ,
        setTlsPasswordFlags                     ,
    #if ENABLE_OVERLOADING
        tlsPasswordFlags                        ,
    #endif

    -- ** warning #attr:warning#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        TlsPasswordWarningPropertyInfo          ,
    #endif
        constructTlsPasswordWarning             ,
        getTlsPasswordWarning                   ,
        setTlsPasswordWarning                   ,
    #if ENABLE_OVERLOADING
        tlsPasswordWarning                      ,
    #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.ManagedPtr as B.ManagedPtr
    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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags

    -- | Memory-managed wrapper type.
    newtype TlsPassword = TlsPassword (ManagedPtr TlsPassword)
    foreign import ccall "g_tls_password_get_type"
        c_g_tls_password_get_type :: IO GType

    instance GObject TlsPassword where
        gobjectType _ = c_g_tls_password_get_type

    -- | Type class for types which can be safely cast to `TlsPassword`, for instance with `toTlsPassword`.
    class GObject o => IsTlsPassword o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError TlsPassword a) =>
        IsTlsPassword a
    #endif
    instance IsTlsPassword TlsPassword
    instance GObject.Object.IsObject TlsPassword

    -- | Cast to `TlsPassword`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toTlsPassword :: (MonadIO m, IsTlsPassword o) => o -> m TlsPassword
    toTlsPassword = liftIO . unsafeCastTo TlsPassword

    -- | A convenience alias for `Nothing` :: `Maybe` `TlsPassword`.
    noTlsPassword :: Maybe TlsPassword
    noTlsPassword = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveTlsPasswordMethod (t :: Symbol) (o :: *) :: * where
        ResolveTlsPasswordMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTlsPasswordMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTlsPasswordMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTlsPasswordMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTlsPasswordMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTlsPasswordMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTlsPasswordMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTlsPasswordMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTlsPasswordMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTlsPasswordMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTlsPasswordMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTlsPasswordMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTlsPasswordMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTlsPasswordMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTlsPasswordMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTlsPasswordMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTlsPasswordMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTlsPasswordMethod "getDescription" o = TlsPasswordGetDescriptionMethodInfo
        ResolveTlsPasswordMethod "getFlags" o = TlsPasswordGetFlagsMethodInfo
        ResolveTlsPasswordMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTlsPasswordMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTlsPasswordMethod "getWarning" o = TlsPasswordGetWarningMethodInfo
        ResolveTlsPasswordMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTlsPasswordMethod "setDescription" o = TlsPasswordSetDescriptionMethodInfo
        ResolveTlsPasswordMethod "setFlags" o = TlsPasswordSetFlagsMethodInfo
        ResolveTlsPasswordMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTlsPasswordMethod "setValue" o = TlsPasswordSetValueMethodInfo
        ResolveTlsPasswordMethod "setValueFull" o = TlsPasswordSetValueFullMethodInfo
        ResolveTlsPasswordMethod "setWarning" o = TlsPasswordSetWarningMethodInfo
        ResolveTlsPasswordMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveTlsPasswordMethod t TlsPassword, O.MethodInfo info TlsPassword p) => O.IsLabelProxy t (TlsPassword -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

    #endif

    -- VVV Prop "description"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    @
    'Data.GI.Base.Attributes.get' tlsPassword #description
    @
    -}
    getTlsPasswordDescription :: (MonadIO m, IsTlsPassword o) => o -> m T.Text
    getTlsPasswordDescription obj = liftIO $ checkUnexpectedNothing "getTlsPasswordDescription" $ getObjectPropertyString obj "description"

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

    @
    'Data.GI.Base.Attributes.set' tlsPassword [ #description 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setTlsPasswordDescription :: (MonadIO m, IsTlsPassword o) => o -> T.Text -> m ()
    setTlsPasswordDescription obj val = liftIO $ setObjectPropertyString obj "description" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructTlsPasswordDescription :: (IsTlsPassword o) => T.Text -> IO (GValueConstruct o)
    constructTlsPasswordDescription val = constructObjectPropertyString "description" (Just val)

    #if ENABLE_OVERLOADING
    data TlsPasswordDescriptionPropertyInfo
    instance AttrInfo TlsPasswordDescriptionPropertyInfo where
        type AttrAllowedOps TlsPasswordDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint TlsPasswordDescriptionPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint TlsPasswordDescriptionPropertyInfo = IsTlsPassword
        type AttrGetType TlsPasswordDescriptionPropertyInfo = T.Text
        type AttrLabel TlsPasswordDescriptionPropertyInfo = "description"
        type AttrOrigin TlsPasswordDescriptionPropertyInfo = TlsPassword
        attrGet _ = getTlsPasswordDescription
        attrSet _ = setTlsPasswordDescription
        attrConstruct _ = constructTlsPasswordDescription
        attrClear _ = undefined
    #endif

    -- VVV Prop "flags"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsPasswordFlags"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    @
    'Data.GI.Base.Attributes.get' tlsPassword #flags
    @
    -}
    getTlsPasswordFlags :: (MonadIO m, IsTlsPassword o) => o -> m [Gio.Flags.TlsPasswordFlags]
    getTlsPasswordFlags obj = liftIO $ getObjectPropertyFlags obj "flags"

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

    @
    'Data.GI.Base.Attributes.set' tlsPassword [ #flags 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setTlsPasswordFlags :: (MonadIO m, IsTlsPassword o) => o -> [Gio.Flags.TlsPasswordFlags] -> m ()
    setTlsPasswordFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructTlsPasswordFlags :: (IsTlsPassword o) => [Gio.Flags.TlsPasswordFlags] -> IO (GValueConstruct o)
    constructTlsPasswordFlags val = constructObjectPropertyFlags "flags" val

    #if ENABLE_OVERLOADING
    data TlsPasswordFlagsPropertyInfo
    instance AttrInfo TlsPasswordFlagsPropertyInfo where
        type AttrAllowedOps TlsPasswordFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint TlsPasswordFlagsPropertyInfo = (~) [Gio.Flags.TlsPasswordFlags]
        type AttrBaseTypeConstraint TlsPasswordFlagsPropertyInfo = IsTlsPassword
        type AttrGetType TlsPasswordFlagsPropertyInfo = [Gio.Flags.TlsPasswordFlags]
        type AttrLabel TlsPasswordFlagsPropertyInfo = "flags"
        type AttrOrigin TlsPasswordFlagsPropertyInfo = TlsPassword
        attrGet _ = getTlsPasswordFlags
        attrSet _ = setTlsPasswordFlags
        attrConstruct _ = constructTlsPasswordFlags
        attrClear _ = undefined
    #endif

    -- VVV Prop "warning"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    @
    'Data.GI.Base.Attributes.get' tlsPassword #warning
    @
    -}
    getTlsPasswordWarning :: (MonadIO m, IsTlsPassword o) => o -> m T.Text
    getTlsPasswordWarning obj = liftIO $ checkUnexpectedNothing "getTlsPasswordWarning" $ getObjectPropertyString obj "warning"

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

    @
    'Data.GI.Base.Attributes.set' tlsPassword [ #warning 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setTlsPasswordWarning :: (MonadIO m, IsTlsPassword o) => o -> T.Text -> m ()
    setTlsPasswordWarning obj val = liftIO $ setObjectPropertyString obj "warning" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@warning@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructTlsPasswordWarning :: (IsTlsPassword o) => T.Text -> IO (GValueConstruct o)
    constructTlsPasswordWarning val = constructObjectPropertyString "warning" (Just val)

    #if ENABLE_OVERLOADING
    data TlsPasswordWarningPropertyInfo
    instance AttrInfo TlsPasswordWarningPropertyInfo where
        type AttrAllowedOps TlsPasswordWarningPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint TlsPasswordWarningPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint TlsPasswordWarningPropertyInfo = IsTlsPassword
        type AttrGetType TlsPasswordWarningPropertyInfo = T.Text
        type AttrLabel TlsPasswordWarningPropertyInfo = "warning"
        type AttrOrigin TlsPasswordWarningPropertyInfo = TlsPassword
        attrGet _ = getTlsPasswordWarning
        attrSet _ = setTlsPasswordWarning
        attrConstruct _ = constructTlsPasswordWarning
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList TlsPassword
    type instance O.AttributeList TlsPassword = TlsPasswordAttributeList
    type TlsPasswordAttributeList = ('[ '("description", TlsPasswordDescriptionPropertyInfo), '("flags", TlsPasswordFlagsPropertyInfo), '("warning", TlsPasswordWarningPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    tlsPasswordDescription :: AttrLabelProxy "description"
    tlsPasswordDescription = AttrLabelProxy

    tlsPasswordFlags :: AttrLabelProxy "flags"
    tlsPasswordFlags = AttrLabelProxy

    tlsPasswordWarning :: AttrLabelProxy "warning"
    tlsPasswordWarning = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList TlsPassword = TlsPasswordSignalList
    type TlsPasswordSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method TlsPassword::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsPasswordFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the password flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "description of what the password is for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsPassword"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_new" g_tls_password_new ::
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsPasswordFlags"})
        CString ->                              -- description : TBasicType TUTF8
        IO (Ptr TlsPassword)

    {- |
    Create a new 'GI.Gio.Objects.TlsPassword.TlsPassword' object.
    -}
    tlsPasswordNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        [Gio.Flags.TlsPasswordFlags]
        {- ^ /@flags@/: the password flags -}
        -> T.Text
        {- ^ /@description@/: description of what the password is for -}
        -> m TlsPassword
        {- ^ __Returns:__ The newly allocated password object -}
    tlsPasswordNew flags description = liftIO $ do
        let flags' = gflagsToWord flags
        description' <- textToCString description
        result <- g_tls_password_new flags' description'
        checkUnexpectedReturnNULL "tlsPasswordNew" result
        result' <- (wrapObject TlsPassword) result
        freeMem description'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method TlsPassword::get_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_get_description" g_tls_password_get_description ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        IO CString

    {- |
    Get a description string about what the password will be used for.

    /Since: 2.30/
    -}
    tlsPasswordGetDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> m T.Text
        {- ^ __Returns:__ The description of the password. -}
    tlsPasswordGetDescription password = liftIO $ do
        password' <- unsafeManagedPtrCastPtr password
        result <- g_tls_password_get_description password'
        checkUnexpectedReturnNULL "tlsPasswordGetDescription" result
        result' <- cstringToText result
        touchManagedPtr password
        return result'

    #if ENABLE_OVERLOADING
    data TlsPasswordGetDescriptionMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordGetDescriptionMethodInfo a signature where
        overloadedMethod _ = tlsPasswordGetDescription

    #endif

    -- method TlsPassword::get_flags
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsPasswordFlags"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_get_flags" g_tls_password_get_flags ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        IO CUInt

    {- |
    Get flags about the password.

    /Since: 2.30/
    -}
    tlsPasswordGetFlags ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> m [Gio.Flags.TlsPasswordFlags]
        {- ^ __Returns:__ The flags about the password. -}
    tlsPasswordGetFlags password = liftIO $ do
        password' <- unsafeManagedPtrCastPtr password
        result <- g_tls_password_get_flags password'
        let result' = wordToGFlags result
        touchManagedPtr password
        return result'

    #if ENABLE_OVERLOADING
    data TlsPasswordGetFlagsMethodInfo
    instance (signature ~ (m [Gio.Flags.TlsPasswordFlags]), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordGetFlagsMethodInfo a signature where
        overloadedMethod _ = tlsPasswordGetFlags

    #endif

    -- method TlsPassword::get_warning
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_get_warning" g_tls_password_get_warning ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        IO CString

    {- |
    Get a user readable translated warning. Usually this warning is a
    representation of the password flags returned from
    'GI.Gio.Objects.TlsPassword.tlsPasswordGetFlags'.

    /Since: 2.30/
    -}
    tlsPasswordGetWarning ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> m T.Text
        {- ^ __Returns:__ The warning. -}
    tlsPasswordGetWarning password = liftIO $ do
        password' <- unsafeManagedPtrCastPtr password
        result <- g_tls_password_get_warning password'
        checkUnexpectedReturnNULL "tlsPasswordGetWarning" result
        result' <- cstringToText result
        touchManagedPtr password
        return result'

    #if ENABLE_OVERLOADING
    data TlsPasswordGetWarningMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordGetWarningMethodInfo a signature where
        overloadedMethod _ = tlsPasswordGetWarning

    #endif

    -- method TlsPassword::set_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The description of the password", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_set_description" g_tls_password_set_description ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        CString ->                              -- description : TBasicType TUTF8
        IO ()

    {- |
    Set a description string about what the password will be used for.

    /Since: 2.30/
    -}
    tlsPasswordSetDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> T.Text
        {- ^ /@description@/: The description of the password -}
        -> m ()
    tlsPasswordSetDescription password description = liftIO $ do
        password' <- unsafeManagedPtrCastPtr password
        description' <- textToCString description
        g_tls_password_set_description password' description'
        touchManagedPtr password
        freeMem description'
        return ()

    #if ENABLE_OVERLOADING
    data TlsPasswordSetDescriptionMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordSetDescriptionMethodInfo a signature where
        overloadedMethod _ = tlsPasswordSetDescription

    #endif

    -- method TlsPassword::set_flags
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsPasswordFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The flags about the password", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_set_flags" g_tls_password_set_flags ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsPasswordFlags"})
        IO ()

    {- |
    Set flags about the password.

    /Since: 2.30/
    -}
    tlsPasswordSetFlags ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> [Gio.Flags.TlsPasswordFlags]
        {- ^ /@flags@/: The flags about the password -}
        -> m ()
    tlsPasswordSetFlags password flags = liftIO $ do
        password' <- unsafeManagedPtrCastPtr password
        let flags' = gflagsToWord flags
        g_tls_password_set_flags password' flags'
        touchManagedPtr password
        return ()

    #if ENABLE_OVERLOADING
    data TlsPasswordSetFlagsMethodInfo
    instance (signature ~ ([Gio.Flags.TlsPasswordFlags] -> m ()), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordSetFlagsMethodInfo a signature where
        overloadedMethod _ = tlsPasswordSetFlags

    #endif

    -- method TlsPassword::set_value
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new password value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the password, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the password, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_set_value" g_tls_password_set_value ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        Ptr Word8 ->                            -- value : TCArray False (-1) 2 (TBasicType TUInt8)
        Int64 ->                                -- length : TBasicType TInt64
        IO ()

    {- |
    Set the value for this password. The /@value@/ will be copied by the password
    object.

    Specify the /@length@/, for a non-nul-terminated password. Pass -1 as
    /@length@/ if using a nul-terminated password, and /@length@/ will be
    calculated automatically. (Note that the terminating nul is not
    considered part of the password in this case.)

    /Since: 2.30/
    -}
    tlsPasswordSetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> ByteString
        {- ^ /@value@/: the new password value -}
        -> m ()
    tlsPasswordSetValue password value = liftIO $ do
        let length_ = fromIntegral $ B.length value
        password' <- unsafeManagedPtrCastPtr password
        value' <- packByteString value
        g_tls_password_set_value password' value' length_
        touchManagedPtr password
        freeMem value'
        return ()

    #if ENABLE_OVERLOADING
    data TlsPasswordSetValueMethodInfo
    instance (signature ~ (ByteString -> m ()), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordSetValueMethodInfo a signature where
        overloadedMethod _ = tlsPasswordSetValue

    #endif

    -- method TlsPassword::set_value_full
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value for the password", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the password, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a function to use to free the password.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the password, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_set_value_full" g_tls_password_set_value_full ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        Ptr Word8 ->                            -- value : TCArray False (-1) 2 (TBasicType TUInt8)
        Int64 ->                                -- length : TBasicType TInt64
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO ()

    {- |
    Provide the value for this password.

    The /@value@/ will be owned by the password object, and later freed using
    the /@destroy@/ function callback.

    Specify the /@length@/, for a non-nul-terminated password. Pass -1 as
    /@length@/ if using a nul-terminated password, and /@length@/ will be
    calculated automatically. (Note that the terminating nul is not
    considered part of the password in this case.)

    /Since: 2.30/
    -}
    tlsPasswordSetValueFull ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> ByteString
        {- ^ /@value@/: the value for the password -}
        -> Maybe (GLib.Callbacks.DestroyNotify)
        {- ^ /@destroy@/: a function to use to free the password. -}
        -> m ()
    tlsPasswordSetValueFull password value destroy = liftIO $ do
        let length_ = fromIntegral $ B.length value
        password' <- unsafeManagedPtrCastPtr password
        value' <- packByteString value
        maybeDestroy <- case destroy of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jDestroy -> do
                ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
                jDestroy' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdestroy) jDestroy)
                poke ptrdestroy jDestroy'
                return jDestroy'
        g_tls_password_set_value_full password' value' length_ maybeDestroy
        touchManagedPtr password
        freeMem value'
        return ()

    #if ENABLE_OVERLOADING
    data TlsPasswordSetValueFullMethodInfo
    instance (signature ~ (ByteString -> Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordSetValueFullMethodInfo a signature where
        overloadedMethod _ = tlsPasswordSetValueFull

    #endif

    -- method TlsPassword::set_warning
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "password", argType = TInterface (Name {namespace = "Gio", name = "TlsPassword"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsPassword object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "warning", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The user readable warning", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_password_set_warning" g_tls_password_set_warning ::
        Ptr TlsPassword ->                      -- password : TInterface (Name {namespace = "Gio", name = "TlsPassword"})
        CString ->                              -- warning : TBasicType TUTF8
        IO ()

    {- |
    Set a user readable translated warning. Usually this warning is a
    representation of the password flags returned from
    'GI.Gio.Objects.TlsPassword.tlsPasswordGetFlags'.

    /Since: 2.30/
    -}
    tlsPasswordSetWarning ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsPassword a) =>
        a
        {- ^ /@password@/: a 'GI.Gio.Objects.TlsPassword.TlsPassword' object -}
        -> T.Text
        {- ^ /@warning@/: The user readable warning -}
        -> m ()
    tlsPasswordSetWarning password warning = liftIO $ do
        password' <- unsafeManagedPtrCastPtr password
        warning' <- textToCString warning
        g_tls_password_set_warning password' warning'
        touchManagedPtr password
        freeMem warning'
        return ()

    #if ENABLE_OVERLOADING
    data TlsPasswordSetWarningMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsTlsPassword a) => O.MethodInfo TlsPasswordSetWarningMethodInfo a signature where
        overloadedMethod _ = tlsPasswordSetWarning

    #endif