    {-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The @GSettings@ class provides a convenient API for storing and retrieving
    -- application settings.
    --
    -- Reads and writes can be considered to be non-blocking.  Reading
    -- settings with @GSettings@ is typically extremely fast: on
    -- approximately the same order of magnitude (but slower than) a
    -- [struct/@gLib@/.HashTable] lookup.  Writing settings is also extremely fast in
    -- terms of time to return to your application, but can be extremely expensive
    -- for other threads and other processes.  Many settings backends
    -- (including dconf) have lazy initialisation which means in the common
    -- case of the user using their computer without modifying any settings
    -- a lot of work can be avoided.  For dconf, the D-Bus service doesn’t
    -- even need to be started in this case.  For this reason, you should
    -- only ever modify @GSettings@ keys in response to explicit user action.
    -- Particular care should be paid to ensure that modifications are not
    -- made during startup — for example, when setting the initial value
    -- of preferences widgets.  The built-in 'GI.Gio.Objects.Settings.settingsBind'
    -- functionality is careful not to write settings in response to notify signals
    -- as a result of modifications that it makes to widgets.
    --
    -- When creating a @GSettings@ instance, you have to specify a schema
    -- that describes the keys in your settings and their types and default
    -- values, as well as some other information.
    --
    -- Normally, a schema has a fixed path that determines where the settings
    -- are stored in the conceptual global tree of settings. However, schemas
    -- can also be ‘<http://developer.gnome.org/gio/stable/#relocatable-schemas relocatable>’, i.e. not equipped with
    -- a fixed path. This is
    -- useful e.g. when the schema describes an ‘account’, and you want to be
    -- able to store a arbitrary number of accounts.
    --
    -- Paths must start with and end with a forward slash character (@\/@)
    -- and must not contain two sequential slash characters.  Paths should
    -- be chosen based on a domain name associated with the program or
    -- library to which the settings belong.  Examples of paths are
    -- @\/org\/gtk\/settings\/file-chooser\/@ and @\/ca\/desrt\/dconf-editor\/@.
    -- Paths should not start with @\/apps\/@, @\/desktop\/@ or @\/system\/@ as
    -- they often did in GConf.
    --
    -- Unlike other configuration systems (like GConf), GSettings does not
    -- restrict keys to basic types like strings and numbers. GSettings stores
    -- values as [struct/@gLib@/.Variant], and allows any [type/@gLib@/.VariantType] for
    -- keys. Key names are restricted to lowercase characters, numbers and @-@.
    -- Furthermore, the names must begin with a lowercase character, must not end
    -- with a @-@, and must not contain consecutive dashes.
    --
    -- Similar to GConf, the default values in GSettings schemas can be
    -- localized, but the localized values are stored in gettext catalogs
    -- and looked up with the domain that is specified in the
    -- @gettext-domain@ attribute of the @\<schemalist>@ or @\<schema>@
    -- elements and the category that is specified in the @l10n@ attribute of
    -- the @\<default>@ element. The string which is translated includes all text in
    -- the @\<default>@ element, including any surrounding quotation marks.
    --
    -- The @l10n@ attribute must be set to @messages@ or @time@, and sets the
    -- <https://www.gnu.org/software/gettext/manual/html_node/Aspects.html#index-locale-categories-1 locale category for
    -- translation>.
    -- The @messages@ category should be used by default; use @time@ for
    -- translatable date or time formats. A translation comment can be added as an
    -- XML comment immediately above the @\<default>@ element — it is recommended to
    -- add these comments to aid translators understand the meaning and
    -- implications of the default value. An optional translation @context@
    -- attribute can be set on the @\<default>@ element to disambiguate multiple
    -- defaults which use the same string.
    --
    -- For example:
    --
    -- === /xml code/
    -- > <!-- Translators: A list of words which are not allowed to be typed, in
    -- >      GVariant serialization syntax.
    -- >      See: https://developer.gnome.org/glib/stable/gvariant-text.html -->
    -- > <default l10n='messages' context='Banned words'>['bad', 'words']</default>
    --
    --
    -- Translations of default values must remain syntactically valid serialized
    -- [struct/@gLib@/.Variant]s (e.g. retaining any surrounding quotation marks) or
    -- runtime errors will occur.
    --
    -- GSettings uses schemas in a compact binary form that is created
    -- by the <http://developer.gnome.org/gio/stable/glib-compile-schemas.html `glib-compile-schemas`>
    -- utility. The input is a schema description in an XML format.
    --
    -- A DTD for the gschema XML format can be found here:
    -- <https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/gschema.dtd gschema.dtd>
    --
    -- The <http://developer.gnome.org/gio/stable/glib-compile-schemas.html `glib-compile-schemas`> tool expects schema
    -- files to have the extension @.gschema.xml@.
    --
    -- At runtime, schemas are identified by their ID (as specified in the
    -- @id@ attribute of the @\<schema>@ element). The convention for schema
    -- IDs is to use a dotted name, similar in style to a D-Bus bus name,
    -- e.g. @org.gnome.SessionManager@. In particular, if the settings are
    -- for a specific service that owns a D-Bus bus name, the D-Bus bus name
    -- and schema ID should match. For schemas which deal with settings not
    -- associated with one named application, the ID should not use
    -- StudlyCaps, e.g. @org.gnome.font-rendering@.
    --
    -- In addition to [struct/@gLib@/.Variant] types, keys can have types that have
    -- enumerated types. These can be described by a @\<choice>@,
    -- @\<enum>@ or @\<flags>@ element, as seen in the
    -- second example below. The underlying type of such a key
    -- is string, but you can use 'GI.Gio.Objects.Settings.settingsGetEnum',
    -- 'GI.Gio.Objects.Settings.settingsSetEnum', 'GI.Gio.Objects.Settings.settingsGetFlags',
    -- 'GI.Gio.Objects.Settings.settingsSetFlags' access the numeric values corresponding to
    -- the string value of enum and flags keys.
    --
    -- An example for default value:
    --
    -- === /xml code/
    -- ><schemalist>
    -- >  <schema id="org.gtk.Test" path="/org/gtk/Test/" gettext-domain="test">
    -- >
    -- >    <key name="greeting" type="s">
    -- >      <default l10n="messages">"Hello, earthlings"</default>
    -- >      <summary>A greeting</summary>
    -- >      <description>
    -- >        Greeting of the invading martians
    -- >      </description>
    -- >    </key>
    -- >
    -- >    <key name="box" type="(ii)">
    -- >      <default>(20,30)</default>
    -- >    </key>
    -- >
    -- >    <key name="empty-string" type="s">
    -- >      <default>""</default>
    -- >      <summary>Empty strings have to be provided in GVariant form</summary>
    -- >    </key>
    -- >
    -- >  </schema>
    -- ></schemalist>
    --
    --
    -- An example for ranges, choices and enumerated types:
    --
    -- === /xml code/
    -- ><schemalist>
    -- >
    -- >  <enum id="org.gtk.Test.myenum">
    -- >    <value nick="first" value="1"/>
    -- >    <value nick="second" value="2"/>
    -- >  </enum>
    -- >
    -- >  <flags id="org.gtk.Test.myflags">
    -- >    <value nick="flag1" value="1"/>
    -- >    <value nick="flag2" value="2"/>
    -- >    <value nick="flag3" value="4"/>
    -- >  </flags>
    -- >
    -- >  <schema id="org.gtk.Test">
    -- >
    -- >    <key name="key-with-range" type="i">
    -- >      <range min="1" max="100"/>
    -- >      <default>10</default>
    -- >    </key>
    -- >
    -- >    <key name="key-with-choices" type="s">
    -- >      <choices>
    -- >        <choice value='Elisabeth'/>
    -- >        <choice value='Annabeth'/>
    -- >        <choice value='Joe'/>
    -- >      </choices>
    -- >      <aliases>
    -- >        <alias value='Anna' target='Annabeth'/>
    -- >        <alias value='Beth' target='Elisabeth'/>
    -- >      </aliases>
    -- >      <default>'Joe'</default>
    -- >    </key>
    -- >
    -- >    <key name='enumerated-key' enum='org.gtk.Test.myenum'>
    -- >      <default>'first'</default>
    -- >    </key>
    -- >
    -- >    <key name='flags-key' flags='org.gtk.Test.myflags'>
    -- >      <default>["flag1","flag2"]</default>
    -- >    </key>
    -- >  </schema>
    -- ></schemalist>
    --
    --
    -- == Vendor overrides
    --
    -- Default values are defined in the schemas that get installed by
    -- an application. Sometimes, it is necessary for a vendor or distributor
    -- to adjust these defaults. Since patching the XML source for the schema
    -- is inconvenient and error-prone,
    -- <http://developer.gnome.org/gio/stable/glib-compile-schemas.html `glib-compile-schemas`> reads so-called ‘vendor
    -- override’ files. These are keyfiles in the same directory as the XML
    -- schema sources which can override default values. The schema ID serves
    -- as the group name in the key file, and the values are expected in
    -- serialized [struct/@gLib@/.Variant] form, as in the following example:
    -- >[org.gtk.Example]
    -- >key1='string'
    -- >key2=1.5
    --
    --
    -- @glib-compile-schemas@ expects schema files to have the extension
    -- @.gschema.override@.
    --
    -- == Binding
    --
    -- A very convenient feature of GSettings lets you bind t'GI.GObject.Objects.Object.Object'
    -- properties directly to settings, using 'GI.Gio.Objects.Settings.settingsBind'. Once a
    -- t'GI.GObject.Objects.Object.Object' property has been bound to a setting, changes on
    -- either side are automatically propagated to the other side. GSettings handles
    -- details like mapping between t'GI.GObject.Objects.Object.Object' and [struct/@gLib@/.Variant]
    -- types, and preventing infinite cycles.
    --
    -- This makes it very easy to hook up a preferences dialog to the
    -- underlying settings. To make this even more convenient, GSettings
    -- looks for a boolean property with the name @sensitivity@ and
    -- automatically binds it to the writability of the bound setting.
    -- If this ‘magic’ gets in the way, it can be suppressed with the
    -- @G_SETTINGS_BIND_NO_SENSITIVITY@ flag.
    --
    -- == Relocatable schemas
    --
    -- A relocatable schema is one with no @path@ attribute specified on its
    -- @\<schema>@ element. By using 'GI.Gio.Objects.Settings.settingsNewWithPath', a @GSettings@
    -- object can be instantiated for a relocatable schema, assigning a path to the
    -- instance. Paths passed to 'GI.Gio.Objects.Settings.settingsNewWithPath' will typically be
    -- constructed dynamically from a constant prefix plus some form of instance
    -- identifier; but they must still be valid GSettings paths. Paths could also
    -- be constant and used with a globally installed schema originating from a
    -- dependency library.
    --
    -- For example, a relocatable schema could be used to store geometry information
    -- for different windows in an application. If the schema ID was
    -- @org.foo.MyApp.Window@, it could be instantiated for paths
    -- @\/org\/foo\/MyApp\/main\/@, @\/org\/foo\/MyApp\/document-1\/@,
    -- @\/org\/foo\/MyApp\/document-2\/@, etc. If any of the paths are well-known
    -- they can be specified as @\<child>@ elements in the parent schema, e.g.:
    --
    -- === /xml code/
    -- ><schema id="org.foo.MyApp" path="/org/foo/MyApp/">
    -- >  <child name="main" schema="org.foo.MyApp.Window"/>
    -- ></schema>
    --
    --
    -- == Build system integration
    --
    -- GSettings comes with autotools integration to simplify compiling and
    -- installing schemas. To add GSettings support to an application, add the
    -- following to your @configure.ac@:
    -- >GLIB_GSETTINGS
    --
    --
    -- In the appropriate @Makefile.am@, use the following snippet to compile and
    -- install the named schema:
    -- >gsettings_SCHEMAS = org.foo.MyApp.gschema.xml
    -- >EXTRA_DIST = $(gsettings_SCHEMAS)
    -- >
    -- >@GSETTINGS_RULES@
    --
    --
    -- No changes are needed to the build system to mark a schema XML file for
    -- translation. Assuming it sets the @gettext-domain@ attribute, a schema may
    -- be marked for translation by adding it to @POTFILES.in@, assuming gettext
    -- 0.19 is in use (the preferred method for translation):
    -- >data/org.foo.MyApp.gschema.xml
    --
    --
    -- Alternatively, if intltool 0.50.1 is in use:
    -- >[type: gettext/gsettings]data/org.foo.MyApp.gschema.xml
    --
    --
    -- GSettings will use gettext to look up translations for the @\<summary>@ and
    -- @\<description>@ elements, and also any @\<default>@ elements which have a
    -- @l10n@ attribute set. Translations must not be included in the @.gschema.xml@
    -- file by the build system, for example by using intltool XML rules with a
    -- @.gschema.xml.in@ template.
    --
    -- If an enumerated type defined in a C header file is to be used in a GSettings
    -- schema, it can either be defined manually using an @\<enum>@ element in the
    -- schema XML, or it can be extracted automatically from the C header. This
    -- approach is preferred, as it ensures the two representations are always
    -- synchronised. To do so, add the following to the relevant @Makefile.am@:
    -- >gsettings_ENUM_NAMESPACE = org.foo.MyApp
    -- >gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h
    --
    --
    -- @gsettings_ENUM_NAMESPACE@ specifies the schema namespace for the enum files,
    -- which are specified in @gsettings_ENUM_FILES@. This will generate a
    -- @org.foo.MyApp.enums.xml@ file containing the extracted enums, which will be
    -- automatically included in the schema compilation, install and uninstall
    -- rules. It should not be committed to version control or included in
    -- @EXTRA_DIST@.

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

    module GI.Gio.Objects.Settings
        (

    -- * Exported types
        Settings(..)                            ,
        IsSettings                              ,
        toSettings                              ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [apply]("GI.Gio.Objects.Settings#g:method:apply"), [bind]("GI.Gio.Objects.Settings#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [bindWithMapping]("GI.Gio.Objects.Settings#g:method:bindWithMapping"), [bindWritable]("GI.Gio.Objects.Settings#g:method:bindWritable"), [createAction]("GI.Gio.Objects.Settings#g:method:createAction"), [delay]("GI.Gio.Objects.Settings#g:method:delay"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isWritable]("GI.Gio.Objects.Settings#g:method:isWritable"), [listChildren]("GI.Gio.Objects.Settings#g:method:listChildren"), [listKeys]("GI.Gio.Objects.Settings#g:method:listKeys"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [rangeCheck]("GI.Gio.Objects.Settings#g:method:rangeCheck"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reset]("GI.Gio.Objects.Settings#g:method:reset"), [revert]("GI.Gio.Objects.Settings#g:method:revert"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getBoolean]("GI.Gio.Objects.Settings#g:method:getBoolean"), [getChild]("GI.Gio.Objects.Settings#g:method:getChild"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultValue]("GI.Gio.Objects.Settings#g:method:getDefaultValue"), [getDouble]("GI.Gio.Objects.Settings#g:method:getDouble"), [getEnum]("GI.Gio.Objects.Settings#g:method:getEnum"), [getFlags]("GI.Gio.Objects.Settings#g:method:getFlags"), [getHasUnapplied]("GI.Gio.Objects.Settings#g:method:getHasUnapplied"), [getInt]("GI.Gio.Objects.Settings#g:method:getInt"), [getInt64]("GI.Gio.Objects.Settings#g:method:getInt64"), [getMapped]("GI.Gio.Objects.Settings#g:method:getMapped"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRange]("GI.Gio.Objects.Settings#g:method:getRange"), [getString]("GI.Gio.Objects.Settings#g:method:getString"), [getStrv]("GI.Gio.Objects.Settings#g:method:getStrv"), [getUint]("GI.Gio.Objects.Settings#g:method:getUint"), [getUint64]("GI.Gio.Objects.Settings#g:method:getUint64"), [getUserValue]("GI.Gio.Objects.Settings#g:method:getUserValue"), [getValue]("GI.Gio.Objects.Settings#g:method:getValue").
    --
    -- ==== Setters
    -- [setBoolean]("GI.Gio.Objects.Settings#g:method:setBoolean"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDouble]("GI.Gio.Objects.Settings#g:method:setDouble"), [setEnum]("GI.Gio.Objects.Settings#g:method:setEnum"), [setFlags]("GI.Gio.Objects.Settings#g:method:setFlags"), [setInt]("GI.Gio.Objects.Settings#g:method:setInt"), [setInt64]("GI.Gio.Objects.Settings#g:method:setInt64"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setString]("GI.Gio.Objects.Settings#g:method:setString"), [setStrv]("GI.Gio.Objects.Settings#g:method:setStrv"), [setUint]("GI.Gio.Objects.Settings#g:method:setUint"), [setUint64]("GI.Gio.Objects.Settings#g:method:setUint64"), [setValue]("GI.Gio.Objects.Settings#g:method:setValue").

    #if defined(ENABLE_OVERLOADING)
        ResolveSettingsMethod                   ,
    #endif

    -- ** apply #method:apply#

    #if defined(ENABLE_OVERLOADING)
        SettingsApplyMethodInfo                 ,
    #endif
        settingsApply                           ,

    -- ** bind #method:bind#

    #if defined(ENABLE_OVERLOADING)
        SettingsBindMethodInfo                  ,
    #endif
        settingsBind                            ,

    -- ** bindWithMapping #method:bindWithMapping#

    #if defined(ENABLE_OVERLOADING)
        SettingsBindWithMappingMethodInfo       ,
    #endif
        settingsBindWithMapping                 ,

    -- ** bindWritable #method:bindWritable#

    #if defined(ENABLE_OVERLOADING)
        SettingsBindWritableMethodInfo          ,
    #endif
        settingsBindWritable                    ,

    -- ** createAction #method:createAction#

    #if defined(ENABLE_OVERLOADING)
        SettingsCreateActionMethodInfo          ,
    #endif
        settingsCreateAction                    ,

    -- ** delay #method:delay#

    #if defined(ENABLE_OVERLOADING)
        SettingsDelayMethodInfo                 ,
    #endif
        settingsDelay                           ,

    -- ** getBoolean #method:getBoolean#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetBooleanMethodInfo            ,
    #endif
        settingsGetBoolean                      ,

    -- ** getChild #method:getChild#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetChildMethodInfo              ,
    #endif
        settingsGetChild                        ,

    -- ** getDefaultValue #method:getDefaultValue#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetDefaultValueMethodInfo       ,
    #endif
        settingsGetDefaultValue                 ,

    -- ** getDouble #method:getDouble#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetDoubleMethodInfo             ,
    #endif
        settingsGetDouble                       ,

    -- ** getEnum #method:getEnum#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetEnumMethodInfo               ,
    #endif
        settingsGetEnum                         ,

    -- ** getFlags #method:getFlags#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetFlagsMethodInfo              ,
    #endif
        settingsGetFlags                        ,

    -- ** getHasUnapplied #method:getHasUnapplied#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetHasUnappliedMethodInfo       ,
    #endif
        settingsGetHasUnapplied                 ,

    -- ** getInt #method:getInt#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetIntMethodInfo                ,
    #endif
        settingsGetInt                          ,

    -- ** getInt64 #method:getInt64#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetInt64MethodInfo              ,
    #endif
        settingsGetInt64                        ,

    -- ** getMapped #method:getMapped#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetMappedMethodInfo             ,
    #endif
        settingsGetMapped                       ,

    -- ** getRange #method:getRange#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetRangeMethodInfo              ,
    #endif
        settingsGetRange                        ,

    -- ** getString #method:getString#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetStringMethodInfo             ,
    #endif
        settingsGetString                       ,

    -- ** getStrv #method:getStrv#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetStrvMethodInfo               ,
    #endif
        settingsGetStrv                         ,

    -- ** getUint #method:getUint#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetUintMethodInfo               ,
    #endif
        settingsGetUint                         ,

    -- ** getUint64 #method:getUint64#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetUint64MethodInfo             ,
    #endif
        settingsGetUint64                       ,

    -- ** getUserValue #method:getUserValue#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetUserValueMethodInfo          ,
    #endif
        settingsGetUserValue                    ,

    -- ** getValue #method:getValue#

    #if defined(ENABLE_OVERLOADING)
        SettingsGetValueMethodInfo              ,
    #endif
        settingsGetValue                        ,

    -- ** isWritable #method:isWritable#

    #if defined(ENABLE_OVERLOADING)
        SettingsIsWritableMethodInfo            ,
    #endif
        settingsIsWritable                      ,

    -- ** listChildren #method:listChildren#

    #if defined(ENABLE_OVERLOADING)
        SettingsListChildrenMethodInfo          ,
    #endif
        settingsListChildren                    ,

    -- ** listKeys #method:listKeys#

    #if defined(ENABLE_OVERLOADING)
        SettingsListKeysMethodInfo              ,
    #endif
        settingsListKeys                        ,

    -- ** listRelocatableSchemas #method:listRelocatableSchemas#

        settingsListRelocatableSchemas          ,

    -- ** listSchemas #method:listSchemas#

        settingsListSchemas                     ,

    -- ** new #method:new#

        settingsNew                             ,

    -- ** newFull #method:newFull#

        settingsNewFull                         ,

    -- ** newWithBackend #method:newWithBackend#

        settingsNewWithBackend                  ,

    -- ** newWithBackendAndPath #method:newWithBackendAndPath#

        settingsNewWithBackendAndPath           ,

    -- ** newWithPath #method:newWithPath#

        settingsNewWithPath                     ,

    -- ** rangeCheck #method:rangeCheck#

    #if defined(ENABLE_OVERLOADING)
        SettingsRangeCheckMethodInfo            ,
    #endif
        settingsRangeCheck                      ,

    -- ** reset #method:reset#

    #if defined(ENABLE_OVERLOADING)
        SettingsResetMethodInfo                 ,
    #endif
        settingsReset                           ,

    -- ** revert #method:revert#

    #if defined(ENABLE_OVERLOADING)
        SettingsRevertMethodInfo                ,
    #endif
        settingsRevert                          ,

    -- ** setBoolean #method:setBoolean#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetBooleanMethodInfo            ,
    #endif
        settingsSetBoolean                      ,

    -- ** setDouble #method:setDouble#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetDoubleMethodInfo             ,
    #endif
        settingsSetDouble                       ,

    -- ** setEnum #method:setEnum#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetEnumMethodInfo               ,
    #endif
        settingsSetEnum                         ,

    -- ** setFlags #method:setFlags#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetFlagsMethodInfo              ,
    #endif
        settingsSetFlags                        ,

    -- ** setInt #method:setInt#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetIntMethodInfo                ,
    #endif
        settingsSetInt                          ,

    -- ** setInt64 #method:setInt64#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetInt64MethodInfo              ,
    #endif
        settingsSetInt64                        ,

    -- ** setString #method:setString#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetStringMethodInfo             ,
    #endif
        settingsSetString                       ,

    -- ** setStrv #method:setStrv#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetStrvMethodInfo               ,
    #endif
        settingsSetStrv                         ,

    -- ** setUint #method:setUint#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetUintMethodInfo               ,
    #endif
        settingsSetUint                         ,

    -- ** setUint64 #method:setUint64#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetUint64MethodInfo             ,
    #endif
        settingsSetUint64                       ,

    -- ** setValue #method:setValue#

    #if defined(ENABLE_OVERLOADING)
        SettingsSetValueMethodInfo              ,
    #endif
        settingsSetValue                        ,

    -- ** sync #method:sync#

        settingsSync                            ,

    -- ** unbind #method:unbind#

        settingsUnbind                          ,

     -- * Properties

    -- ** backend #attr:backend#
    -- | The name of the context that the settings are stored in.

    #if defined(ENABLE_OVERLOADING)
        SettingsBackendPropertyInfo             ,
    #endif
        constructSettingsBackend                ,
        getSettingsBackend                      ,
    #if defined(ENABLE_OVERLOADING)
        settingsBackend                         ,
    #endif

    -- ** delayApply #attr:delayApply#
    -- | Whether the t'GI.Gio.Objects.Settings.Settings' object is in \'delay-apply\' mode. See
    -- 'GI.Gio.Objects.Settings.settingsDelay' for details.
    --
    -- /Since: 2.28/

    #if defined(ENABLE_OVERLOADING)
        SettingsDelayApplyPropertyInfo          ,
    #endif
        getSettingsDelayApply                   ,
    #if defined(ENABLE_OVERLOADING)
        settingsDelayApply                      ,
    #endif

    -- ** hasUnapplied #attr:hasUnapplied#
    -- | If this property is 'P.True', the t'GI.Gio.Objects.Settings.Settings' object has outstanding
    -- changes that will be applied when 'GI.Gio.Objects.Settings.settingsApply' is called.

    #if defined(ENABLE_OVERLOADING)
        SettingsHasUnappliedPropertyInfo        ,
    #endif
        getSettingsHasUnapplied                 ,
    #if defined(ENABLE_OVERLOADING)
        settingsHasUnapplied                    ,
    #endif

    -- ** path #attr:path#
    -- | The path within the backend where the settings are stored.

    #if defined(ENABLE_OVERLOADING)
        SettingsPathPropertyInfo                ,
    #endif
        constructSettingsPath                   ,
        getSettingsPath                         ,
    #if defined(ENABLE_OVERLOADING)
        settingsPath                            ,
    #endif

    -- ** schema #attr:schema#
    -- | The name of the schema that describes the types of keys
    -- for this t'GI.Gio.Objects.Settings.Settings' object.
    --
    -- The type of this property is *not* t'GI.Gio.Structs.SettingsSchema.SettingsSchema'.
    -- t'GI.Gio.Structs.SettingsSchema.SettingsSchema' has only existed since version 2.32 and
    -- unfortunately this name was used in previous versions to refer to
    -- the schema ID rather than the schema itself.  Take care to use the
    -- \'settings-schema\' property if you wish to pass in a
    -- t'GI.Gio.Structs.SettingsSchema.SettingsSchema'.

    #if defined(ENABLE_OVERLOADING)
        SettingsSchemaPropertyInfo              ,
    #endif
        constructSettingsSchema                 ,
        getSettingsSchema                       ,
    #if defined(ENABLE_OVERLOADING)
        settingsSchema                          ,
    #endif

    -- ** schemaId #attr:schemaId#
    -- | The name of the schema that describes the types of keys
    -- for this t'GI.Gio.Objects.Settings.Settings' object.

    #if defined(ENABLE_OVERLOADING)
        SettingsSchemaIdPropertyInfo            ,
    #endif
        constructSettingsSchemaId               ,
        getSettingsSchemaId                     ,
    #if defined(ENABLE_OVERLOADING)
        settingsSchemaId                        ,
    #endif

    -- ** settingsSchema #attr:settingsSchema#
    -- | The t'GI.Gio.Structs.SettingsSchema.SettingsSchema' describing the types of keys for this
    -- t'GI.Gio.Objects.Settings.Settings' object.
    --
    -- Ideally, this property would be called \'schema\'.  t'GI.Gio.Structs.SettingsSchema.SettingsSchema'
    -- has only existed since version 2.32, however, and before then the
    -- \'schema\' property was used to refer to the ID of the schema rather
    -- than the schema itself.  Take care.

    #if defined(ENABLE_OVERLOADING)
        SettingsSettingsSchemaPropertyInfo      ,
    #endif
        constructSettingsSettingsSchema         ,
        getSettingsSettingsSchema               ,
    #if defined(ENABLE_OVERLOADING)
        settingsSettingsSchema                  ,
    #endif

     -- * Signals

    -- ** changeEvent #signal:changeEvent#

        SettingsChangeEventCallback             ,
    #if defined(ENABLE_OVERLOADING)
        SettingsChangeEventSignalInfo           ,
    #endif
        afterSettingsChangeEvent                ,
        onSettingsChangeEvent                   ,

    -- ** changed #signal:changed#

        SettingsChangedCallback                 ,
    #if defined(ENABLE_OVERLOADING)
        SettingsChangedSignalInfo               ,
    #endif
        afterSettingsChanged                    ,
        onSettingsChanged                       ,

    -- ** writableChangeEvent #signal:writableChangeEvent#

        SettingsWritableChangeEventCallback     ,
    #if defined(ENABLE_OVERLOADING)
        SettingsWritableChangeEventSignalInfo   ,
    #endif
        afterSettingsWritableChangeEvent        ,
        onSettingsWritableChangeEvent           ,

    -- ** writableChanged #signal:writableChanged#

        SettingsWritableChangedCallback         ,
    #if defined(ENABLE_OVERLOADING)
        SettingsWritableChangedSignalInfo       ,
    #endif
        afterSettingsWritableChanged            ,
        onSettingsWritableChanged               ,

        ) 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 qualified GI.GLib.Structs.Tree as GLib.Tree
    import qualified GI.GLib.Structs.VariantType as GLib.VariantType
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Action as Gio.Action
    import {-# SOURCE #-} qualified GI.Gio.Objects.SettingsBackend as Gio.SettingsBackend
    import {-# SOURCE #-} qualified GI.Gio.Structs.SettingsSchema as Gio.SettingsSchema
    import {-# SOURCE #-} qualified GI.Gio.Structs.SettingsSchemaKey as Gio.SettingsSchemaKey

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Action as Gio.Action
    import {-# SOURCE #-} qualified GI.Gio.Objects.SettingsBackend as Gio.SettingsBackend
    import {-# SOURCE #-} qualified GI.Gio.Structs.SettingsSchema as Gio.SettingsSchema

    #endif

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

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

    foreign import ccall "g_settings_get_type"
        c_g_settings_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Settings where
        glibType :: IO GType
    glibType = IO GType
    c_g_settings_get_type

    instance B.Types.GObject Settings

    -- | Type class for types which can be safely cast to `Settings`, for instance with `toSettings`.
    class (SP.GObject o, O.IsDescendantOf Settings o) => IsSettings o
    instance (SP.GObject o, O.IsDescendantOf Settings o) => IsSettings o

    instance O.HasParentTypes Settings
    type instance O.ParentTypes Settings = '[GObject.Object.Object]

    -- | Cast to `Settings`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toSettings :: (MIO.MonadIO m, IsSettings o) => o -> m Settings
    toSettings :: forall (m :: * -> *) o.
    (MonadIO m, IsSettings o) =>
    o -> m Settings
    toSettings = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Settings -> m Settings)
    -> (o -> IO Settings) -> o -> m Settings
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr Settings -> Settings) -> o -> IO Settings
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr Settings -> Settings
    Settings

    -- | Convert 'Settings' 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 Settings) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_g_settings_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Settings -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Settings
    P.Nothing = Ptr GValue -> Ptr Settings -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr Settings
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Settings)
        gvalueSet_ Ptr GValue
    gv (P.Just Settings
    obj) = Settings -> (Ptr Settings -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Settings
    obj (Ptr GValue -> Ptr Settings -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Settings)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr Settings
    ptr <- Ptr GValue -> IO (Ptr Settings)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr Settings)
            if Ptr Settings
    ptr Ptr Settings -> Ptr Settings -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr Settings
    forall a. Ptr a
    FP.nullPtr
            then Settings -> Maybe Settings
    forall a. a -> Maybe a
    P.Just (Settings -> Maybe Settings) -> IO Settings -> IO (Maybe Settings)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr Settings -> Settings
    Settings Ptr Settings
    ptr
            else Maybe Settings -> IO (Maybe Settings)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Settings
    forall a. Maybe a
    P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSettingsMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveSettingsMethod "apply" o = SettingsApplyMethodInfo
        ResolveSettingsMethod "bind" o = SettingsBindMethodInfo
        ResolveSettingsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSettingsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSettingsMethod "bindWithMapping" o = SettingsBindWithMappingMethodInfo
        ResolveSettingsMethod "bindWritable" o = SettingsBindWritableMethodInfo
        ResolveSettingsMethod "createAction" o = SettingsCreateActionMethodInfo
        ResolveSettingsMethod "delay" o = SettingsDelayMethodInfo
        ResolveSettingsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSettingsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSettingsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSettingsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSettingsMethod "isWritable" o = SettingsIsWritableMethodInfo
        ResolveSettingsMethod "listChildren" o = SettingsListChildrenMethodInfo
        ResolveSettingsMethod "listKeys" o = SettingsListKeysMethodInfo
        ResolveSettingsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSettingsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSettingsMethod "rangeCheck" o = SettingsRangeCheckMethodInfo
        ResolveSettingsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSettingsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSettingsMethod "reset" o = SettingsResetMethodInfo
        ResolveSettingsMethod "revert" o = SettingsRevertMethodInfo
        ResolveSettingsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSettingsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSettingsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSettingsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSettingsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSettingsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSettingsMethod "getBoolean" o = SettingsGetBooleanMethodInfo
        ResolveSettingsMethod "getChild" o = SettingsGetChildMethodInfo
        ResolveSettingsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSettingsMethod "getDefaultValue" o = SettingsGetDefaultValueMethodInfo
        ResolveSettingsMethod "getDouble" o = SettingsGetDoubleMethodInfo
        ResolveSettingsMethod "getEnum" o = SettingsGetEnumMethodInfo
        ResolveSettingsMethod "getFlags" o = SettingsGetFlagsMethodInfo
        ResolveSettingsMethod "getHasUnapplied" o = SettingsGetHasUnappliedMethodInfo
        ResolveSettingsMethod "getInt" o = SettingsGetIntMethodInfo
        ResolveSettingsMethod "getInt64" o = SettingsGetInt64MethodInfo
        ResolveSettingsMethod "getMapped" o = SettingsGetMappedMethodInfo
        ResolveSettingsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSettingsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSettingsMethod "getRange" o = SettingsGetRangeMethodInfo
        ResolveSettingsMethod "getString" o = SettingsGetStringMethodInfo
        ResolveSettingsMethod "getStrv" o = SettingsGetStrvMethodInfo
        ResolveSettingsMethod "getUint" o = SettingsGetUintMethodInfo
        ResolveSettingsMethod "getUint64" o = SettingsGetUint64MethodInfo
        ResolveSettingsMethod "getUserValue" o = SettingsGetUserValueMethodInfo
        ResolveSettingsMethod "getValue" o = SettingsGetValueMethodInfo
        ResolveSettingsMethod "setBoolean" o = SettingsSetBooleanMethodInfo
        ResolveSettingsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSettingsMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveSettingsMethod "setDouble" o = SettingsSetDoubleMethodInfo
        ResolveSettingsMethod "setEnum" o = SettingsSetEnumMethodInfo
        ResolveSettingsMethod "setFlags" o = SettingsSetFlagsMethodInfo
        ResolveSettingsMethod "setInt" o = SettingsSetIntMethodInfo
        ResolveSettingsMethod "setInt64" o = SettingsSetInt64MethodInfo
        ResolveSettingsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSettingsMethod "setString" o = SettingsSetStringMethodInfo
        ResolveSettingsMethod "setStrv" o = SettingsSetStrvMethodInfo
        ResolveSettingsMethod "setUint" o = SettingsSetUintMethodInfo
        ResolveSettingsMethod "setUint64" o = SettingsSetUint64MethodInfo
        ResolveSettingsMethod "setValue" o = SettingsSetValueMethodInfo
        ResolveSettingsMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- signal Settings::change-event
    -- | The \"change-event\" signal is emitted once per change event that
    -- affects this settings object.  You should connect to this signal
    -- only if you are interested in viewing groups of changes before they
    -- are split out into multiple emissions of the \"changed\" signal.
    -- For most use cases it is more appropriate to use the \"changed\" signal.
    --
    -- In the event that the change event applies to one or more specified
    -- keys, /@keys@/ will be an array of @/GQuark/@ of length /@nKeys@/.  In the
    -- event that the change event applies to the t'GI.Gio.Objects.Settings.Settings' object as a
    -- whole (ie: potentially every key has been changed) then /@keys@/ will
    -- be 'P.Nothing' and /@nKeys@/ will be 0.
    --
    -- The default handler for this signal invokes the \"changed\" signal
    -- for each affected key.  If any other connected handler returns
    -- 'P.True' then this default functionality will be suppressed.
    type SettingsChangeEventCallback =
        Maybe [Word32]
        -- ^ /@keys@/:
        --        an array of @/GQuarks/@ for the changed keys, or 'P.Nothing'
        -> IO Bool
        -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the
        --          event. FALSE to propagate the event further.

    type C_SettingsChangeEventCallback =
        Ptr Settings ->                         -- object
        Ptr Word32 ->
        Int32 ->
        Ptr () ->                               -- user_data
        IO CInt

    -- | Generate a function pointer callable from C code, from a `C_SettingsChangeEventCallback`.
    foreign import ccall "wrapper"
        mk_SettingsChangeEventCallback :: C_SettingsChangeEventCallback -> IO (FunPtr C_SettingsChangeEventCallback)

    wrap_SettingsChangeEventCallback ::
        GObject a => (a -> SettingsChangeEventCallback) ->
        C_SettingsChangeEventCallback
    wrap_SettingsChangeEventCallback :: forall a.
    GObject a =>
    (a -> SettingsChangeEventCallback) -> C_SettingsChangeEventCallback
    wrap_SettingsChangeEventCallback a -> SettingsChangeEventCallback
    gi'cb Ptr Settings
    gi'selfPtr Ptr Word32
    keys Int32
    nKeys Ptr ()
    _ = do
        Maybe [Word32]
    maybeKeys <-
            if Ptr Word32
    keys Ptr Word32 -> Ptr Word32 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word32
    forall a. Ptr a
    FP.nullPtr
            then Maybe [Word32] -> IO (Maybe [Word32])
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe [Word32]
    forall a. Maybe a
    Nothing
            else do
                [Word32]
    keys' <- (Int32 -> Ptr Word32 -> IO [Word32]
    forall a b. (Integral a, Storable b) => a -> Ptr b -> IO [b]
    unpackStorableArrayWithLength Int32
    nKeys) Ptr Word32
    keys
                Maybe [Word32] -> IO (Maybe [Word32])
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe [Word32] -> IO (Maybe [Word32]))
    -> Maybe [Word32] -> IO (Maybe [Word32])
    forall a b. (a -> b) -> a -> b
    $ [Word32] -> Maybe [Word32]
    forall a. a -> Maybe a
    Just [Word32]
    keys'
        Bool
    result <- Ptr Settings -> (Settings -> IO Bool) -> IO Bool
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Settings
    gi'selfPtr ((Settings -> IO Bool) -> IO Bool)
    -> (Settings -> IO Bool) -> IO Bool
    forall a b. (a -> b) -> a -> b
    $ \Settings
    gi'self -> a -> SettingsChangeEventCallback
    gi'cb (Settings -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Settings
    gi'self)  Maybe [Word32]
    maybeKeys
        let result' :: CInt
    result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
        CInt -> IO CInt
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CInt
    result'

    -- | Connect a signal handler for the [changeEvent](#signal:changeEvent) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' settings #changeEvent callback
    -- @
    --
    --
    onSettingsChangeEvent :: (IsSettings a, MonadIO m) => a -> ((?self :: a) => SettingsChangeEventCallback) -> m SignalHandlerId
    onSettingsChangeEvent :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> ((?self::a) => SettingsChangeEventCallback) -> m SignalHandlerId
    onSettingsChangeEvent a
    obj (?self::a) => SettingsChangeEventCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsChangeEventCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsChangeEventCallback
    SettingsChangeEventCallback
    cb
        let wrapped' :: C_SettingsChangeEventCallback
    wrapped' = (a -> SettingsChangeEventCallback) -> C_SettingsChangeEventCallback
    forall a.
    GObject a =>
    (a -> SettingsChangeEventCallback) -> C_SettingsChangeEventCallback
    wrap_SettingsChangeEventCallback a -> SettingsChangeEventCallback
    wrapped
        FunPtr C_SettingsChangeEventCallback
    wrapped'' <- C_SettingsChangeEventCallback
    -> IO (FunPtr C_SettingsChangeEventCallback)
    mk_SettingsChangeEventCallback C_SettingsChangeEventCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsChangeEventCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "change-event" FunPtr C_SettingsChangeEventCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [changeEvent](#signal:changeEvent) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' settings #changeEvent callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSettingsChangeEvent :: (IsSettings a, MonadIO m) => a -> ((?self :: a) => SettingsChangeEventCallback) -> m SignalHandlerId
    afterSettingsChangeEvent :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> ((?self::a) => SettingsChangeEventCallback) -> m SignalHandlerId
    afterSettingsChangeEvent a
    obj (?self::a) => SettingsChangeEventCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsChangeEventCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsChangeEventCallback
    SettingsChangeEventCallback
    cb
        let wrapped' :: C_SettingsChangeEventCallback
    wrapped' = (a -> SettingsChangeEventCallback) -> C_SettingsChangeEventCallback
    forall a.
    GObject a =>
    (a -> SettingsChangeEventCallback) -> C_SettingsChangeEventCallback
    wrap_SettingsChangeEventCallback a -> SettingsChangeEventCallback
    wrapped
        FunPtr C_SettingsChangeEventCallback
    wrapped'' <- C_SettingsChangeEventCallback
    -> IO (FunPtr C_SettingsChangeEventCallback)
    mk_SettingsChangeEventCallback C_SettingsChangeEventCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsChangeEventCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "change-event" FunPtr C_SettingsChangeEventCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SettingsChangeEventSignalInfo
    instance SignalInfo SettingsChangeEventSignalInfo where
        type HaskellCallbackType SettingsChangeEventSignalInfo = SettingsChangeEventCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SettingsChangeEventCallback cb
            cb'' <- mk_SettingsChangeEventCallback cb'
            connectSignalFunPtr obj "change-event" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings::change-event"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:signal:changeEvent"})

    #endif

    -- signal Settings::changed
    -- | The \"changed\" signal is emitted when a key has potentially changed.
    -- You should call one of the @/g_settings_get()/@ calls to check the new
    -- value.
    --
    -- This signal supports detailed connections.  You can connect to the
    -- detailed signal \"changed[x](#g:signal:x)\" in order to only receive callbacks
    -- when key \"x\" changes.
    --
    -- Note that /@settings@/ only emits this signal if you have read /@key@/ at
    -- least once while a signal handler was already connected for /@key@/.
    type SettingsChangedCallback =
        T.Text
        -- ^ /@key@/: the name of the key that changed
        -> IO ()

    type C_SettingsChangedCallback =
        Ptr Settings ->                         -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_SettingsChangedCallback`.
    foreign import ccall "wrapper"
        mk_SettingsChangedCallback :: C_SettingsChangedCallback -> IO (FunPtr C_SettingsChangedCallback)

    wrap_SettingsChangedCallback ::
        GObject a => (a -> SettingsChangedCallback) ->
        C_SettingsChangedCallback
    wrap_SettingsChangedCallback :: forall a.
    GObject a =>
    (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    wrap_SettingsChangedCallback a -> SettingsChangedCallback
    gi'cb Ptr Settings
    gi'selfPtr CString
    key Ptr ()
    _ = do
        Text
    key' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    key
        Ptr Settings -> (Settings -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Settings
    gi'selfPtr ((Settings -> IO ()) -> IO ()) -> (Settings -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Settings
    gi'self -> a -> SettingsChangedCallback
    gi'cb (Settings -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Settings
    gi'self)  Text
    key'

    -- | Connect a signal handler for the [changed](#signal:changed) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' settings #changed callback
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@changed::detail@” instead.
    --
    onSettingsChanged :: (IsSettings a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => SettingsChangedCallback) -> m SignalHandlerId
    onSettingsChanged :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => SettingsChangedCallback)
    -> m SignalHandlerId
    onSettingsChanged a
    obj Maybe Text
    detail (?self::a) => SettingsChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsChangedCallback
    SettingsChangedCallback
    cb
        let wrapped' :: C_SettingsChangedCallback
    wrapped' = (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    forall a.
    GObject a =>
    (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    wrap_SettingsChangedCallback a -> SettingsChangedCallback
    wrapped
        FunPtr C_SettingsChangedCallback
    wrapped'' <- C_SettingsChangedCallback -> IO (FunPtr C_SettingsChangedCallback)
    mk_SettingsChangedCallback C_SettingsChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "changed" FunPtr C_SettingsChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    detail

    -- | Connect a signal handler for the [changed](#signal:changed) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' settings #changed callback
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@changed::detail@” instead.
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSettingsChanged :: (IsSettings a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => SettingsChangedCallback) -> m SignalHandlerId
    afterSettingsChanged :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => SettingsChangedCallback)
    -> m SignalHandlerId
    afterSettingsChanged a
    obj Maybe Text
    detail (?self::a) => SettingsChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsChangedCallback
    SettingsChangedCallback
    cb
        let wrapped' :: C_SettingsChangedCallback
    wrapped' = (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    forall a.
    GObject a =>
    (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    wrap_SettingsChangedCallback a -> SettingsChangedCallback
    wrapped
        FunPtr C_SettingsChangedCallback
    wrapped'' <- C_SettingsChangedCallback -> IO (FunPtr C_SettingsChangedCallback)
    mk_SettingsChangedCallback C_SettingsChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "changed" FunPtr C_SettingsChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    detail

    #if defined(ENABLE_OVERLOADING)
    data SettingsChangedSignalInfo
    instance SignalInfo SettingsChangedSignalInfo where
        type HaskellCallbackType SettingsChangedSignalInfo = SettingsChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SettingsChangedCallback cb
            cb'' <- mk_SettingsChangedCallback cb'
            connectSignalFunPtr obj "changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings::changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:signal:changed"})

    #endif

    -- signal Settings::writable-change-event
    -- | The \"writable-change-event\" signal is emitted once per writability
    -- change event that affects this settings object.  You should connect
    -- to this signal if you are interested in viewing groups of changes
    -- before they are split out into multiple emissions of the
    -- \"writable-changed\" signal.  For most use cases it is more
    -- appropriate to use the \"writable-changed\" signal.
    --
    -- In the event that the writability change applies only to a single
    -- key, /@key@/ will be set to the @/GQuark/@ for that key.  In the event
    -- that the writability change affects the entire settings object,
    -- /@key@/ will be 0.
    --
    -- The default handler for this signal invokes the \"writable-changed\"
    -- and \"changed\" signals for each affected key.  This is done because
    -- changes in writability might also imply changes in value (if for
    -- example, a new mandatory setting is introduced).  If any other
    -- connected handler returns 'P.True' then this default functionality
    -- will be suppressed.
    type SettingsWritableChangeEventCallback =
        Word32
        -- ^ /@key@/: the quark of the key, or 0
        -> IO Bool
        -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the
        --          event. FALSE to propagate the event further.

    type C_SettingsWritableChangeEventCallback =
        Ptr Settings ->                         -- object
        Word32 ->
        Ptr () ->                               -- user_data
        IO CInt

    -- | Generate a function pointer callable from C code, from a `C_SettingsWritableChangeEventCallback`.
    foreign import ccall "wrapper"
        mk_SettingsWritableChangeEventCallback :: C_SettingsWritableChangeEventCallback -> IO (FunPtr C_SettingsWritableChangeEventCallback)

    wrap_SettingsWritableChangeEventCallback ::
        GObject a => (a -> SettingsWritableChangeEventCallback) ->
        C_SettingsWritableChangeEventCallback
    wrap_SettingsWritableChangeEventCallback :: forall a.
    GObject a =>
    (a -> SettingsWritableChangeEventCallback)
    -> C_SettingsWritableChangeEventCallback
    wrap_SettingsWritableChangeEventCallback a -> SettingsWritableChangeEventCallback
    gi'cb Ptr Settings
    gi'selfPtr Word32
    key Ptr ()
    _ = do
        Bool
    result <- Ptr Settings -> (Settings -> IO Bool) -> IO Bool
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Settings
    gi'selfPtr ((Settings -> IO Bool) -> IO Bool)
    -> (Settings -> IO Bool) -> IO Bool
    forall a b. (a -> b) -> a -> b
    $ \Settings
    gi'self -> a -> SettingsWritableChangeEventCallback
    gi'cb (Settings -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Settings
    gi'self)  Word32
    key
        let result' :: CInt
    result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
        CInt -> IO CInt
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CInt
    result'

    -- | Connect a signal handler for the [writableChangeEvent](#signal:writableChangeEvent) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' settings #writableChangeEvent callback
    -- @
    --
    --
    onSettingsWritableChangeEvent :: (IsSettings a, MonadIO m) => a -> ((?self :: a) => SettingsWritableChangeEventCallback) -> m SignalHandlerId
    onSettingsWritableChangeEvent :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> ((?self::a) => SettingsWritableChangeEventCallback)
    -> m SignalHandlerId
    onSettingsWritableChangeEvent a
    obj (?self::a) => SettingsWritableChangeEventCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsWritableChangeEventCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsWritableChangeEventCallback
    SettingsWritableChangeEventCallback
    cb
        let wrapped' :: C_SettingsWritableChangeEventCallback
    wrapped' = (a -> SettingsWritableChangeEventCallback)
    -> C_SettingsWritableChangeEventCallback
    forall a.
    GObject a =>
    (a -> SettingsWritableChangeEventCallback)
    -> C_SettingsWritableChangeEventCallback
    wrap_SettingsWritableChangeEventCallback a -> SettingsWritableChangeEventCallback
    wrapped
        FunPtr C_SettingsWritableChangeEventCallback
    wrapped'' <- C_SettingsWritableChangeEventCallback
    -> IO (FunPtr C_SettingsWritableChangeEventCallback)
    mk_SettingsWritableChangeEventCallback C_SettingsWritableChangeEventCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsWritableChangeEventCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "writable-change-event" FunPtr C_SettingsWritableChangeEventCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [writableChangeEvent](#signal:writableChangeEvent) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' settings #writableChangeEvent callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSettingsWritableChangeEvent :: (IsSettings a, MonadIO m) => a -> ((?self :: a) => SettingsWritableChangeEventCallback) -> m SignalHandlerId
    afterSettingsWritableChangeEvent :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> ((?self::a) => SettingsWritableChangeEventCallback)
    -> m SignalHandlerId
    afterSettingsWritableChangeEvent a
    obj (?self::a) => SettingsWritableChangeEventCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsWritableChangeEventCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsWritableChangeEventCallback
    SettingsWritableChangeEventCallback
    cb
        let wrapped' :: C_SettingsWritableChangeEventCallback
    wrapped' = (a -> SettingsWritableChangeEventCallback)
    -> C_SettingsWritableChangeEventCallback
    forall a.
    GObject a =>
    (a -> SettingsWritableChangeEventCallback)
    -> C_SettingsWritableChangeEventCallback
    wrap_SettingsWritableChangeEventCallback a -> SettingsWritableChangeEventCallback
    wrapped
        FunPtr C_SettingsWritableChangeEventCallback
    wrapped'' <- C_SettingsWritableChangeEventCallback
    -> IO (FunPtr C_SettingsWritableChangeEventCallback)
    mk_SettingsWritableChangeEventCallback C_SettingsWritableChangeEventCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsWritableChangeEventCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "writable-change-event" FunPtr C_SettingsWritableChangeEventCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SettingsWritableChangeEventSignalInfo
    instance SignalInfo SettingsWritableChangeEventSignalInfo where
        type HaskellCallbackType SettingsWritableChangeEventSignalInfo = SettingsWritableChangeEventCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SettingsWritableChangeEventCallback cb
            cb'' <- mk_SettingsWritableChangeEventCallback cb'
            connectSignalFunPtr obj "writable-change-event" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings::writable-change-event"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:signal:writableChangeEvent"})

    #endif

    -- signal Settings::writable-changed
    -- | The \"writable-changed\" signal is emitted when the writability of a
    -- key has potentially changed.  You should call
    -- 'GI.Gio.Objects.Settings.settingsIsWritable' in order to determine the new status.
    --
    -- This signal supports detailed connections.  You can connect to the
    -- detailed signal \"writable-changed[x](#g:signal:x)\" in order to only receive
    -- callbacks when the writability of \"x\" changes.
    type SettingsWritableChangedCallback =
        T.Text
        -- ^ /@key@/: the key
        -> IO ()

    type C_SettingsWritableChangedCallback =
        Ptr Settings ->                         -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_SettingsWritableChangedCallback`.
    foreign import ccall "wrapper"
        mk_SettingsWritableChangedCallback :: C_SettingsWritableChangedCallback -> IO (FunPtr C_SettingsWritableChangedCallback)

    wrap_SettingsWritableChangedCallback ::
        GObject a => (a -> SettingsWritableChangedCallback) ->
        C_SettingsWritableChangedCallback
    wrap_SettingsWritableChangedCallback :: forall a.
    GObject a =>
    (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    wrap_SettingsWritableChangedCallback a -> SettingsChangedCallback
    gi'cb Ptr Settings
    gi'selfPtr CString
    key Ptr ()
    _ = do
        Text
    key' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    key
        Ptr Settings -> (Settings -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr Settings
    gi'selfPtr ((Settings -> IO ()) -> IO ()) -> (Settings -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Settings
    gi'self -> a -> SettingsChangedCallback
    gi'cb (Settings -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Settings
    gi'self)  Text
    key'

    -- | Connect a signal handler for the [writableChanged](#signal:writableChanged) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' settings #writableChanged callback
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@writable-changed::detail@” instead.
    --
    onSettingsWritableChanged :: (IsSettings a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => SettingsWritableChangedCallback) -> m SignalHandlerId
    onSettingsWritableChanged :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => SettingsChangedCallback)
    -> m SignalHandlerId
    onSettingsWritableChanged a
    obj Maybe Text
    detail (?self::a) => SettingsChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsChangedCallback
    SettingsChangedCallback
    cb
        let wrapped' :: C_SettingsChangedCallback
    wrapped' = (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    forall a.
    GObject a =>
    (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    wrap_SettingsWritableChangedCallback a -> SettingsChangedCallback
    wrapped
        FunPtr C_SettingsChangedCallback
    wrapped'' <- C_SettingsChangedCallback -> IO (FunPtr C_SettingsChangedCallback)
    mk_SettingsWritableChangedCallback C_SettingsChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "writable-changed" FunPtr C_SettingsChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectBefore Maybe Text
    detail

    -- | Connect a signal handler for the [writableChanged](#signal:writableChanged) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' settings #writableChanged callback
    -- @
    --
    -- This signal admits a optional parameter @detail@.
    -- If it's not @Nothing@, we will connect to “@writable-changed::detail@” instead.
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSettingsWritableChanged :: (IsSettings a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => SettingsWritableChangedCallback) -> m SignalHandlerId
    afterSettingsWritableChanged :: forall a (m :: * -> *).
    (IsSettings a, MonadIO m) =>
    a
    -> Maybe Text
    -> ((?self::a) => SettingsChangedCallback)
    -> m SignalHandlerId
    afterSettingsWritableChanged a
    obj Maybe Text
    detail (?self::a) => SettingsChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SettingsChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SettingsChangedCallback
    SettingsChangedCallback
    cb
        let wrapped' :: C_SettingsChangedCallback
    wrapped' = (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    forall a.
    GObject a =>
    (a -> SettingsChangedCallback) -> C_SettingsChangedCallback
    wrap_SettingsWritableChangedCallback a -> SettingsChangedCallback
    wrapped
        FunPtr C_SettingsChangedCallback
    wrapped'' <- C_SettingsChangedCallback -> IO (FunPtr C_SettingsChangedCallback)
    mk_SettingsWritableChangedCallback C_SettingsChangedCallback
    wrapped'
        a
    -> Text
    -> FunPtr C_SettingsChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj Text
    "writable-changed" FunPtr C_SettingsChangedCallback
    wrapped'' SignalConnectMode
    SignalConnectAfter Maybe Text
    detail

    #if defined(ENABLE_OVERLOADING)
    data SettingsWritableChangedSignalInfo
    instance SignalInfo SettingsWritableChangedSignalInfo where
        type HaskellCallbackType SettingsWritableChangedSignalInfo = SettingsWritableChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SettingsWritableChangedCallback cb
            cb'' <- mk_SettingsWritableChangedCallback cb'
            connectSignalFunPtr obj "writable-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings::writable-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:signal:writableChanged"})

    #endif

    -- VVV Prop "backend"
       -- Type: TInterface (Name {namespace = "Gio", name = "SettingsBackend"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@backend@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #backend
    -- @
    getSettingsBackend :: (MonadIO m, IsSettings o) => o -> m (Maybe Gio.SettingsBackend.SettingsBackend)
    getSettingsBackend :: forall (m :: * -> *) o.
    (MonadIO m, IsSettings o) =>
    o -> m (Maybe SettingsBackend)
    getSettingsBackend o
    obj = IO (Maybe SettingsBackend) -> m (Maybe SettingsBackend)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe SettingsBackend) -> m (Maybe SettingsBackend))
    -> IO (Maybe SettingsBackend) -> m (Maybe SettingsBackend)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr SettingsBackend -> SettingsBackend)
    -> IO (Maybe SettingsBackend)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "backend" ManagedPtr SettingsBackend -> SettingsBackend
    Gio.SettingsBackend.SettingsBackend

    -- | Construct a `GValueConstruct` with valid value for the “@backend@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSettingsBackend :: (IsSettings o, MIO.MonadIO m, Gio.SettingsBackend.IsSettingsBackend a) => a -> m (GValueConstruct o)
    constructSettingsBackend :: forall o (m :: * -> *) a.
    (IsSettings o, MonadIO m, IsSettingsBackend a) =>
    a -> m (GValueConstruct o)
    constructSettingsBackend a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject String
    "backend" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    #if defined(ENABLE_OVERLOADING)
    data SettingsBackendPropertyInfo
    instance AttrInfo SettingsBackendPropertyInfo where
        type AttrAllowedOps SettingsBackendPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SettingsBackendPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsBackendPropertyInfo = Gio.SettingsBackend.IsSettingsBackend
        type AttrTransferTypeConstraint SettingsBackendPropertyInfo = Gio.SettingsBackend.IsSettingsBackend
        type AttrTransferType SettingsBackendPropertyInfo = Gio.SettingsBackend.SettingsBackend
        type AttrGetType SettingsBackendPropertyInfo = (Maybe Gio.SettingsBackend.SettingsBackend)
        type AttrLabel SettingsBackendPropertyInfo = "backend"
        type AttrOrigin SettingsBackendPropertyInfo = Settings
        attrGet = getSettingsBackend
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo Gio.SettingsBackend.SettingsBackend v
        attrConstruct = constructSettingsBackend
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.backend"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:backend"
            })
    #endif

    -- VVV Prop "delay-apply"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@delay-apply@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #delayApply
    -- @
    getSettingsDelayApply :: (MonadIO m, IsSettings o) => o -> m Bool
    getSettingsDelayApply :: forall (m :: * -> *) o. (MonadIO m, IsSettings o) => o -> m Bool
    getSettingsDelayApply o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "delay-apply"

    #if defined(ENABLE_OVERLOADING)
    data SettingsDelayApplyPropertyInfo
    instance AttrInfo SettingsDelayApplyPropertyInfo where
        type AttrAllowedOps SettingsDelayApplyPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint SettingsDelayApplyPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsDelayApplyPropertyInfo = (~) ()
        type AttrTransferTypeConstraint SettingsDelayApplyPropertyInfo = (~) ()
        type AttrTransferType SettingsDelayApplyPropertyInfo = ()
        type AttrGetType SettingsDelayApplyPropertyInfo = Bool
        type AttrLabel SettingsDelayApplyPropertyInfo = "delay-apply"
        type AttrOrigin SettingsDelayApplyPropertyInfo = Settings
        attrGet = getSettingsDelayApply
        attrSet = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.delayApply"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:delayApply"
            })
    #endif

    -- VVV Prop "has-unapplied"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@has-unapplied@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #hasUnapplied
    -- @
    getSettingsHasUnapplied :: (MonadIO m, IsSettings o) => o -> m Bool
    getSettingsHasUnapplied :: forall (m :: * -> *) o. (MonadIO m, IsSettings o) => o -> m Bool
    getSettingsHasUnapplied o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "has-unapplied"

    #if defined(ENABLE_OVERLOADING)
    data SettingsHasUnappliedPropertyInfo
    instance AttrInfo SettingsHasUnappliedPropertyInfo where
        type AttrAllowedOps SettingsHasUnappliedPropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint SettingsHasUnappliedPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsHasUnappliedPropertyInfo = (~) ()
        type AttrTransferTypeConstraint SettingsHasUnappliedPropertyInfo = (~) ()
        type AttrTransferType SettingsHasUnappliedPropertyInfo = ()
        type AttrGetType SettingsHasUnappliedPropertyInfo = Bool
        type AttrLabel SettingsHasUnappliedPropertyInfo = "has-unapplied"
        type AttrOrigin SettingsHasUnappliedPropertyInfo = Settings
        attrGet = getSettingsHasUnapplied
        attrSet = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.hasUnapplied"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:hasUnapplied"
            })
    #endif

    -- VVV Prop "path"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@path@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #path
    -- @
    getSettingsPath :: (MonadIO m, IsSettings o) => o -> m (Maybe T.Text)
    getSettingsPath :: forall (m :: * -> *) o.
    (MonadIO m, IsSettings o) =>
    o -> m (Maybe Text)
    getSettingsPath o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "path"

    -- | Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSettingsPath :: (IsSettings o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructSettingsPath :: forall o (m :: * -> *).
    (IsSettings o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructSettingsPath Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "path" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    #if defined(ENABLE_OVERLOADING)
    data SettingsPathPropertyInfo
    instance AttrInfo SettingsPathPropertyInfo where
        type AttrAllowedOps SettingsPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SettingsPathPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsPathPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint SettingsPathPropertyInfo = (~) T.Text
        type AttrTransferType SettingsPathPropertyInfo = T.Text
        type AttrGetType SettingsPathPropertyInfo = (Maybe T.Text)
        type AttrLabel SettingsPathPropertyInfo = "path"
        type AttrOrigin SettingsPathPropertyInfo = Settings
        attrGet = getSettingsPath
        attrSet = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSettingsPath
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.path"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:path"
            })
    #endif

    -- VVV Prop "schema"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@schema@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #schema
    -- @
    getSettingsSchema :: (MonadIO m, IsSettings o) => o -> m (Maybe T.Text)
    getSettingsSchema :: forall (m :: * -> *) o.
    (MonadIO m, IsSettings o) =>
    o -> m (Maybe Text)
    getSettingsSchema o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "schema"

    -- | Construct a `GValueConstruct` with valid value for the “@schema@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSettingsSchema :: (IsSettings o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructSettingsSchema :: forall o (m :: * -> *).
    (IsSettings o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructSettingsSchema Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "schema" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    #if defined(ENABLE_OVERLOADING)
    data SettingsSchemaPropertyInfo
    instance AttrInfo SettingsSchemaPropertyInfo where
        type AttrAllowedOps SettingsSchemaPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SettingsSchemaPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsSchemaPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint SettingsSchemaPropertyInfo = (~) T.Text
        type AttrTransferType SettingsSchemaPropertyInfo = T.Text
        type AttrGetType SettingsSchemaPropertyInfo = (Maybe T.Text)
        type AttrLabel SettingsSchemaPropertyInfo = "schema"
        type AttrOrigin SettingsSchemaPropertyInfo = Settings
        attrGet = getSettingsSchema
        attrSet = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSettingsSchema
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.schema"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:schema"
            })
    #endif

    -- VVV Prop "schema-id"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@schema-id@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #schemaId
    -- @
    getSettingsSchemaId :: (MonadIO m, IsSettings o) => o -> m (Maybe T.Text)
    getSettingsSchemaId :: forall (m :: * -> *) o.
    (MonadIO m, IsSettings o) =>
    o -> m (Maybe Text)
    getSettingsSchemaId o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "schema-id"

    -- | Construct a `GValueConstruct` with valid value for the “@schema-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSettingsSchemaId :: (IsSettings o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructSettingsSchemaId :: forall o (m :: * -> *).
    (IsSettings o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructSettingsSchemaId Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "schema-id" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    #if defined(ENABLE_OVERLOADING)
    data SettingsSchemaIdPropertyInfo
    instance AttrInfo SettingsSchemaIdPropertyInfo where
        type AttrAllowedOps SettingsSchemaIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SettingsSchemaIdPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsSchemaIdPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint SettingsSchemaIdPropertyInfo = (~) T.Text
        type AttrTransferType SettingsSchemaIdPropertyInfo = T.Text
        type AttrGetType SettingsSchemaIdPropertyInfo = (Maybe T.Text)
        type AttrLabel SettingsSchemaIdPropertyInfo = "schema-id"
        type AttrOrigin SettingsSchemaIdPropertyInfo = Settings
        attrGet = getSettingsSchemaId
        attrSet = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSettingsSchemaId
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.schemaId"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:schemaId"
            })
    #endif

    -- VVV Prop "settings-schema"
       -- Type: TInterface (Name {namespace = "Gio", name = "SettingsSchema"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@settings-schema@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' settings #settingsSchema
    -- @
    getSettingsSettingsSchema :: (MonadIO m, IsSettings o) => o -> m (Maybe Gio.SettingsSchema.SettingsSchema)
    getSettingsSettingsSchema :: forall (m :: * -> *) o.
    (MonadIO m, IsSettings o) =>
    o -> m (Maybe SettingsSchema)
    getSettingsSettingsSchema o
    obj = IO (Maybe SettingsSchema) -> m (Maybe SettingsSchema)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe SettingsSchema) -> m (Maybe SettingsSchema))
    -> IO (Maybe SettingsSchema) -> m (Maybe SettingsSchema)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr SettingsSchema -> SettingsSchema)
    -> IO (Maybe SettingsSchema)
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyBoxed o
    obj String
    "settings-schema" ManagedPtr SettingsSchema -> SettingsSchema
    Gio.SettingsSchema.SettingsSchema

    -- | Construct a `GValueConstruct` with valid value for the “@settings-schema@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSettingsSettingsSchema :: (IsSettings o, MIO.MonadIO m) => Gio.SettingsSchema.SettingsSchema -> m (GValueConstruct o)
    constructSettingsSettingsSchema :: forall o (m :: * -> *).
    (IsSettings o, MonadIO m) =>
    SettingsSchema -> m (GValueConstruct o)
    constructSettingsSettingsSchema SettingsSchema
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe SettingsSchema -> IO (GValueConstruct o)
    forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBoxed String
    "settings-schema" (SettingsSchema -> Maybe SettingsSchema
    forall a. a -> Maybe a
    P.Just SettingsSchema
    val)

    #if defined(ENABLE_OVERLOADING)
    data SettingsSettingsSchemaPropertyInfo
    instance AttrInfo SettingsSettingsSchemaPropertyInfo where
        type AttrAllowedOps SettingsSettingsSchemaPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SettingsSettingsSchemaPropertyInfo = IsSettings
        type AttrSetTypeConstraint SettingsSettingsSchemaPropertyInfo = (~) Gio.SettingsSchema.SettingsSchema
        type AttrTransferTypeConstraint SettingsSettingsSchemaPropertyInfo = (~) Gio.SettingsSchema.SettingsSchema
        type AttrTransferType SettingsSettingsSchemaPropertyInfo = Gio.SettingsSchema.SettingsSchema
        type AttrGetType SettingsSettingsSchemaPropertyInfo = (Maybe Gio.SettingsSchema.SettingsSchema)
        type AttrLabel SettingsSettingsSchemaPropertyInfo = "settings-schema"
        type AttrOrigin SettingsSettingsSchemaPropertyInfo = Settings
        attrGet = getSettingsSettingsSchema
        attrSet = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSettingsSettingsSchema
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSchema"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#g:attr:settingsSchema"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Settings
    type instance O.AttributeList Settings = SettingsAttributeList
    type SettingsAttributeList = ('[ '("backend", SettingsBackendPropertyInfo), '("delayApply", SettingsDelayApplyPropertyInfo), '("hasUnapplied", SettingsHasUnappliedPropertyInfo), '("path", SettingsPathPropertyInfo), '("schema", SettingsSchemaPropertyInfo), '("schemaId", SettingsSchemaIdPropertyInfo), '("settingsSchema", SettingsSettingsSchemaPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    settingsBackend :: AttrLabelProxy "backend"
    settingsBackend = AttrLabelProxy

    settingsDelayApply :: AttrLabelProxy "delayApply"
    settingsDelayApply = AttrLabelProxy

    settingsHasUnapplied :: AttrLabelProxy "hasUnapplied"
    settingsHasUnapplied = AttrLabelProxy

    settingsPath :: AttrLabelProxy "path"
    settingsPath = AttrLabelProxy

    settingsSchema :: AttrLabelProxy "schema"
    settingsSchema = AttrLabelProxy

    settingsSchemaId :: AttrLabelProxy "schemaId"
    settingsSchemaId = AttrLabelProxy

    settingsSettingsSchema :: AttrLabelProxy "settingsSchema"
    settingsSettingsSchema = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Settings = SettingsSignalList
    type SettingsSignalList = ('[ '("changeEvent", SettingsChangeEventSignalInfo), '("changed", SettingsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("writableChangeEvent", SettingsWritableChangeEventSignalInfo), '("writableChanged", SettingsWritableChangedSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method Settings::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "schema_id"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the id of the schema"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Settings" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_new" g_settings_new ::
        CString ->                              -- schema_id : TBasicType TUTF8
        IO (Ptr Settings)

    -- | Creates a new t'GI.Gio.Objects.Settings.Settings' object with the schema specified by
    -- /@schemaId@/.
    --
    -- It is an error for the schema to not exist: schemas are an
    -- essential part of a program, as they provide type information.
    -- If schemas need to be dynamically loaded (for example, from an
    -- optional runtime dependency), 'GI.Gio.Structs.SettingsSchemaSource.settingsSchemaSourceLookup'
    -- can be used to test for their existence before loading them.
    --
    -- Signals on the newly created t'GI.Gio.Objects.Settings.Settings' object will be dispatched
    -- via the thread-default t'GI.GLib.Structs.MainContext.MainContext' in effect at the time of the
    -- call to 'GI.Gio.Objects.Settings.settingsNew'.  The new t'GI.Gio.Objects.Settings.Settings' will hold a reference
    -- on the context.  See 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault'.
    --
    -- /Since: 2.26/
    settingsNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@schemaId@/: the id of the schema
        -> m Settings
        -- ^ __Returns:__ a new t'GI.Gio.Objects.Settings.Settings' object
    settingsNew :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> m Settings
    settingsNew Text
    schemaId = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Settings -> m Settings) -> IO Settings -> m Settings
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    schemaId' <- Text -> IO CString
    textToCString Text
    schemaId
        Ptr Settings
    result <- CString -> IO (Ptr Settings)
    g_settings_new CString
    schemaId'
        Text -> Ptr Settings -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsNew" Ptr Settings
    result
        Settings
    result' <- ((ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Settings -> Settings
    Settings) Ptr Settings
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    schemaId'
        Settings -> IO Settings
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Settings
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::new_full
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "schema"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsSchema" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettingsSchema" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "backend"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsBackend" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettingsBackend"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the path to use" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Settings" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_new_full" g_settings_new_full ::
        Ptr Gio.SettingsSchema.SettingsSchema -> -- schema : TInterface (Name {namespace = "Gio", name = "SettingsSchema"})
        Ptr Gio.SettingsBackend.SettingsBackend -> -- backend : TInterface (Name {namespace = "Gio", name = "SettingsBackend"})
        CString ->                              -- path : TBasicType TUTF8
        IO (Ptr Settings)

    -- | Creates a new t'GI.Gio.Objects.Settings.Settings' object with a given schema, backend and
    -- path.
    --
    -- It should be extremely rare that you ever want to use this function.
    -- It is made available for advanced use-cases (such as plugin systems
    -- that want to provide access to schemas loaded from custom locations,
    -- etc).
    --
    -- At the most basic level, a t'GI.Gio.Objects.Settings.Settings' object is a pure composition of
    -- 4 things: a t'GI.Gio.Structs.SettingsSchema.SettingsSchema', a t'GI.Gio.Objects.SettingsBackend.SettingsBackend', a path within that
    -- backend, and a t'GI.GLib.Structs.MainContext.MainContext' to which signals are dispatched.
    --
    -- This constructor therefore gives you full control over constructing
    -- t'GI.Gio.Objects.Settings.Settings' instances.  The first 3 parameters are given directly as
    -- /@schema@/, /@backend@/ and /@path@/, and the main context is taken from the
    -- thread-default (as per 'GI.Gio.Objects.Settings.settingsNew').
    --
    -- If /@backend@/ is 'P.Nothing' then the default backend is used.
    --
    -- If /@path@/ is 'P.Nothing' then the path from the schema is used.  It is an
    -- error if /@path@/ is 'P.Nothing' and the schema has no path of its own or if
    -- /@path@/ is non-'P.Nothing' and not equal to the path that the schema does
    -- have.
    --
    -- /Since: 2.32/
    settingsNewFull ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.SettingsBackend.IsSettingsBackend a) =>
        Gio.SettingsSchema.SettingsSchema
        -- ^ /@schema@/: a t'GI.Gio.Structs.SettingsSchema.SettingsSchema'
        -> Maybe (a)
        -- ^ /@backend@/: a t'GI.Gio.Objects.SettingsBackend.SettingsBackend'
        -> Maybe (T.Text)
        -- ^ /@path@/: the path to use
        -> m Settings
        -- ^ __Returns:__ a new t'GI.Gio.Objects.Settings.Settings' object
    settingsNewFull :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettingsBackend a) =>
    SettingsSchema -> Maybe a -> Maybe Text -> m Settings
    settingsNewFull SettingsSchema
    schema Maybe a
    backend Maybe Text
    path = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Settings -> m Settings) -> IO Settings -> m Settings
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SettingsSchema
    schema' <- SettingsSchema -> IO (Ptr SettingsSchema)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr SettingsSchema
    schema
        Ptr SettingsBackend
    maybeBackend <- case Maybe a
    backend of
            Maybe a
    Nothing -> Ptr SettingsBackend -> IO (Ptr SettingsBackend)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr SettingsBackend
    forall a. Ptr a
    FP.nullPtr
            Just a
    jBackend -> do
                Ptr SettingsBackend
    jBackend' <- a -> IO (Ptr SettingsBackend)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jBackend
                Ptr SettingsBackend -> IO (Ptr SettingsBackend)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr SettingsBackend
    jBackend'
        CString
    maybePath <- case Maybe Text
    path of
            Maybe Text
    Nothing -> CString -> IO CString
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CString
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jPath -> do
                CString
    jPath' <- Text -> IO CString
    textToCString Text
    jPath
                CString -> IO CString
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CString
    jPath'
        Ptr Settings
    result <- Ptr SettingsSchema
    -> Ptr SettingsBackend -> CString -> IO (Ptr Settings)
    g_settings_new_full Ptr SettingsSchema
    schema' Ptr SettingsBackend
    maybeBackend CString
    maybePath
        Text -> Ptr Settings -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsNewFull" Ptr Settings
    result
        Settings
    result' <- ((ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Settings -> Settings
    Settings) Ptr Settings
    result
        SettingsSchema -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr SettingsSchema
    schema
        Maybe a -> (a -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe a
    backend a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    maybePath
        Settings -> IO Settings
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Settings
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::new_with_backend
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "schema_id"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the id of the schema"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "backend"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsBackend" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GSettingsBackend to use"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Settings" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_new_with_backend" g_settings_new_with_backend ::
        CString ->                              -- schema_id : TBasicType TUTF8
        Ptr Gio.SettingsBackend.SettingsBackend -> -- backend : TInterface (Name {namespace = "Gio", name = "SettingsBackend"})
        IO (Ptr Settings)

    -- | Creates a new t'GI.Gio.Objects.Settings.Settings' object with the schema specified by
    -- /@schemaId@/ and a given t'GI.Gio.Objects.SettingsBackend.SettingsBackend'.
    --
    -- Creating a t'GI.Gio.Objects.Settings.Settings' object with a different backend allows accessing
    -- settings from a database other than the usual one. For example, it may make
    -- sense to pass a backend corresponding to the \"defaults\" settings database on
    -- the system to get a settings object that modifies the system default
    -- settings instead of the settings for this user.
    --
    -- /Since: 2.26/
    settingsNewWithBackend ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.SettingsBackend.IsSettingsBackend a) =>
        T.Text
        -- ^ /@schemaId@/: the id of the schema
        -> a
        -- ^ /@backend@/: the t'GI.Gio.Objects.SettingsBackend.SettingsBackend' to use
        -> m Settings
        -- ^ __Returns:__ a new t'GI.Gio.Objects.Settings.Settings' object
    settingsNewWithBackend :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettingsBackend a) =>
    Text -> a -> m Settings
    settingsNewWithBackend Text
    schemaId a
    backend = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Settings -> m Settings) -> IO Settings -> m Settings
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    schemaId' <- Text -> IO CString
    textToCString Text
    schemaId
        Ptr SettingsBackend
    backend' <- a -> IO (Ptr SettingsBackend)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    backend
        Ptr Settings
    result <- CString -> Ptr SettingsBackend -> IO (Ptr Settings)
    g_settings_new_with_backend CString
    schemaId' Ptr SettingsBackend
    backend'
        Text -> Ptr Settings -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsNewWithBackend" Ptr Settings
    result
        Settings
    result' <- ((ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Settings -> Settings
    Settings) Ptr Settings
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    backend
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    schemaId'
        Settings -> IO Settings
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Settings
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::new_with_backend_and_path
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "schema_id"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the id of the schema"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "backend"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsBackend" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GSettingsBackend to use"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the path to use" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Settings" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_new_with_backend_and_path" g_settings_new_with_backend_and_path ::
        CString ->                              -- schema_id : TBasicType TUTF8
        Ptr Gio.SettingsBackend.SettingsBackend -> -- backend : TInterface (Name {namespace = "Gio", name = "SettingsBackend"})
        CString ->                              -- path : TBasicType TUTF8
        IO (Ptr Settings)

    -- | Creates a new t'GI.Gio.Objects.Settings.Settings' object with the schema specified by
    -- /@schemaId@/ and a given t'GI.Gio.Objects.SettingsBackend.SettingsBackend' and path.
    --
    -- This is a mix of 'GI.Gio.Objects.Settings.settingsNewWithBackend' and
    -- 'GI.Gio.Objects.Settings.settingsNewWithPath'.
    --
    -- /Since: 2.26/
    settingsNewWithBackendAndPath ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.SettingsBackend.IsSettingsBackend a) =>
        T.Text
        -- ^ /@schemaId@/: the id of the schema
        -> a
        -- ^ /@backend@/: the t'GI.Gio.Objects.SettingsBackend.SettingsBackend' to use
        -> T.Text
        -- ^ /@path@/: the path to use
        -> m Settings
        -- ^ __Returns:__ a new t'GI.Gio.Objects.Settings.Settings' object
    settingsNewWithBackendAndPath :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettingsBackend a) =>
    Text -> a -> Text -> m Settings
    settingsNewWithBackendAndPath Text
    schemaId a
    backend Text
    path = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Settings -> m Settings) -> IO Settings -> m Settings
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    schemaId' <- Text -> IO CString
    textToCString Text
    schemaId
        Ptr SettingsBackend
    backend' <- a -> IO (Ptr SettingsBackend)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    backend
        CString
    path' <- Text -> IO CString
    textToCString Text
    path
        Ptr Settings
    result <- CString -> Ptr SettingsBackend -> CString -> IO (Ptr Settings)
    g_settings_new_with_backend_and_path CString
    schemaId' Ptr SettingsBackend
    backend' CString
    path'
        Text -> Ptr Settings -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsNewWithBackendAndPath" Ptr Settings
    result
        Settings
    result' <- ((ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Settings -> Settings
    Settings) Ptr Settings
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    backend
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    schemaId'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    path'
        Settings -> IO Settings
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Settings
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::new_with_path
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "schema_id"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the id of the schema"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the path to use" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Settings" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_new_with_path" g_settings_new_with_path ::
        CString ->                              -- schema_id : TBasicType TUTF8
        CString ->                              -- path : TBasicType TUTF8
        IO (Ptr Settings)

    -- | Creates a new t'GI.Gio.Objects.Settings.Settings' object with the relocatable schema specified
    -- by /@schemaId@/ and a given path.
    --
    -- You only need to do this if you want to directly create a settings
    -- object with a schema that doesn\'t have a specified path of its own.
    -- That\'s quite rare.
    --
    -- It is a programmer error to call this function for a schema that
    -- has an explicitly specified path.
    --
    -- It is a programmer error if /@path@/ is not a valid path.  A valid path
    -- begins and ends with \'\/\' and does not contain two consecutive \'\/\'
    -- characters.
    --
    -- /Since: 2.26/
    settingsNewWithPath ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@schemaId@/: the id of the schema
        -> T.Text
        -- ^ /@path@/: the path to use
        -> m Settings
        -- ^ __Returns:__ a new t'GI.Gio.Objects.Settings.Settings' object
    settingsNewWithPath :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Text -> m Settings
    settingsNewWithPath Text
    schemaId Text
    path = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Settings -> m Settings) -> IO Settings -> m Settings
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    schemaId' <- Text -> IO CString
    textToCString Text
    schemaId
        CString
    path' <- Text -> IO CString
    textToCString Text
    path
        Ptr Settings
    result <- CString -> CString -> IO (Ptr Settings)
    g_settings_new_with_path CString
    schemaId' CString
    path'
        Text -> Ptr Settings -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsNewWithPath" Ptr Settings
    result
        Settings
    result' <- ((ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Settings -> Settings
    Settings) Ptr Settings
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    schemaId'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    path'
        Settings -> IO Settings
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Settings
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::apply
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings instance"
    --                 , 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 "g_settings_apply" g_settings_apply ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        IO ()

    -- | Applies any changes that have been made to the settings.  This
    -- function does nothing unless /@settings@/ is in \'delay-apply\' mode;
    -- see 'GI.Gio.Objects.Settings.settingsDelay'.  In the normal case settings are always
    -- applied immediately.
    settingsApply ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' instance
        -> m ()
    settingsApply :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> m ()
    settingsApply a
    settings = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        Ptr Settings -> IO ()
    g_settings_apply Ptr Settings
    settings'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsApplyMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsApplyMethodInfo a signature where
        overloadedMethod = settingsApply

    instance O.OverloadedMethodInfo SettingsApplyMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsApply",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsApply"
            })

    #endif

    -- method Settings::bind
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to bind" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "object"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the property to bind"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsBindFlags" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "flags for the binding"
    --                 , 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 "g_settings_bind" g_settings_bind ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
        CString ->                              -- property : TBasicType TUTF8
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "SettingsBindFlags"})
        IO ()

    -- | Create a binding between the /@key@/ in the /@settings@/ object
    -- and the property /@property@/ of /@object@/.
    --
    -- The binding uses the default GIO mapping functions to map
    -- between the settings and property values. These functions
    -- handle booleans, numeric types and string types in a
    -- straightforward way. Use @/g_settings_bind_with_mapping()/@ if
    -- you need a custom mapping, or map between types that are not
    -- supported by the default mapping functions.
    --
    -- Unless the /@flags@/ include 'GI.Gio.Flags.SettingsBindFlagsNoSensitivity', this
    -- function also establishes a binding between the writability of
    -- /@key@/ and the \"sensitive\" property of /@object@/ (if /@object@/ has
    -- a boolean property by that name). See 'GI.Gio.Objects.Settings.settingsBindWritable'
    -- for more details about writable bindings.
    --
    -- Note that the lifecycle of the binding is tied to /@object@/,
    -- and that you can have only one binding per object property.
    -- If you bind the same property twice on the same object, the second
    -- binding overrides the first one.
    --
    -- /Since: 2.26/
    settingsBind ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a, GObject.Object.IsObject b) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to bind
        -> b
        -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
        -> T.Text
        -- ^ /@property@/: the name of the property to bind
        -> [Gio.Flags.SettingsBindFlags]
        -- ^ /@flags@/: flags for the binding
        -> m ()
    settingsBind :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSettings a, IsObject b) =>
    a -> Text -> b -> Text -> [SettingsBindFlags] -> m ()
    settingsBind a
    settings Text
    key b
    object Text
    property [SettingsBindFlags]
    flags = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr Object
    object' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    object
        CString
    property' <- Text -> IO CString
    textToCString Text
    property
        let flags' :: CUInt
    flags' = [SettingsBindFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [SettingsBindFlags]
    flags
        Ptr Settings -> CString -> Ptr Object -> CString -> CUInt -> IO ()
    g_settings_bind Ptr Settings
    settings' CString
    key' Ptr Object
    object' CString
    property' CUInt
    flags'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    object
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    property'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsBindMethodInfo
    instance (signature ~ (T.Text -> b -> T.Text -> [Gio.Flags.SettingsBindFlags] -> m ()), MonadIO m, IsSettings a, GObject.Object.IsObject b) => O.OverloadedMethod SettingsBindMethodInfo a signature where
        overloadedMethod = settingsBind

    instance O.OverloadedMethodInfo SettingsBindMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsBind",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsBind"
            })

    #endif

    -- method Settings::bind_with_mapping
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to bind" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "object"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the property to bind"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsBindFlags" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "flags for the binding"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "get_mapping"
    --           , argType = TGClosure Nothing
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a function that gets called to convert values\n    from @settings to @object, or %NULL to use the default GIO mapping"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "set_mapping"
    --           , argType = TGClosure Nothing
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a function that gets called to convert values\n    from @object to @settings, or %NULL to use the default GIO mapping"
    --                 , 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 "g_settings_bind_with_mapping_closures" g_settings_bind_with_mapping_closures ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
        CString ->                              -- property : TBasicType TUTF8
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "SettingsBindFlags"})
        Ptr (GClosure ()) ->                    -- get_mapping : TGClosure Nothing
        Ptr (GClosure ()) ->                    -- set_mapping : TGClosure Nothing
        IO ()

    -- | Version of @/g_settings_bind_with_mapping()/@ using closures instead of callbacks
    -- for easier binding in other languages.
    --
    -- /Since: 2.82/
    settingsBindWithMapping ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a, GObject.Object.IsObject b) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to bind
        -> b
        -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
        -> T.Text
        -- ^ /@property@/: the name of the property to bind
        -> [Gio.Flags.SettingsBindFlags]
        -- ^ /@flags@/: flags for the binding
        -> Maybe (GClosure c)
        -- ^ /@getMapping@/: a function that gets called to convert values
        --     from /@settings@/ to /@object@/, or 'P.Nothing' to use the default GIO mapping
        -> Maybe (GClosure d)
        -- ^ /@setMapping@/: a function that gets called to convert values
        --     from /@object@/ to /@settings@/, or 'P.Nothing' to use the default GIO mapping
        -> m ()
    settingsBindWithMapping :: forall (m :: * -> *) a b c d.
    (HasCallStack, MonadIO m, IsSettings a, IsObject b) =>
    a
    -> Text
    -> b
    -> Text
    -> [SettingsBindFlags]
    -> Maybe (GClosure c)
    -> Maybe (GClosure d)
    -> m ()
    settingsBindWithMapping a
    settings Text
    key b
    object Text
    property [SettingsBindFlags]
    flags Maybe (GClosure c)
    getMapping Maybe (GClosure d)
    setMapping = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr Object
    object' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    object
        CString
    property' <- Text -> IO CString
    textToCString Text
    property
        let flags' :: CUInt
    flags' = [SettingsBindFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [SettingsBindFlags]
    flags
        Ptr (GClosure ())
    maybeGetMapping <- case Maybe (GClosure c)
    getMapping of
            Maybe (GClosure c)
    Nothing -> Ptr (GClosure ()) -> IO (Ptr (GClosure ()))
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr (GClosure ())
    forall a. Ptr a
    FP.nullPtr
            Just GClosure c
    jGetMapping -> do
                Ptr (GClosure ())
    jGetMapping' <- GClosure c -> IO (Ptr (GClosure ()))
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr GClosure c
    jGetMapping
                Ptr (GClosure ()) -> IO (Ptr (GClosure ()))
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr (GClosure ())
    jGetMapping'
        Ptr (GClosure ())
    maybeSetMapping <- case Maybe (GClosure d)
    setMapping of
            Maybe (GClosure d)
    Nothing -> Ptr (GClosure ()) -> IO (Ptr (GClosure ()))
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr (GClosure ())
    forall a. Ptr a
    FP.nullPtr
            Just GClosure d
    jSetMapping -> do
                Ptr (GClosure ())
    jSetMapping' <- GClosure d -> IO (Ptr (GClosure ()))
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr GClosure d
    jSetMapping
                Ptr (GClosure ()) -> IO (Ptr (GClosure ()))
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr (GClosure ())
    jSetMapping'
        Ptr Settings
    -> CString
    -> Ptr Object
    -> CString
    -> CUInt
    -> Ptr (GClosure ())
    -> Ptr (GClosure ())
    -> IO ()
    g_settings_bind_with_mapping_closures Ptr Settings
    settings' CString
    key' Ptr Object
    object' CString
    property' CUInt
    flags' Ptr (GClosure ())
    maybeGetMapping Ptr (GClosure ())
    maybeSetMapping
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    object
        Maybe (GClosure c) -> (GClosure c -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe (GClosure c)
    getMapping GClosure c -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        Maybe (GClosure d) -> (GClosure d -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe (GClosure d)
    setMapping GClosure d -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    property'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsBindWithMappingMethodInfo
    instance (signature ~ (T.Text -> b -> T.Text -> [Gio.Flags.SettingsBindFlags] -> Maybe (GClosure c) -> Maybe (GClosure d) -> m ()), MonadIO m, IsSettings a, GObject.Object.IsObject b) => O.OverloadedMethod SettingsBindWithMappingMethodInfo a signature where
        overloadedMethod = settingsBindWithMapping

    instance O.OverloadedMethodInfo SettingsBindWithMappingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsBindWithMapping",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsBindWithMapping"
            })

    #endif

    -- method Settings::bind_writable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to bind" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "object"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of a boolean property to bind"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "inverted"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to 'invert' the value"
    --                 , 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 "g_settings_bind_writable" g_settings_bind_writable ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
        CString ->                              -- property : TBasicType TUTF8
        CInt ->                                 -- inverted : TBasicType TBoolean
        IO ()

    -- | Create a binding between the writability of /@key@/ in the
    -- /@settings@/ object and the property /@property@/ of /@object@/.
    -- The property must be boolean; \"sensitive\" or \"visible\"
    -- properties of widgets are the most likely candidates.
    --
    -- Writable bindings are always uni-directional; changes of the
    -- writability of the setting will be propagated to the object
    -- property, not the other way.
    --
    -- When the /@inverted@/ argument is 'P.True', the binding inverts the
    -- value as it passes from the setting to the object, i.e. /@property@/
    -- will be set to 'P.True' if the key is not writable.
    --
    -- Note that the lifecycle of the binding is tied to /@object@/,
    -- and that you can have only one binding per object property.
    -- If you bind the same property twice on the same object, the second
    -- binding overrides the first one.
    --
    -- /Since: 2.26/
    settingsBindWritable ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a, GObject.Object.IsObject b) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to bind
        -> b
        -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
        -> T.Text
        -- ^ /@property@/: the name of a boolean property to bind
        -> Bool
        -- ^ /@inverted@/: whether to \'invert\' the value
        -> m ()
    settingsBindWritable :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSettings a, IsObject b) =>
    a -> Text -> b -> Text -> Bool -> m ()
    settingsBindWritable a
    settings Text
    key b
    object Text
    property Bool
    inverted = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr Object
    object' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    object
        CString
    property' <- Text -> IO CString
    textToCString Text
    property
        let inverted' :: CInt
    inverted' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    inverted
        Ptr Settings -> CString -> Ptr Object -> CString -> CInt -> IO ()
    g_settings_bind_writable Ptr Settings
    settings' CString
    key' Ptr Object
    object' CString
    property' CInt
    inverted'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    object
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    property'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsBindWritableMethodInfo
    instance (signature ~ (T.Text -> b -> T.Text -> Bool -> m ()), MonadIO m, IsSettings a, GObject.Object.IsObject b) => O.OverloadedMethod SettingsBindWritableMethodInfo a signature where
        overloadedMethod = settingsBindWritable

    instance O.OverloadedMethodInfo SettingsBindWritableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsBindWritable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsBindWritable"
            })

    #endif

    -- method Settings::create_action
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of a key in @settings"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Action" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_create_action" g_settings_create_action ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO (Ptr Gio.Action.Action)

    -- | Creates a t'GI.Gio.Interfaces.Action.Action' corresponding to a given t'GI.Gio.Objects.Settings.Settings' key.
    --
    -- The action has the same name as the key.
    --
    -- The value of the key becomes the state of the action and the action
    -- is enabled when the key is writable.  Changing the state of the
    -- action results in the key being written to.  Changes to the value or
    -- writability of the key cause appropriate change notifications to be
    -- emitted for the action.
    --
    -- For boolean-valued keys, action activations take no parameter and
    -- result in the toggling of the value.  For all other types,
    -- activations take the new value for the key (which must have the
    -- correct type).
    --
    -- /Since: 2.32/
    settingsCreateAction ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings'
        -> T.Text
        -- ^ /@key@/: the name of a key in /@settings@/
        -> m Gio.Action.Action
        -- ^ __Returns:__ a new t'GI.Gio.Interfaces.Action.Action'
    settingsCreateAction :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Action
    settingsCreateAction a
    settings Text
    key = IO Action -> m Action
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Action -> m Action) -> IO Action -> m Action
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr Action
    result <- Ptr Settings -> CString -> IO (Ptr Action)
    g_settings_create_action Ptr Settings
    settings' CString
    key'
        Text -> Ptr Action -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsCreateAction" Ptr Action
    result
        Action
    result' <- ((ManagedPtr Action -> Action) -> Ptr Action -> IO Action
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Action -> Action
    Gio.Action.Action) Ptr Action
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Action -> IO Action
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Action
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsCreateActionMethodInfo
    instance (signature ~ (T.Text -> m Gio.Action.Action), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsCreateActionMethodInfo a signature where
        overloadedMethod = settingsCreateAction

    instance O.OverloadedMethodInfo SettingsCreateActionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsCreateAction",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsCreateAction"
            })

    #endif

    -- method Settings::delay
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , 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 "g_settings_delay" g_settings_delay ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        IO ()

    -- | Changes the t'GI.Gio.Objects.Settings.Settings' object into \'delay-apply\' mode. In this
    -- mode, changes to /@settings@/ are not immediately propagated to the
    -- backend, but kept locally until 'GI.Gio.Objects.Settings.settingsApply' is called.
    --
    -- /Since: 2.26/
    settingsDelay ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> m ()
    settingsDelay :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> m ()
    settingsDelay a
    settings = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        Ptr Settings -> IO ()
    g_settings_delay Ptr Settings
    settings'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsDelayMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsDelayMethodInfo a signature where
        overloadedMethod = settingsDelay

    instance O.OverloadedMethodInfo SettingsDelayMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsDelay",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsDelay"
            })

    #endif

    -- method Settings::get_boolean
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , 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 "g_settings_get_boolean" g_settings_get_boolean ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO CInt

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for booleans.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a boolean type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetBoolean ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Bool
        -- ^ __Returns:__ a boolean
    settingsGetBoolean :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Bool
    settingsGetBoolean a
    settings Text
    key = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> IO CInt
    g_settings_get_boolean Ptr Settings
    settings' CString
    key'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetBooleanMethodInfo
    instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetBooleanMethodInfo a signature where
        overloadedMethod = settingsGetBoolean

    instance O.OverloadedMethodInfo SettingsGetBooleanMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetBoolean",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetBoolean"
            })

    #endif

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

    foreign import ccall "g_settings_get_child" g_settings_get_child ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- name : TBasicType TUTF8
        IO (Ptr Settings)

    -- | Creates a child settings object which has a base path of
    -- @base-path\/\@name@, where @base-path@ is the base path of
    -- /@settings@/.
    --
    -- The schema for the child settings object must have been declared
    -- in the schema of /@settings@/ using a @\<child>@ element.
    --
    -- The created child settings object will inherit the [Settings:delayApply]("GI.Gio.Objects.Settings#g:attr:delayApply")
    -- mode from /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@name@/: the name of the child schema
        -> m Settings
        -- ^ __Returns:__ a \'child\' settings object
    settingsGetChild :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Settings
    settingsGetChild a
    settings Text
    name = IO Settings -> m Settings
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Settings -> m Settings) -> IO Settings -> m Settings
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        Ptr Settings
    result <- Ptr Settings -> CString -> IO (Ptr Settings)
    g_settings_get_child Ptr Settings
    settings' CString
    name'
        Text -> Ptr Settings -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsGetChild" Ptr Settings
    result
        Settings
    result' <- ((ManagedPtr Settings -> Settings) -> Ptr Settings -> IO Settings
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Settings -> Settings
    Settings) Ptr Settings
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        Settings -> IO Settings
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Settings
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetChildMethodInfo
    instance (signature ~ (T.Text -> m Settings), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetChildMethodInfo a signature where
        overloadedMethod = settingsGetChild

    instance O.OverloadedMethodInfo SettingsGetChildMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetChild",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetChild"
            })

    #endif

    -- method Settings::get_default_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the default value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just TVariant
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_default_value" g_settings_get_default_value ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO (Ptr GVariant)

    -- | Gets the \"default value\" of a key.
    --
    -- This is the value that would be read if 'GI.Gio.Objects.Settings.settingsReset' were to be
    -- called on the key.
    --
    -- Note that this may be a different value than returned by
    -- 'GI.Gio.Structs.SettingsSchemaKey.settingsSchemaKeyGetDefaultValue' if the system administrator
    -- has provided a default value.
    --
    -- Comparing the return values of 'GI.Gio.Objects.Settings.settingsGetDefaultValue' and
    -- 'GI.Gio.Objects.Settings.settingsGetValue' is not sufficient for determining if a value
    -- has been set because the user may have explicitly set the value to
    -- something that happens to be equal to the default.  The difference
    -- here is that if the default changes in the future, the user\'s key
    -- will still be set.
    --
    -- This function may be useful for adding an indication to a UI of what
    -- the default value was before the user set it.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/.
    --
    -- /Since: 2.40/
    settingsGetDefaultValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the default value for
        -> m (Maybe GVariant)
        -- ^ __Returns:__ the default value
    settingsGetDefaultValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m (Maybe GVariant)
    settingsGetDefaultValue a
    settings Text
    key = IO (Maybe GVariant) -> m (Maybe GVariant)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
    -> IO (Maybe GVariant) -> m (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr GVariant
    result <- Ptr Settings -> CString -> IO (Ptr GVariant)
    g_settings_get_default_value Ptr Settings
    settings' CString
    key'
        Maybe GVariant
    maybeResult <- Ptr GVariant
    -> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr GVariant
    result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
    -> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ \Ptr GVariant
    result' -> do
            GVariant
    result'' <- Ptr GVariant -> IO GVariant
    B.GVariant.wrapGVariantPtr Ptr GVariant
    result'
            GVariant -> IO GVariant
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GVariant
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Maybe GVariant -> IO (Maybe GVariant)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GVariant
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetDefaultValueMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetDefaultValueMethodInfo a signature where
        overloadedMethod = settingsGetDefaultValue

    instance O.OverloadedMethodInfo SettingsGetDefaultValueMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetDefaultValue",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetDefaultValue"
            })

    #endif

    -- method Settings::get_double
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TDouble)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_double" g_settings_get_double ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO CDouble

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for doubles.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a \'double\' type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetDouble ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Double
        -- ^ __Returns:__ a double
    settingsGetDouble :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Double
    settingsGetDouble a
    settings Text
    key = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CDouble
    result <- Ptr Settings -> CString -> IO CDouble
    g_settings_get_double Ptr Settings
    settings' CString
    key'
        let result' :: Double
    result' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Double -> IO Double
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Double
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetDoubleMethodInfo
    instance (signature ~ (T.Text -> m Double), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetDoubleMethodInfo a signature where
        overloadedMethod = settingsGetDouble

    instance O.OverloadedMethodInfo SettingsGetDoubleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetDouble",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetDouble"
            })

    #endif

    -- method Settings::get_enum
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_enum" g_settings_get_enum ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO Int32

    -- | Gets the value that is stored in /@settings@/ for /@key@/ and converts it
    -- to the enum value that it represents.
    --
    -- In order to use this function the type of the value must be a string
    -- and it must be marked in the schema file as an enumerated type.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/ or is not marked as an enumerated type.
    --
    -- If the value stored in the configuration database is not a valid
    -- value for the enumerated type then this function will return the
    -- default value.
    --
    -- /Since: 2.26/
    settingsGetEnum ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Int32
        -- ^ __Returns:__ the enum value
    settingsGetEnum :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Int32
    settingsGetEnum a
    settings Text
    key = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Int32
    result <- Ptr Settings -> CString -> IO Int32
    g_settings_get_enum Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Int32 -> IO Int32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetEnumMethodInfo
    instance (signature ~ (T.Text -> m Int32), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetEnumMethodInfo a signature where
        overloadedMethod = settingsGetEnum

    instance O.OverloadedMethodInfo SettingsGetEnumMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetEnum",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetEnum"
            })

    #endif

    -- method Settings::get_flags
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_flags" g_settings_get_flags ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO Word32

    -- | Gets the value that is stored in /@settings@/ for /@key@/ and converts it
    -- to the flags value that it represents.
    --
    -- In order to use this function the type of the value must be an array
    -- of strings and it must be marked in the schema file as a flags type.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/ or is not marked as a flags type.
    --
    -- If the value stored in the configuration database is not a valid
    -- value for the flags type then this function will return the default
    -- value.
    --
    -- /Since: 2.26/
    settingsGetFlags ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Word32
        -- ^ __Returns:__ the flags value
    settingsGetFlags :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Word32
    settingsGetFlags a
    settings Text
    key = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Word32
    result <- Ptr Settings -> CString -> IO Word32
    g_settings_get_flags Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetFlagsMethodInfo
    instance (signature ~ (T.Text -> m Word32), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetFlagsMethodInfo a signature where
        overloadedMethod = settingsGetFlags

    instance O.OverloadedMethodInfo SettingsGetFlagsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetFlags",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetFlags"
            })

    #endif

    -- method Settings::get_has_unapplied
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , 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 "g_settings_get_has_unapplied" g_settings_get_has_unapplied ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        IO CInt

    -- | Returns whether the t'GI.Gio.Objects.Settings.Settings' object has any unapplied
    -- changes.  This can only be the case if it is in \'delayed-apply\' mode.
    --
    -- /Since: 2.26/
    settingsGetHasUnapplied ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@settings@/ has unapplied changes
    settingsGetHasUnapplied :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> m Bool
    settingsGetHasUnapplied a
    settings = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CInt
    result <- Ptr Settings -> IO CInt
    g_settings_get_has_unapplied Ptr Settings
    settings'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetHasUnappliedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetHasUnappliedMethodInfo a signature where
        overloadedMethod = settingsGetHasUnapplied

    instance O.OverloadedMethodInfo SettingsGetHasUnappliedMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetHasUnapplied",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetHasUnapplied"
            })

    #endif

    -- method Settings::get_int
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_int" g_settings_get_int ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO Int32

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for 32-bit integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a int32 type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetInt ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Int32
        -- ^ __Returns:__ an integer
    settingsGetInt :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Int32
    settingsGetInt a
    settings Text
    key = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Int32
    result <- Ptr Settings -> CString -> IO Int32
    g_settings_get_int Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Int32 -> IO Int32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetIntMethodInfo
    instance (signature ~ (T.Text -> m Int32), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetIntMethodInfo a signature where
        overloadedMethod = settingsGetInt

    instance O.OverloadedMethodInfo SettingsGetIntMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetInt",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetInt"
            })

    #endif

    -- method Settings::get_int64
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt64)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_int64" g_settings_get_int64 ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO Int64

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for 64-bit integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a int64 type in the schema for /@settings@/.
    --
    -- /Since: 2.50/
    settingsGetInt64 ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Int64
        -- ^ __Returns:__ a 64-bit integer
    settingsGetInt64 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Int64
    settingsGetInt64 a
    settings Text
    key = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Int64
    result <- Ptr Settings -> CString -> IO Int64
    g_settings_get_int64 Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Int64 -> IO Int64
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int64
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetInt64MethodInfo
    instance (signature ~ (T.Text -> m Int64), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetInt64MethodInfo a signature where
        overloadedMethod = settingsGetInt64

    instance O.OverloadedMethodInfo SettingsGetInt64MethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetInt64",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetInt64"
            })

    #endif

    -- method Settings::get_mapped
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "mapping"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SettingsGetMapping" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the function to map the value in the\n          settings database to the value used by the application"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeCall
    --           , argClosure = 3
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data for @mapping"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_mapped" g_settings_get_mapped ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        FunPtr Gio.Callbacks.C_SettingsGetMapping -> -- mapping : TInterface (Name {namespace = "Gio", name = "SettingsGetMapping"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO (Ptr ())

    -- | Gets the value that is stored at /@key@/ in /@settings@/, subject to
    -- application-level validation\/mapping.
    --
    -- You should use this function when the application needs to perform
    -- some processing on the value of the key (for example, parsing).  The
    -- /@mapping@/ function performs that processing.  If the function
    -- indicates that the processing was unsuccessful (due to a parse error,
    -- for example) then the mapping is tried again with another value.
    --
    -- This allows a robust \'fall back to defaults\' behaviour to be
    -- implemented somewhat automatically.
    --
    -- The first value that is tried is the user\'s setting for the key.  If
    -- the mapping function fails to map this value, other values may be
    -- tried in an unspecified order (system or site defaults, translated
    -- schema default values, untranslated schema default values, etc).
    --
    -- If the mapping function fails for all possible values, one additional
    -- attempt is made: the mapping function is called with a 'P.Nothing' value.
    -- If the mapping function still indicates failure at this point then
    -- the application will be aborted.
    --
    -- The result parameter for the /@mapping@/ function is pointed to a
    -- @/gpointer/@ which is initially set to 'P.Nothing'.  The same pointer is given
    -- to each invocation of /@mapping@/.  The final value of that @/gpointer/@ is
    -- what is returned by this function.  'P.Nothing' is valid; it is returned
    -- just as any other value would be.
    settingsGetMapped ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> Gio.Callbacks.SettingsGetMapping
        -- ^ /@mapping@/: the function to map the value in the
        --           settings database to the value used by the application
        -> m (Ptr ())
        -- ^ __Returns:__ the result, which may be 'P.Nothing'
    settingsGetMapped :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> SettingsGetMapping -> m (Ptr ())
    settingsGetMapped a
    settings Text
    key SettingsGetMapping
    mapping = IO (Ptr ()) -> m (Ptr ())
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        FunPtr C_SettingsGetMapping
    mapping' <- C_SettingsGetMapping -> IO (FunPtr C_SettingsGetMapping)
    Gio.Callbacks.mk_SettingsGetMapping (Maybe (Ptr (FunPtr C_SettingsGetMapping))
    -> SettingsGetMapping_WithClosures -> C_SettingsGetMapping
    Gio.Callbacks.wrap_SettingsGetMapping Maybe (Ptr (FunPtr C_SettingsGetMapping))
    forall a. Maybe a
    Nothing (SettingsGetMapping -> SettingsGetMapping_WithClosures
    Gio.Callbacks.drop_closures_SettingsGetMapping SettingsGetMapping
    mapping))
        let userData :: Ptr a
    userData = Ptr a
    forall a. Ptr a
    nullPtr
        Ptr ()
    result <- Ptr Settings
    -> CString -> FunPtr C_SettingsGetMapping -> Ptr () -> IO (Ptr ())
    g_settings_get_mapped Ptr Settings
    settings' CString
    key' FunPtr C_SettingsGetMapping
    mapping' Ptr ()
    forall a. Ptr a
    userData
        Ptr Any -> IO ()
    forall a. Ptr a -> IO ()
    safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr C_SettingsGetMapping -> Ptr Any
    forall a b. FunPtr a -> Ptr b
    castFunPtrToPtr FunPtr C_SettingsGetMapping
    mapping'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Ptr () -> IO (Ptr ())
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ()
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetMappedMethodInfo
    instance (signature ~ (T.Text -> Gio.Callbacks.SettingsGetMapping -> m (Ptr ())), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetMappedMethodInfo a signature where
        overloadedMethod = settingsGetMapped

    instance O.OverloadedMethodInfo SettingsGetMappedMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetMapped",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetMapped"
            })

    #endif

    -- method Settings::get_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to query the range of"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just TVariant
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_range" g_settings_get_range ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO (Ptr GVariant)

    {-# DEPRECATED settingsGetRange ["(Since version 2.40)","Use 'GI.Gio.Structs.SettingsSchemaKey.settingsSchemaKeyGetRange' instead."] #-}
    -- | Queries the range of a key.
    --
    -- /Since: 2.28/
    settingsGetRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings'
        -> T.Text
        -- ^ /@key@/: the key to query the range of
        -> m GVariant
    settingsGetRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m GVariant
    settingsGetRange a
    settings Text
    key = IO GVariant -> m GVariant
    forall a. IO a -> m a
    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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr GVariant
    result <- Ptr Settings -> CString -> IO (Ptr GVariant)
    g_settings_get_range Ptr Settings
    settings' CString
    key'
        Text -> Ptr GVariant -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsGetRange" Ptr GVariant
    result
        GVariant
    result' <- Ptr GVariant -> IO GVariant
    B.GVariant.wrapGVariantPtr Ptr GVariant
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        GVariant -> IO GVariant
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GVariant
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetRangeMethodInfo
    instance (signature ~ (T.Text -> m GVariant), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetRangeMethodInfo a signature where
        overloadedMethod = settingsGetRange

    instance O.OverloadedMethodInfo SettingsGetRangeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetRange",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetRange"
            })

    #endif

    -- method Settings::get_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , 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 "g_settings_get_string" g_settings_get_string ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO CString

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for strings.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a string type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetString ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m T.Text
        -- ^ __Returns:__ a newly-allocated string
    settingsGetString :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Text
    settingsGetString a
    settings Text
    key = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CString
    result <- Ptr Settings -> CString -> IO CString
    g_settings_get_string Ptr Settings
    settings' CString
    key'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsGetString" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetStringMethodInfo
    instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetStringMethodInfo a signature where
        overloadedMethod = settingsGetString

    instance O.OverloadedMethodInfo SettingsGetStringMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetString",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetString"
            })

    #endif

    -- method Settings::get_strv
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_strv" g_settings_get_strv ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO (Ptr CString)

    -- | A convenience variant of @/g_settings_get()/@ for string arrays.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having an array of strings type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetStrv ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m [T.Text]
        -- ^ __Returns:__ a
        -- newly-allocated, 'P.Nothing'-terminated array of strings, the value that
        -- is stored at /@key@/ in /@settings@/.
    settingsGetStrv :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m [Text]
    settingsGetStrv a
    settings Text
    key = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr CString
    result <- Ptr Settings -> CString -> IO (Ptr CString)
    g_settings_get_strv Ptr Settings
    settings' CString
    key'
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsGetStrv" Ptr CString
    result
        [Text]
    result' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result
        (CString -> IO ()) -> Ptr CString -> IO ()
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
    mapZeroTerminatedCArray CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        Ptr CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        [Text] -> IO [Text]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetStrvMethodInfo
    instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetStrvMethodInfo a signature where
        overloadedMethod = settingsGetStrv

    instance O.OverloadedMethodInfo SettingsGetStrvMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetStrv",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetStrv"
            })

    #endif

    -- method Settings::get_uint
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_uint" g_settings_get_uint ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO Word32

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for 32-bit unsigned
    -- integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a uint32 type in the schema for /@settings@/.
    --
    -- /Since: 2.30/
    settingsGetUint ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Word32
        -- ^ __Returns:__ an unsigned integer
    settingsGetUint :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Word32
    settingsGetUint a
    settings Text
    key = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Word32
    result <- Ptr Settings -> CString -> IO Word32
    g_settings_get_uint Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetUintMethodInfo
    instance (signature ~ (T.Text -> m Word32), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetUintMethodInfo a signature where
        overloadedMethod = settingsGetUint

    instance O.OverloadedMethodInfo SettingsGetUintMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetUint",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetUint"
            })

    #endif

    -- method Settings::get_uint64
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt64)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_uint64" g_settings_get_uint64 ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO Word64

    -- | Gets the value that is stored at /@key@/ in /@settings@/.
    --
    -- A convenience variant of @/g_settings_get()/@ for 64-bit unsigned
    -- integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a uint64 type in the schema for /@settings@/.
    --
    -- /Since: 2.50/
    settingsGetUint64 ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m Word64
        -- ^ __Returns:__ a 64-bit unsigned integer
    settingsGetUint64 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Word64
    settingsGetUint64 a
    settings Text
    key = IO Word64 -> m Word64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Word64
    result <- Ptr Settings -> CString -> IO Word64
    g_settings_get_uint64 Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Word64 -> IO Word64
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word64
    result

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetUint64MethodInfo
    instance (signature ~ (T.Text -> m Word64), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetUint64MethodInfo a signature where
        overloadedMethod = settingsGetUint64

    instance O.OverloadedMethodInfo SettingsGetUint64MethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetUint64",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetUint64"
            })

    #endif

    -- method Settings::get_user_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the user value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just TVariant
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_user_value" g_settings_get_user_value ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO (Ptr GVariant)

    -- | Checks the \"user value\" of a key, if there is one.
    --
    -- The user value of a key is the last value that was set by the user.
    --
    -- After calling 'GI.Gio.Objects.Settings.settingsReset' this function should always return
    -- 'P.Nothing' (assuming something is not wrong with the system
    -- configuration).
    --
    -- It is possible that 'GI.Gio.Objects.Settings.settingsGetValue' will return a different
    -- value than this function.  This can happen in the case that the user
    -- set a value for a key that was subsequently locked down by the system
    -- administrator -- this function will return the user\'s old value.
    --
    -- This function may be useful for adding a \"reset\" option to a UI or
    -- for providing indication that a particular value has been changed.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/.
    --
    -- /Since: 2.40/
    settingsGetUserValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the user value for
        -> m (Maybe GVariant)
        -- ^ __Returns:__ the user\'s value, if set
    settingsGetUserValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m (Maybe GVariant)
    settingsGetUserValue a
    settings Text
    key = IO (Maybe GVariant) -> m (Maybe GVariant)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
    -> IO (Maybe GVariant) -> m (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr GVariant
    result <- Ptr Settings -> CString -> IO (Ptr GVariant)
    g_settings_get_user_value Ptr Settings
    settings' CString
    key'
        Maybe GVariant
    maybeResult <- Ptr GVariant
    -> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr GVariant
    result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
    -> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ \Ptr GVariant
    result' -> do
            GVariant
    result'' <- Ptr GVariant -> IO GVariant
    B.GVariant.wrapGVariantPtr Ptr GVariant
    result'
            GVariant -> IO GVariant
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GVariant
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Maybe GVariant -> IO (Maybe GVariant)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GVariant
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetUserValueMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetUserValueMethodInfo a signature where
        overloadedMethod = settingsGetUserValue

    instance O.OverloadedMethodInfo SettingsGetUserValueMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetUserValue",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetUserValue"
            })

    #endif

    -- method Settings::get_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to get the value for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just TVariant
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_get_value" g_settings_get_value ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO (Ptr GVariant)

    -- | Gets the value that is stored in /@settings@/ for /@key@/.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsGetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the key to get the value for
        -> m GVariant
        -- ^ __Returns:__ a new t'GVariant'
    settingsGetValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m GVariant
    settingsGetValue a
    settings Text
    key = IO GVariant -> m GVariant
    forall a. IO a -> m a
    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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr GVariant
    result <- Ptr Settings -> CString -> IO (Ptr GVariant)
    g_settings_get_value Ptr Settings
    settings' CString
    key'
        Text -> Ptr GVariant -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsGetValue" Ptr GVariant
    result
        GVariant
    result' <- Ptr GVariant -> IO GVariant
    B.GVariant.wrapGVariantPtr Ptr GVariant
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        GVariant -> IO GVariant
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GVariant
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsGetValueMethodInfo
    instance (signature ~ (T.Text -> m GVariant), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetValueMethodInfo a signature where
        overloadedMethod = settingsGetValue

    instance O.OverloadedMethodInfo SettingsGetValueMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsGetValue",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsGetValue"
            })

    #endif

    -- method Settings::is_writable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of a key" , 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 "g_settings_is_writable" g_settings_is_writable ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- name : TBasicType TUTF8
        IO CInt

    -- | Finds out if a key can be written or not
    --
    -- /Since: 2.26/
    settingsIsWritable ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@name@/: the name of a key
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the key /@name@/ is writable
    settingsIsWritable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m Bool
    settingsIsWritable a
    settings Text
    name = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        CInt
    result <- Ptr Settings -> CString -> IO CInt
    g_settings_is_writable Ptr Settings
    settings' CString
    name'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsIsWritableMethodInfo
    instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsIsWritableMethodInfo a signature where
        overloadedMethod = settingsIsWritable

    instance O.OverloadedMethodInfo SettingsIsWritableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsIsWritable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsIsWritable"
            })

    #endif

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

    foreign import ccall "g_settings_list_children" g_settings_list_children ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        IO (Ptr CString)

    -- | Gets the list of children on /@settings@/.
    --
    -- The list is exactly the list of strings for which it is not an error
    -- to call 'GI.Gio.Objects.Settings.settingsGetChild'.
    --
    -- There is little reason to call this function from \"normal\" code, since
    -- you should already know what children are in your schema. This function
    -- may still be useful there for introspection reasons, however.
    --
    -- You should free the return value with 'GI.GLib.Functions.strfreev' when you are done
    -- with it.
    settingsListChildren ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> m [T.Text]
        -- ^ __Returns:__ a list of the children
        --    on /@settings@/, in no defined order
    settingsListChildren :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> m [Text]
    settingsListChildren a
    settings = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        Ptr CString
    result <- Ptr Settings -> IO (Ptr CString)
    g_settings_list_children Ptr Settings
    settings'
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsListChildren" Ptr CString
    result
        [Text]
    result' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result
        (CString -> IO ()) -> Ptr CString -> IO ()
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
    mapZeroTerminatedCArray CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        Ptr CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        [Text] -> IO [Text]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsListChildrenMethodInfo
    instance (signature ~ (m [T.Text]), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsListChildrenMethodInfo a signature where
        overloadedMethod = settingsListChildren

    instance O.OverloadedMethodInfo SettingsListChildrenMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsListChildren",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsListChildren"
            })

    #endif

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

    foreign import ccall "g_settings_list_keys" g_settings_list_keys ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        IO (Ptr CString)

    {-# DEPRECATED settingsListKeys ["(Since version 2.46)","Use 'GI.Gio.Structs.SettingsSchema.settingsSchemaListKeys' instead."] #-}
    -- | Introspects the list of keys on /@settings@/.
    --
    -- You should probably not be calling this function from \"normal\" code
    -- (since you should already know what keys are in your schema).  This
    -- function is intended for introspection reasons.
    --
    -- You should free the return value with 'GI.GLib.Functions.strfreev' when you are done
    -- with it.
    settingsListKeys ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> m [T.Text]
        -- ^ __Returns:__ a list
        --    of the keys on /@settings@/, in no defined order
    settingsListKeys :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> m [Text]
    settingsListKeys a
    settings = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        Ptr CString
    result <- Ptr Settings -> IO (Ptr CString)
    g_settings_list_keys Ptr Settings
    settings'
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsListKeys" Ptr CString
    result
        [Text]
    result' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result
        (CString -> IO ()) -> Ptr CString -> IO ()
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
    mapZeroTerminatedCArray CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        Ptr CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        [Text] -> IO [Text]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsListKeysMethodInfo
    instance (signature ~ (m [T.Text]), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsListKeysMethodInfo a signature where
        overloadedMethod = settingsListKeys

    instance O.OverloadedMethodInfo SettingsListKeysMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsListKeys",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsListKeys"
            })

    #endif

    -- method Settings::range_check
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the key to check" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_range_check" g_settings_range_check ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Ptr GVariant ->                         -- value : TVariant
        IO CInt

    {-# DEPRECATED settingsRangeCheck ["(Since version 2.40)","Use 'GI.Gio.Structs.SettingsSchemaKey.settingsSchemaKeyRangeCheck' instead."] #-}
    -- | Checks if the given /@value@/ is of the correct type and within the
    -- permitted range for /@key@/.
    --
    -- /Since: 2.28/
    settingsRangeCheck ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings'
        -> T.Text
        -- ^ /@key@/: the key to check
        -> GVariant
        -- ^ /@value@/: the value to check
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@value@/ is valid for /@key@/
    settingsRangeCheck :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> GVariant -> m Bool
    settingsRangeCheck a
    settings Text
    key GVariant
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr GVariant
    value' <- GVariant -> IO (Ptr GVariant)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GVariant
    value
        CInt
    result <- Ptr Settings -> CString -> Ptr GVariant -> IO CInt
    g_settings_range_check Ptr Settings
    settings' CString
    key' Ptr GVariant
    value'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        GVariant -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr GVariant
    value
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsRangeCheckMethodInfo
    instance (signature ~ (T.Text -> GVariant -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsRangeCheckMethodInfo a signature where
        overloadedMethod = settingsRangeCheck

    instance O.OverloadedMethodInfo SettingsRangeCheckMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsRangeCheck",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsRangeCheck"
            })

    #endif

    -- method Settings::reset
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of a key" , 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 "g_settings_reset" g_settings_reset ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        IO ()

    -- | Resets /@key@/ to its default value.
    --
    -- This call resets the key, as much as possible, to its default value.
    -- That might be the value specified in the schema or the one set by the
    -- administrator.
    settingsReset ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of a key
        -> m ()
    settingsReset :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> m ()
    settingsReset a
    settings Text
    key = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr Settings -> CString -> IO ()
    g_settings_reset Ptr Settings
    settings' CString
    key'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsResetMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsResetMethodInfo a signature where
        overloadedMethod = settingsReset

    instance O.OverloadedMethodInfo SettingsResetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsReset",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsReset"
            })

    #endif

    -- method Settings::revert
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings instance"
    --                 , 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 "g_settings_revert" g_settings_revert ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        IO ()

    -- | Reverts all non-applied changes to the settings.  This function
    -- does nothing unless /@settings@/ is in \'delay-apply\' mode; see
    -- 'GI.Gio.Objects.Settings.settingsDelay'.  In the normal case settings are always applied
    -- immediately.
    --
    -- Change notifications will be emitted for affected keys.
    settingsRevert ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' instance
        -> m ()
    settingsRevert :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> m ()
    settingsRevert a
    settings = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        Ptr Settings -> IO ()
    g_settings_revert Ptr Settings
    settings'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SettingsRevertMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsRevertMethodInfo a signature where
        overloadedMethod = settingsRevert

    instance O.OverloadedMethodInfo SettingsRevertMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsRevert",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsRevert"
            })

    #endif

    -- method Settings::set_boolean
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_boolean" g_settings_set_boolean ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        CInt ->                                 -- value : TBasicType TBoolean
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for booleans.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a boolean type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsSetBoolean ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Bool
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetBoolean :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Bool -> m Bool
    settingsSetBoolean a
    settings Text
    key Bool
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        let value' :: CInt
    value' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    value
        CInt
    result <- Ptr Settings -> CString -> CInt -> IO CInt
    g_settings_set_boolean Ptr Settings
    settings' CString
    key' CInt
    value'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetBooleanMethodInfo
    instance (signature ~ (T.Text -> Bool -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetBooleanMethodInfo a signature where
        overloadedMethod = settingsSetBoolean

    instance O.OverloadedMethodInfo SettingsSetBooleanMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetBoolean",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetBoolean"
            })

    #endif

    -- method Settings::set_double
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TDouble
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_double" g_settings_set_double ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        CDouble ->                              -- value : TBasicType TDouble
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for doubles.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a \'double\' type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsSetDouble ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Double
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetDouble :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Double -> m Bool
    settingsSetDouble a
    settings Text
    key Double
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        let value' :: CDouble
    value' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    value
        CInt
    result <- Ptr Settings -> CString -> CDouble -> IO CInt
    g_settings_set_double Ptr Settings
    settings' CString
    key' CDouble
    value'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetDoubleMethodInfo
    instance (signature ~ (T.Text -> Double -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetDoubleMethodInfo a signature where
        overloadedMethod = settingsSetDouble

    instance O.OverloadedMethodInfo SettingsSetDoubleMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetDouble",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetDouble"
            })

    #endif

    -- method Settings::set_enum
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a key, within @settings"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an enumerated value"
    --                 , 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 "g_settings_set_enum" g_settings_set_enum ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Int32 ->                                -- value : TBasicType TInt
        IO CInt

    -- | Looks up the enumerated type nick for /@value@/ and writes it to /@key@/,
    -- within /@settings@/.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/ or is not marked as an enumerated type, or for
    -- /@value@/ not to be a valid value for the named type.
    --
    -- After performing the write, accessing /@key@/ directly with
    -- 'GI.Gio.Objects.Settings.settingsGetString' will return the \'nick\' associated with
    -- /@value@/.
    settingsSetEnum ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: a key, within /@settings@/
        -> Int32
        -- ^ /@value@/: an enumerated value
        -> m Bool
        -- ^ __Returns:__ 'P.True', if the set succeeds
    settingsSetEnum :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Int32 -> m Bool
    settingsSetEnum a
    settings Text
    key Int32
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> Int32 -> IO CInt
    g_settings_set_enum Ptr Settings
    settings' CString
    key' Int32
    value
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetEnumMethodInfo
    instance (signature ~ (T.Text -> Int32 -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetEnumMethodInfo a signature where
        overloadedMethod = settingsSetEnum

    instance O.OverloadedMethodInfo SettingsSetEnumMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetEnum",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetEnum"
            })

    #endif

    -- method Settings::set_flags
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a key, within @settings"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TUInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a flags value" , 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 "g_settings_set_flags" g_settings_set_flags ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Word32 ->                               -- value : TBasicType TUInt
        IO CInt

    -- | Looks up the flags type nicks for the bits specified by /@value@/, puts
    -- them in an array of strings and writes the array to /@key@/, within
    -- /@settings@/.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/ or is not marked as a flags type, or for /@value@/
    -- to contain any bits that are not value for the named type.
    --
    -- After performing the write, accessing /@key@/ directly with
    -- 'GI.Gio.Objects.Settings.settingsGetStrv' will return an array of \'nicks\'; one for each
    -- bit in /@value@/.
    settingsSetFlags ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: a key, within /@settings@/
        -> Word32
        -- ^ /@value@/: a flags value
        -> m Bool
        -- ^ __Returns:__ 'P.True', if the set succeeds
    settingsSetFlags :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Word32 -> m Bool
    settingsSetFlags a
    settings Text
    key Word32
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> Word32 -> IO CInt
    g_settings_set_flags Ptr Settings
    settings' CString
    key' Word32
    value
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetFlagsMethodInfo
    instance (signature ~ (T.Text -> Word32 -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetFlagsMethodInfo a signature where
        overloadedMethod = settingsSetFlags

    instance O.OverloadedMethodInfo SettingsSetFlagsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetFlags",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetFlags"
            })

    #endif

    -- method Settings::set_int
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_int" g_settings_set_int ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Int32 ->                                -- value : TBasicType TInt
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for 32-bit integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a int32 type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsSetInt ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Int32
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetInt :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Int32 -> m Bool
    settingsSetInt a
    settings Text
    key Int32
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> Int32 -> IO CInt
    g_settings_set_int Ptr Settings
    settings' CString
    key' Int32
    value
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetIntMethodInfo
    instance (signature ~ (T.Text -> Int32 -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetIntMethodInfo a signature where
        overloadedMethod = settingsSetInt

    instance O.OverloadedMethodInfo SettingsSetIntMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetInt",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetInt"
            })

    #endif

    -- method Settings::set_int64
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TInt64
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_int64" g_settings_set_int64 ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Int64 ->                                -- value : TBasicType TInt64
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for 64-bit integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a int64 type in the schema for /@settings@/.
    --
    -- /Since: 2.50/
    settingsSetInt64 ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Int64
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetInt64 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Int64 -> m Bool
    settingsSetInt64 a
    settings Text
    key Int64
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> Int64 -> IO CInt
    g_settings_set_int64 Ptr Settings
    settings' CString
    key' Int64
    value
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetInt64MethodInfo
    instance (signature ~ (T.Text -> Int64 -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetInt64MethodInfo a signature where
        overloadedMethod = settingsSetInt64

    instance O.OverloadedMethodInfo SettingsSetInt64MethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetInt64",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetInt64"
            })

    #endif

    -- method Settings::set_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_string" g_settings_set_string ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        CString ->                              -- value : TBasicType TUTF8
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for strings.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a string type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsSetString ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> T.Text
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetString :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Text -> m Bool
    settingsSetString a
    settings Text
    key Text
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CString
    value' <- Text -> IO CString
    textToCString Text
    value
        CInt
    result <- Ptr Settings -> CString -> CString -> IO CInt
    g_settings_set_string Ptr Settings
    settings' CString
    key' CString
    value'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    value'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetStringMethodInfo
    instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetStringMethodInfo a signature where
        overloadedMethod = settingsSetString

    instance O.OverloadedMethodInfo SettingsSetStringMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetString",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetString"
            })

    #endif

    -- method Settings::set_strv
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to, or %NULL"
    --                 , 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 "g_settings_set_strv" g_settings_set_strv ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Ptr CString ->                          -- value : TCArray True (-1) (-1) (TBasicType TUTF8)
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for string arrays.  If
    -- /@value@/ is 'P.Nothing', then /@key@/ is set to be the empty array.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having an array of strings type in the schema for /@settings@/.
    --
    -- /Since: 2.26/
    settingsSetStrv ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Maybe ([T.Text])
        -- ^ /@value@/: the value to set it to, or 'P.Nothing'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetStrv :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Maybe [Text] -> m Bool
    settingsSetStrv a
    settings Text
    key Maybe [Text]
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr CString
    maybeValue <- case Maybe [Text]
    value of
            Maybe [Text]
    Nothing -> Ptr CString -> IO (Ptr CString)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CString
    forall a. Ptr a
    FP.nullPtr
            Just [Text]
    jValue -> do
                Ptr CString
    jValue' <- [Text] -> IO (Ptr CString)
    packZeroTerminatedUTF8CArray [Text]
    jValue
                Ptr CString -> IO (Ptr CString)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CString
    jValue'
        CInt
    result <- Ptr Settings -> CString -> Ptr CString -> IO CInt
    g_settings_set_strv Ptr Settings
    settings' CString
    key' Ptr CString
    maybeValue
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        (CString -> IO ()) -> Ptr CString -> IO ()
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
    mapZeroTerminatedCArray CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    maybeValue
        Ptr CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    maybeValue
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetStrvMethodInfo
    instance (signature ~ (T.Text -> Maybe ([T.Text]) -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetStrvMethodInfo a signature where
        overloadedMethod = settingsSetStrv

    instance O.OverloadedMethodInfo SettingsSetStrvMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetStrv",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetStrv"
            })

    #endif

    -- method Settings::set_uint
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TUInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_uint" g_settings_set_uint ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Word32 ->                               -- value : TBasicType TUInt
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for 32-bit unsigned
    -- integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a uint32 type in the schema for /@settings@/.
    --
    -- /Since: 2.30/
    settingsSetUint ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Word32
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetUint :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Word32 -> m Bool
    settingsSetUint a
    settings Text
    key Word32
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> Word32 -> IO CInt
    g_settings_set_uint Ptr Settings
    settings' CString
    key' Word32
    value
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetUintMethodInfo
    instance (signature ~ (T.Text -> Word32 -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetUintMethodInfo a signature where
        overloadedMethod = settingsSetUint

    instance O.OverloadedMethodInfo SettingsSetUintMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetUint",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetUint"
            })

    #endif

    -- method Settings::set_uint64
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TUInt64
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set it to"
    --                 , 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 "g_settings_set_uint64" g_settings_set_uint64 ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Word64 ->                               -- value : TBasicType TUInt64
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- A convenience variant of @/g_settings_set()/@ for 64-bit unsigned
    -- integers.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t specified as
    -- having a uint64 type in the schema for /@settings@/.
    --
    -- /Since: 2.50/
    settingsSetUint64 ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> Word64
        -- ^ /@value@/: the value to set it to
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetUint64 :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> Word64 -> m Bool
    settingsSetUint64 a
    settings Text
    key Word64
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        CInt
    result <- Ptr Settings -> CString -> Word64 -> IO CInt
    g_settings_set_uint64 Ptr Settings
    settings' CString
    key' Word64
    value
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetUint64MethodInfo
    instance (signature ~ (T.Text -> Word64 -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetUint64MethodInfo a signature where
        overloadedMethod = settingsSetUint64

    instance O.OverloadedMethodInfo SettingsSetUint64MethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetUint64",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetUint64"
            })

    #endif

    -- method Settings::set_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Settings" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSettings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "key"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the key to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TVariant
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GVariant of the correct type"
    --                 , 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 "g_settings_set_value" g_settings_set_value ::
        Ptr Settings ->                         -- settings : TInterface (Name {namespace = "Gio", name = "Settings"})
        CString ->                              -- key : TBasicType TUTF8
        Ptr GVariant ->                         -- value : TVariant
        IO CInt

    -- | Sets /@key@/ in /@settings@/ to /@value@/.
    --
    -- It is a programmer error to give a /@key@/ that isn\'t contained in the
    -- schema for /@settings@/ or for /@value@/ to have the incorrect type, per
    -- the schema.
    --
    -- If /@value@/ is floating then this function consumes the reference.
    --
    -- /Since: 2.26/
    settingsSetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsSettings a) =>
        a
        -- ^ /@settings@/: a t'GI.Gio.Objects.Settings.Settings' object
        -> T.Text
        -- ^ /@key@/: the name of the key to set
        -> GVariant
        -- ^ /@value@/: a t'GVariant' of the correct type
        -> m Bool
        -- ^ __Returns:__ 'P.True' if setting the key succeeded,
        --     'P.False' if the key was not writable
    settingsSetValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSettings a) =>
    a -> Text -> GVariant -> m Bool
    settingsSetValue a
    settings Text
    key GVariant
    value = 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 Settings
    settings' <- a -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    settings
        CString
    key' <- Text -> IO CString
    textToCString Text
    key
        Ptr GVariant
    value' <- GVariant -> IO (Ptr GVariant)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GVariant
    value
        CInt
    result <- Ptr Settings -> CString -> Ptr GVariant -> IO CInt
    g_settings_set_value Ptr Settings
    settings' CString
    key' Ptr GVariant
    value'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    settings
        GVariant -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr GVariant
    value
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    key'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SettingsSetValueMethodInfo
    instance (signature ~ (T.Text -> GVariant -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetValueMethodInfo a signature where
        overloadedMethod = settingsSetValue

    instance O.OverloadedMethodInfo SettingsSetValueMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.Settings.settingsSetValue",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-Settings.html#v:settingsSetValue"
            })

    #endif

    -- method Settings::list_relocatable_schemas
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_list_relocatable_schemas" g_settings_list_relocatable_schemas ::
        IO (Ptr CString)

    {-# DEPRECATED settingsListRelocatableSchemas ["(Since version 2.40)","Use 'GI.Gio.Structs.SettingsSchemaSource.settingsSchemaSourceListSchemas' instead"] #-}
    -- | Deprecated.
    --
    -- /Since: 2.28/
    settingsListRelocatableSchemas ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m [T.Text]
        -- ^ __Returns:__ a list of
        --   relocatable t'GI.Gio.Objects.Settings.Settings' schemas that are available, in no defined order.
        --   The list must not be modified or freed.
    settingsListRelocatableSchemas :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Text]
    settingsListRelocatableSchemas  = 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 CString
    result <- IO (Ptr CString)
    g_settings_list_relocatable_schemas
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsListRelocatableSchemas" Ptr CString
    result
        [Text]
    result' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result
        [Text] -> IO [Text]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::list_schemas
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_list_schemas" g_settings_list_schemas ::
        IO (Ptr CString)

    {-# DEPRECATED settingsListSchemas ["(Since version 2.40)","Use 'GI.Gio.Structs.SettingsSchemaSource.settingsSchemaSourceListSchemas' instead.","If you used 'GI.Gio.Objects.Settings.settingsListSchemas' to check for the presence of","a particular schema, use 'GI.Gio.Structs.SettingsSchemaSource.settingsSchemaSourceLookup' instead","of your whole loop."] #-}
    -- | Deprecated.
    --
    -- /Since: 2.26/
    settingsListSchemas ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m [T.Text]
        -- ^ __Returns:__ a list of
        --   t'GI.Gio.Objects.Settings.Settings' schemas that are available, in no defined order.  The list
        --   must not be modified or freed.
    settingsListSchemas :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Text]
    settingsListSchemas  = 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 CString
    result <- IO (Ptr CString)
    g_settings_list_schemas
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "settingsListSchemas" Ptr CString
    result
        [Text]
    result' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result
        [Text] -> IO [Text]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::sync
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_settings_sync" g_settings_sync ::
        IO ()

    -- | Ensures that all pending operations are complete for the default backend.
    --
    -- Writes made to a t'GI.Gio.Objects.Settings.Settings' are handled asynchronously.  For this
    -- reason, it is very unlikely that the changes have it to disk by the
    -- time @/g_settings_set()/@ returns.
    --
    -- This call will block until all of the writes have made it to the
    -- backend.  Since the mainloop is not running, no change notifications
    -- will be dispatched during this call (but some may be queued by the
    -- time the call is done).
    settingsSync ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m ()
    settingsSync :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ()
    settingsSync  = 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
        IO ()
    g_settings_sync
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Settings::unbind
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "object"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the object" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "property"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the property whose binding is removed"
    --                 , 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 "g_settings_unbind" g_settings_unbind ::
        Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
        CString ->                              -- property : TBasicType TUTF8
        IO ()

    -- | Removes an existing binding for /@property@/ on /@object@/.
    --
    -- Note that bindings are automatically removed when the
    -- object is finalized, so it is rarely necessary to call this
    -- function.
    --
    -- /Since: 2.26/
    settingsUnbind ::
        (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
        a
        -- ^ /@object@/: the object
        -> T.Text
        -- ^ /@property@/: the property whose binding is removed
        -> m ()
    settingsUnbind :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    a -> Text -> m ()
    settingsUnbind a
    object Text
    property = 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 Object
    object' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    object
        CString
    property' <- Text -> IO CString
    textToCString Text
    property
        Ptr Object -> CString -> IO ()
    g_settings_unbind Ptr Object
    object' CString
    property'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    object
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    property'
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    #endif