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

'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' is an opaque data structure and can only be accessed
using the following functions.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Gio.Structs.SettingsSchemaKey
    ( 

-- * Exported types
    SettingsSchemaKey(..)                   ,
    noSettingsSchemaKey                     ,


 -- * Methods
-- ** getDefaultValue #method:getDefaultValue#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyGetDefaultValueMethodInfo,
#endif
    settingsSchemaKeyGetDefaultValue        ,


-- ** getDescription #method:getDescription#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyGetDescriptionMethodInfo,
#endif
    settingsSchemaKeyGetDescription         ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyGetNameMethodInfo      ,
#endif
    settingsSchemaKeyGetName                ,


-- ** getRange #method:getRange#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyGetRangeMethodInfo     ,
#endif
    settingsSchemaKeyGetRange               ,


-- ** getSummary #method:getSummary#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyGetSummaryMethodInfo   ,
#endif
    settingsSchemaKeyGetSummary             ,


-- ** getValueType #method:getValueType#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyGetValueTypeMethodInfo ,
#endif
    settingsSchemaKeyGetValueType           ,


-- ** rangeCheck #method:rangeCheck#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyRangeCheckMethodInfo   ,
#endif
    settingsSchemaKeyRangeCheck             ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyRefMethodInfo          ,
#endif
    settingsSchemaKeyRef                    ,


-- ** unref #method:unref#

#if ENABLE_OVERLOADING
    SettingsSchemaKeyUnrefMethodInfo        ,
#endif
    settingsSchemaKeyUnref                  ,




    ) 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.Structs.VariantType as GLib.VariantType

-- | Memory-managed wrapper type.
newtype SettingsSchemaKey = SettingsSchemaKey (ManagedPtr SettingsSchemaKey)
foreign import ccall "g_settings_schema_key_get_type" c_g_settings_schema_key_get_type :: 
    IO GType

instance BoxedObject SettingsSchemaKey where
    boxedType :: SettingsSchemaKey -> IO GType
boxedType _ = IO GType
c_g_settings_schema_key_get_type

-- | A convenience alias for `Nothing` :: `Maybe` `SettingsSchemaKey`.
noSettingsSchemaKey :: Maybe SettingsSchemaKey
noSettingsSchemaKey :: Maybe SettingsSchemaKey
noSettingsSchemaKey = Maybe SettingsSchemaKey
forall a. Maybe a
Nothing


#if ENABLE_OVERLOADING
instance O.HasAttributeList SettingsSchemaKey
type instance O.AttributeList SettingsSchemaKey = SettingsSchemaKeyAttributeList
type SettingsSchemaKeyAttributeList = ('[ ] :: [(Symbol, *)])
#endif

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

foreign import ccall "g_settings_schema_key_get_default_value" g_settings_schema_key_get_default_value :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO (Ptr GVariant)

{- |
Gets the default value for /@key@/.

Note that this is the default value according to the schema.  System
administrator defaults and lockdown are not visible via this API.

/Since: 2.40/
-}
settingsSchemaKeyGetDefaultValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m GVariant
    {- ^ __Returns:__ the default value for the key -}
settingsSchemaKeyGetDefaultValue :: SettingsSchemaKey -> m GVariant
settingsSchemaKeyGetDefaultValue key :: SettingsSchemaKey
key = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    Ptr GVariant
result <- Ptr SettingsSchemaKey -> IO (Ptr GVariant)
g_settings_schema_key_get_default_value Ptr SettingsSchemaKey
key'
    Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyGetDefaultValue" Ptr GVariant
result
    GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyGetDefaultValueMethodInfo
instance (signature ~ (m GVariant), MonadIO m) => O.MethodInfo SettingsSchemaKeyGetDefaultValueMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyGetDefaultValue

#endif

-- method SettingsSchemaKey::get_description
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "key", argType = TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSettingsSchemaKey", 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_settings_schema_key_get_description" g_settings_schema_key_get_description :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO CString

{- |
Gets the description for /@key@/.

If no description has been provided in the schema for /@key@/, returns
'Nothing'.

The description can be one sentence to several paragraphs in length.
Paragraphs are delimited with a double newline.  Descriptions can be
translated and the value returned from this function is is the
current locale.

This function is slow.  The summary and description information for
the schemas is not stored in the compiled schema database so this
function has to parse all of the source XML files in the schema
directory.

/Since: 2.34/
-}
settingsSchemaKeyGetDescription ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m T.Text
    {- ^ __Returns:__ the description for /@key@/, or 'Nothing' -}
settingsSchemaKeyGetDescription :: SettingsSchemaKey -> m Text
settingsSchemaKeyGetDescription key :: SettingsSchemaKey
key = IO Text -> m Text
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 SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    CString
result <- Ptr SettingsSchemaKey -> IO CString
g_settings_schema_key_get_description Ptr SettingsSchemaKey
key'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyGetDescription" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo SettingsSchemaKeyGetDescriptionMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyGetDescription

#endif

-- method SettingsSchemaKey::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "key", argType = TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSettingsSchemaKey", 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_settings_schema_key_get_name" g_settings_schema_key_get_name :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO CString

{- |
Gets the name of /@key@/.

/Since: 2.44/
-}
settingsSchemaKeyGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m T.Text
    {- ^ __Returns:__ the name of /@key@/. -}
settingsSchemaKeyGetName :: SettingsSchemaKey -> m Text
settingsSchemaKeyGetName key :: SettingsSchemaKey
key = IO Text -> m Text
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 SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    CString
result <- Ptr SettingsSchemaKey -> IO CString
g_settings_schema_key_get_name Ptr SettingsSchemaKey
key'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo SettingsSchemaKeyGetNameMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyGetName

#endif

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

foreign import ccall "g_settings_schema_key_get_range" g_settings_schema_key_get_range :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO (Ptr GVariant)

{- |
Queries the range of a key.

This function will return a 'GVariant' that fully describes the range
of values that are valid for /@key@/.

The type of 'GVariant' returned is @(sv)@. The string describes
the type of range restriction in effect. The type and meaning of
the value contained in the variant depends on the string.

If the string is @\'type\'@ then the variant contains an empty array.
The element type of that empty array is the expected type of value
and all values of that type are valid.

If the string is @\'enum\'@ then the variant contains an array
enumerating the possible values. Each item in the array is
a possible valid value and no other values are valid.

If the string is @\'flags\'@ then the variant contains an array. Each
item in the array is a value that may appear zero or one times in an
array to be used as the value for this key. For example, if the
variant contained the array @[\'x\', \'y\']@ then the valid values for
the key would be @[]@, @[\'x\']@, @[\'y\']@, @[\'x\', \'y\']@ and
@[\'y\', \'x\']@.

Finally, if the string is @\'range\'@ then the variant contains a pair
of like-typed values -- the minimum and maximum permissible values
for this key.

This information should not be used by normal programs.  It is
considered to be a hint for introspection purposes.  Normal programs
should already know what is permitted by their own schema.  The
format may change in any way in the future -- but particularly, new
forms may be added to the possibilities described above.

You should free the returned value with 'GI.GLib.Structs.Variant.variantUnref' when it is
no longer needed.

/Since: 2.40/
-}
settingsSchemaKeyGetRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m GVariant
    {- ^ __Returns:__ a 'GVariant' describing the range -}
settingsSchemaKeyGetRange :: SettingsSchemaKey -> m GVariant
settingsSchemaKeyGetRange key :: SettingsSchemaKey
key = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    Ptr GVariant
result <- Ptr SettingsSchemaKey -> IO (Ptr GVariant)
g_settings_schema_key_get_range Ptr SettingsSchemaKey
key'
    Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyGetRange" Ptr GVariant
result
    GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyGetRangeMethodInfo
instance (signature ~ (m GVariant), MonadIO m) => O.MethodInfo SettingsSchemaKeyGetRangeMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyGetRange

#endif

-- method SettingsSchemaKey::get_summary
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "key", argType = TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSettingsSchemaKey", 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_settings_schema_key_get_summary" g_settings_schema_key_get_summary :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO CString

{- |
Gets the summary for /@key@/.

If no summary has been provided in the schema for /@key@/, returns
'Nothing'.

The summary is a short description of the purpose of the key; usually
one short sentence.  Summaries can be translated and the value
returned from this function is is the current locale.

This function is slow.  The summary and description information for
the schemas is not stored in the compiled schema database so this
function has to parse all of the source XML files in the schema
directory.

/Since: 2.34/
-}
settingsSchemaKeyGetSummary ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m T.Text
    {- ^ __Returns:__ the summary for /@key@/, or 'Nothing' -}
settingsSchemaKeyGetSummary :: SettingsSchemaKey -> m Text
settingsSchemaKeyGetSummary key :: SettingsSchemaKey
key = IO Text -> m Text
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 SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    CString
result <- Ptr SettingsSchemaKey -> IO CString
g_settings_schema_key_get_summary Ptr SettingsSchemaKey
key'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyGetSummary" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyGetSummaryMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo SettingsSchemaKeyGetSummaryMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyGetSummary

#endif

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

foreign import ccall "g_settings_schema_key_get_value_type" g_settings_schema_key_get_value_type :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO (Ptr GLib.VariantType.VariantType)

{- |
Gets the 'GI.GLib.Structs.VariantType.VariantType' of /@key@/.

/Since: 2.40/
-}
settingsSchemaKeyGetValueType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m GLib.VariantType.VariantType
    {- ^ __Returns:__ the type of /@key@/ -}
settingsSchemaKeyGetValueType :: SettingsSchemaKey -> m VariantType
settingsSchemaKeyGetValueType key :: SettingsSchemaKey
key = IO VariantType -> m VariantType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    Ptr VariantType
result <- Ptr SettingsSchemaKey -> IO (Ptr VariantType)
g_settings_schema_key_get_value_type Ptr SettingsSchemaKey
key'
    Text -> Ptr VariantType -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyGetValueType" Ptr VariantType
result
    VariantType
result' <- ((ManagedPtr VariantType -> VariantType)
-> Ptr VariantType -> IO VariantType
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType) Ptr VariantType
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    VariantType -> IO VariantType
forall (m :: * -> *) a. Monad m => a -> m a
return VariantType
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyGetValueTypeMethodInfo
instance (signature ~ (m GLib.VariantType.VariantType), MonadIO m) => O.MethodInfo SettingsSchemaKeyGetValueTypeMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyGetValueType

#endif

-- method SettingsSchemaKey::range_check
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "key", argType = TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSettingsSchemaKey", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_settings_schema_key_range_check" g_settings_schema_key_range_check :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    Ptr GVariant ->                         -- value : TVariant
    IO CInt

{- |
Checks if the given /@value@/ is of the correct type and within the
permitted range for /@key@/.

It is a programmer error if /@value@/ is not of the correct type -- you
must check for this first.

/Since: 2.40/
-}
settingsSchemaKeyRangeCheck ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> GVariant
    {- ^ /@value@/: the value to check -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@value@/ is valid for /@key@/ -}
settingsSchemaKeyRangeCheck :: SettingsSchemaKey -> GVariant -> m Bool
settingsSchemaKeyRangeCheck key :: SettingsSchemaKey
key value :: GVariant
value = IO Bool -> m Bool
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 SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
    CInt
result <- Ptr SettingsSchemaKey -> Ptr GVariant -> IO CInt
g_settings_schema_key_range_check Ptr SettingsSchemaKey
key' Ptr GVariant
value'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyRangeCheckMethodInfo
instance (signature ~ (GVariant -> m Bool), MonadIO m) => O.MethodInfo SettingsSchemaKeyRangeCheckMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyRangeCheck

#endif

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

foreign import ccall "g_settings_schema_key_ref" g_settings_schema_key_ref :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO (Ptr SettingsSchemaKey)

{- |
Increase the reference count of /@key@/, returning a new reference.

/Since: 2.40/
-}
settingsSchemaKeyRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m SettingsSchemaKey
    {- ^ __Returns:__ a new reference to /@key@/ -}
settingsSchemaKeyRef :: SettingsSchemaKey -> m SettingsSchemaKey
settingsSchemaKeyRef key :: SettingsSchemaKey
key = IO SettingsSchemaKey -> m SettingsSchemaKey
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SettingsSchemaKey -> m SettingsSchemaKey)
-> IO SettingsSchemaKey -> m SettingsSchemaKey
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    Ptr SettingsSchemaKey
result <- Ptr SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
g_settings_schema_key_ref Ptr SettingsSchemaKey
key'
    Text -> Ptr SettingsSchemaKey -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "settingsSchemaKeyRef" Ptr SettingsSchemaKey
result
    SettingsSchemaKey
result' <- ((ManagedPtr SettingsSchemaKey -> SettingsSchemaKey)
-> Ptr SettingsSchemaKey -> IO SettingsSchemaKey
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SettingsSchemaKey -> SettingsSchemaKey
SettingsSchemaKey) Ptr SettingsSchemaKey
result
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    SettingsSchemaKey -> IO SettingsSchemaKey
forall (m :: * -> *) a. Monad m => a -> m a
return SettingsSchemaKey
result'

#if ENABLE_OVERLOADING
data SettingsSchemaKeyRefMethodInfo
instance (signature ~ (m SettingsSchemaKey), MonadIO m) => O.MethodInfo SettingsSchemaKeyRefMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyRef

#endif

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

foreign import ccall "g_settings_schema_key_unref" g_settings_schema_key_unref :: 
    Ptr SettingsSchemaKey ->                -- key : TInterface (Name {namespace = "Gio", name = "SettingsSchemaKey"})
    IO ()

{- |
Decrease the reference count of /@key@/, possibly freeing it.

/Since: 2.40/
-}
settingsSchemaKeyUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SettingsSchemaKey
    {- ^ /@key@/: a 'GI.Gio.Structs.SettingsSchemaKey.SettingsSchemaKey' -}
    -> m ()
settingsSchemaKeyUnref :: SettingsSchemaKey -> m ()
settingsSchemaKeyUnref key :: SettingsSchemaKey
key = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingsSchemaKey
key' <- SettingsSchemaKey -> IO (Ptr SettingsSchemaKey)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SettingsSchemaKey
key
    Ptr SettingsSchemaKey -> IO ()
g_settings_schema_key_unref Ptr SettingsSchemaKey
key'
    SettingsSchemaKey -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SettingsSchemaKey
key
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SettingsSchemaKeyUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SettingsSchemaKeyUnrefMethodInfo SettingsSchemaKey signature where
    overloadedMethod _ = settingsSchemaKeyUnref

#endif

#if ENABLE_OVERLOADING
type family ResolveSettingsSchemaKeyMethod (t :: Symbol) (o :: *) :: * where
    ResolveSettingsSchemaKeyMethod "rangeCheck" o = SettingsSchemaKeyRangeCheckMethodInfo
    ResolveSettingsSchemaKeyMethod "ref" o = SettingsSchemaKeyRefMethodInfo
    ResolveSettingsSchemaKeyMethod "unref" o = SettingsSchemaKeyUnrefMethodInfo
    ResolveSettingsSchemaKeyMethod "getDefaultValue" o = SettingsSchemaKeyGetDefaultValueMethodInfo
    ResolveSettingsSchemaKeyMethod "getDescription" o = SettingsSchemaKeyGetDescriptionMethodInfo
    ResolveSettingsSchemaKeyMethod "getName" o = SettingsSchemaKeyGetNameMethodInfo
    ResolveSettingsSchemaKeyMethod "getRange" o = SettingsSchemaKeyGetRangeMethodInfo
    ResolveSettingsSchemaKeyMethod "getSummary" o = SettingsSchemaKeyGetSummaryMethodInfo
    ResolveSettingsSchemaKeyMethod "getValueType" o = SettingsSchemaKeyGetValueTypeMethodInfo
    ResolveSettingsSchemaKeyMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveSettingsSchemaKeyMethod t SettingsSchemaKey, O.MethodInfo info SettingsSchemaKey p) => O.IsLabel t (SettingsSchemaKey -> 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