@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gio/settings.d.ts

@@ -4,6 +4,389 @@ import { Action } from "./action.js";
 import { SettingsBackend } from "./settings-backend.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * 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
+ * {@link 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 {@link Gio.Settings.bind}
+ * 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 ‘[relocatable](#relocatable-schemas)’, 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 {@link GLib.Variant}, and allows any {@link 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
+ * 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
+ *  <!-- 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
+ * {@link 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 `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:
+ * [gschema.dtd](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/gschema.dtd)
+ *
+ * The `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 {@link 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 {@link Gio.Settings.get_enum},
+ * {@link Gio.Settings.set_enum}, {@link Gio.Settings.get_flags},
+ * {@link Gio.Settings.set_flags} access the numeric values corresponding to
+ * the string value of enum and flags keys.
+ *
+ * An example for default value:
+ * ```xml
+ * <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
+ * <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,
+ * `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 {@link 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`.
+ *
+ * ## Delay-apply mode
+ *
+ * By default, values set on a {@link Gio.Settings} instance immediately start
+ * to be written to the backend (although these writes may not complete by the
+ * time that {@link Gio.Settings.set}) returns; see {@link Gio.Settings.sync}).
+ *
+ * In order to allow groups of settings to be changed simultaneously and
+ * atomically, GSettings also supports a ‘delay-apply’ mode. In this mode,
+ * updated values are kept locally in the {@link Gio.Settings} instance until
+ * they are explicitly applied by calling {@link Gio.Settings.apply}.
+ *
+ * For example, this could be useful for a preferences dialog where the
+ * preferences all need to be applied simultaneously when the user clicks ‘Save’.
+ *
+ * Switching a {@link Gio.Settings} instance to ‘delay-apply’ mode is a one-time
+ * irreversible operation: from that point onwards, *all* changes made to that
+ * {@link Gio.Settings} have to be explicitly applied by calling
+ * {@link Gio.Settings.apply}. The ‘delay-apply’ mode is also propagated to any
+ * child settings objects subsequently created using
+ * {@link Gio.Settings.get_child}.
+ *
+ * At any point, the set of unapplied changes can be queried using
+ * {@link Gio.Settings.has-unapplied}, and discarded by calling
+ * {@link Gio.Settings.revert}.
+ *
+ * ## Binding
+ *
+ * A very convenient feature of GSettings lets you bind {@link GObject.Object}
+ * properties directly to settings, using {@link Gio.Settings.bind}. Once a
+ * {@link GObject.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 {@link GObject.Object} and {@link 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 {@link Gio.Settings.new_with_path}, a `GSettings`
+ * object can be instantiated for a relocatable schema, assigning a path to the
+ * instance. Paths passed to {@link Gio.Settings.new_with_path} 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
+ * <schema id="org.foo.MyApp" path="/org/foo/MyApp/">
+ *   <child name="main" schema="org.foo.MyApp.Window"/>
+ * </schema>
+ * ```
+ *
+ * ## Build system integration
+ *
+ * ### Meson
+ *
+ * GSettings is natively supported by Meson’s GNOME module.
+ *
+ * You can install the schemas as any other data file:
+ *
+ * ```
+ * install_data(
+ *   'org.foo.MyApp.gschema.xml',
+ *   install_dir: get_option('datadir') / 'glib-2.0/schemas',
+ * )
+ * ```
+ *
+ * You can use `gnome.post_install()` function to compile the schemas on
+ * installation:
+ *
+ * ```
+ * gnome = import('gnome')
+ * gnome.post_install(
+ *   glib_compile_schemas: true,
+ * )
+ * ```
+ *
+ * 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, you will need to use the `gnome.mkenums()` function
+ * with the following templates:
+ *
+ * ```
+ * schemas_enums = gnome.mkenums('org.foo.MyApp.enums.xml',
+ *   comments: '<!-- `comment`@ -->',
+ *   fhead: '<schemalist>',
+ *   vhead: '  <`type`@ id="org.foo.MyApp.`EnumName`@">',
+ *   vprod: '    <value nick="`valuenick`@" value="`valuenum`@"/>',
+ *   vtail: '  </`type`@>',
+ *   ftail: '</schemalist>',
+ *   sources: enum_sources,
+ *   install_header: true,
+ *   install_dir: get_option('datadir') / 'glib-2.0/schemas',
+ * )
+ * ```
+ *
+ * It is recommended to validate your schemas as part of the test suite for
+ * your application:
+ *
+ * ```
+ * test('validate-schema',
+ *   find_program('glib-compile-schemas'),
+ *   args: ['--strict', '--dry-run', meson.current_source_dir()],
+ * )
+ * ```
+ *
+ * If your application allows running uninstalled, you should also use the
+ * `gnome.compile_schemas()` function to compile the schemas in the current
+ * build directory:
+ *
+ * ```
+ * gnome.compile_schemas()
+ * ```
+ *
+ * ### Autotools
+ *
+ * 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`@
+ * ```
+ *
+ * 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`.
+ *
+ * ## Localization
+ *
+ * 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 or newer 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 a rule to generate the XML file from a template.
+ */
 export declare class Settings extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -21,7 +404,6 @@ export declare class Settings extends GObject.GObject {
      * via the thread-default {@link GLib.MainContext} in effect at the time of the
      * call to {@link Gio.Settings.new}.  The new {@link Gio.Settings} will hold a reference
      * on the context.  See {@link GLib.MainContext.push_thread_default}.
-     * @param schemaId - the ID of the schema
      */
     constructor(schemaId: string);
     /**
@@ -48,11 +430,8 @@ export declare class Settings extends GObject.GObject {
      * error if `path` is `NULL` and the schema has no path of its own or if
      * `path` is non-`NULL` and not equal to the path that the schema does
      * have.
-     * @param schema - the schema describing the settings
-     * @param backend - the settings backend to use
-     * @param path - the path to use
      */
-    static newFull(schema: SettingsSchema, backend?: SettingsBackend, path?: string): Settings;
+    static newFull(schema: SettingsSchema, backend?: SettingsBackend | null, path?: string | null): Settings;
     /**
      * Creates a new {@link Gio.Settings} object with the schema specified by
      * `schema_id` and a given {@link Gio.SettingsBackend}.
@@ -62,8 +441,6 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param schemaId - the ID of the schema
-     * @param backend - the settings backend to use
      */
     static newWithBackend(schemaId: string, backend: SettingsBackend): Settings;
     /**
@@ -72,9 +449,6 @@ export declare class Settings extends GObject.GObject {
      *
      * This is a mix of {@link Gio.Settings.new_with_backend} and
      * {@link Gio.Settings.new_with_path}.
-     * @param schemaId - the ID of the schema
-     * @param backend - the settings backend to use
-     * @param path - the path to use
      */
     static newWithBackendAndPath(schemaId: string, backend: SettingsBackend, path: string): Settings;
     /**
@@ -91,17 +465,11 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param schemaId - the ID of the schema
-     * @param path - the path to use
      */
     static newWithPath(schemaId: string, path: string): Settings;
-    /**
-     * Deprecated.
-     */
+    /** Deprecated. */
     static listRelocatableSchemas(): string[];
-    /**
-     * Deprecated.
-     */
+    /** Deprecated. */
     static listSchemas(): string[];
     /**
      * Ensures that all pending operations are complete for the default backend.
@@ -122,8 +490,6 @@ export declare class Settings extends GObject.GObject {
      * Note that bindings are automatically removed when the
      * object is finalized, so it is rarely necessary to call this
      * function.
-     * @param object - the object with property to unbind
-     * @param property - the property whose binding is removed
      */
     static unbind(object: GObject.GObject, property: string): void;
     /**
@@ -155,23 +521,13 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param key - the key to bind
-     * @param object - the object with property to bind
-     * @param property - the name of the property to bind
-     * @param flags - flags for the binding
      */
     bind(key: string, object: GObject.GObject, property: string, flags: SettingsBindFlags): void;
     /**
      * Version of {@link Gio.Settings.bind_with_mapping} using closures instead of
      * callbacks for easier binding in other languages.
-     * @param key - the key to bind
-     * @param object - the object with property to bind
-     * @param property - the name of the property to bind
-     * @param flags - flags for the binding
-     * @param getMapping - a function that gets called to convert values
-     * @param setMapping - a function that gets called to convert values
      */
-    bindWithMappingClosures(key: string, object: GObject.GObject, property: string, flags: SettingsBindFlags, getMapping?: GObject.Closure, setMapping?: GObject.Closure): void;
+    bindWithMappingClosures(key: string, object: GObject.GObject, property: string, flags: SettingsBindFlags, getMapping?: GObject.Closure | null, setMapping?: GObject.Closure | null): void;
     /**
      * Create a binding between the writability of `key` in the
      * `settings` object and the property `property` of `object`.
@@ -191,10 +547,6 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param key - the key to bind
-     * @param object - the object with property to bind
-     * @param property - the name of a boolean property to bind
-     * @param inverted - whether to ‘invert’ the value
      */
     bindWritable(key: string, object: GObject.GObject, property: string, inverted: boolean): void;
     /**
@@ -212,7 +564,6 @@ export declare class Settings extends GObject.GObject {
      * 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).
-     * @param key - the name of a key in `settings`
      */
     createAction(key: string): Action;
     /**
@@ -231,7 +582,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `b` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getBoolean(key: string): boolean;
     /**
@@ -244,7 +594,6 @@ export declare class Settings extends GObject.GObject {
      *
      * The created child settings object will inherit the
      * {@link Gio.Settings.delay-apply} mode from `settings`.
-     * @param name - the name of the child schema
      */
     getChild(name: string): Settings;
     /**
@@ -269,7 +618,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t contained in the
      * schema for `settings`.
-     * @param key - the key to get the default value for
      */
     getDefaultValue(key: string): GLib.Variant | null;
     /**
@@ -279,7 +627,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `d` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getDouble(key: string): number;
     /**
@@ -295,7 +642,6 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param key - the key to get the value for
      */
     getEnum(key: string): number;
     /**
@@ -311,7 +657,6 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param key - the key to get the value for
      */
     getFlags(key: string): number;
     /**
@@ -329,7 +674,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `i` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getInt(key: string): number;
     /**
@@ -339,13 +683,9 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `x` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getInt64(key: string): number;
-    /**
-     * Queries the range of a key.
-     * @param key - the key to query the range of
-     */
+    /** Queries the range of a key. */
     getRange(key: string): GLib.Variant;
     /**
      * Gets the value that is stored at `key` in `settings`.
@@ -354,7 +694,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `s` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getString(key: string): string;
     /**
@@ -362,7 +701,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `as` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getStrv(key: string): string[];
     /**
@@ -373,7 +711,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `u` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getUint(key: string): number;
     /**
@@ -384,7 +721,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `t` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to get the value for
      */
     getUint64(key: string): number;
     /**
@@ -406,7 +742,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t contained in the
      * schema for `settings`.
-     * @param key - the key to get the user value for
      */
     getUserValue(key: string): GLib.Variant | null;
     /**
@@ -414,13 +749,9 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t contained in the
      * schema for `settings`.
-     * @param key - the key to get the value for
      */
     getValue(key: string): GLib.Variant;
-    /**
-     * Finds out if a key can be written.
-     * @param name - the name of a key
-     */
+    /** Finds out if a key can be written. */
     isWritable(name: string): boolean;
     /**
      * Gets the list of children on `settings`.
@@ -450,8 +781,6 @@ export declare class Settings extends GObject.GObject {
     /**
      * Checks if the given `value` is of the correct type and within the
      * permitted range for `key`.
-     * @param key - the key to check
-     * @param value - the value to check
      */
     rangeCheck(key: string, value: GLib.Variant): boolean;
     /**
@@ -460,7 +789,6 @@ export declare class Settings extends GObject.GObject {
      * 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.
-     * @param key - the name of a key
      */
     reset(key: string): void;
     /**
@@ -480,8 +808,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `b` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setBoolean(key: string, value: boolean): boolean;
     /**
@@ -491,8 +817,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `d` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setDouble(key: string, value: number): boolean;
     /**
@@ -506,8 +830,6 @@ export declare class Settings extends GObject.GObject {
      * After performing the write, accessing `key` directly with
      * {@link Gio.Settings.get_string} will return the ‘nick’ associated with
      * `value`.
-     * @param key - the key to set the value for
-     * @param value - an enumerated value
      */
     setEnum(key: string, value: number): boolean;
     /**
@@ -522,8 +844,6 @@ export declare class Settings extends GObject.GObject {
      * After performing the write, accessing `key` directly with
      * {@link Gio.Settings.get_strv} will return an array of ‘nicks’; one for each
      * bit in `value`.
-     * @param key - the key to set the value for
-     * @param value - a flags value
      */
     setFlags(key: string, value: number): boolean;
     /**
@@ -533,8 +853,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `i` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setInt(key: string, value: number): boolean;
     /**
@@ -544,8 +862,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `x` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setInt64(key: string, value: number): boolean;
     /**
@@ -555,8 +871,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `s` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setString(key: string, value: string): boolean;
     /**
@@ -567,10 +881,8 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having an `as` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
-    setStrv(key: string, value?: string[]): boolean;
+    setStrv(key: string, value?: string[] | null): boolean;
     /**
      * Sets `key` in `settings` to `value`.
      *
@@ -579,8 +891,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `u` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setUint(key: string, value: number): boolean;
     /**
@@ -591,8 +901,6 @@ export declare class Settings extends GObject.GObject {
      *
      * It is a programmer error to give a `key` that isn’t specified as
      * having a `t` type in the schema for `settings` (see {@link GLib.VariantType}).
-     * @param key - the key to set the value for
-     * @param value - the value to set it to
      */
     setUint64(key: string, value: number): boolean;
     /**
@@ -603,14 +911,11 @@ export declare class Settings extends GObject.GObject {
      * the schema.
      *
      * If `value` is floating then this function consumes the reference.
-     * @param key - the key to set the value for
-     * @param value - a {@link GLib.Variant} of the correct type
      */
     setValue(key: string, value: GLib.Variant): boolean;
     connect(signal: "change-event", handler: (self: Settings, keys: number[], nKeys: number) => boolean, after?: boolean): number;
     connect(signal: "changed", handler: (self: Settings, key: string) => void, after?: boolean): number;
     connect(signal: "writable-change-event", handler: (self: Settings, key: number) => boolean, after?: boolean): number;
     connect(signal: "writable-changed", handler: (self: Settings, key: string) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: Settings, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }