@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,12 +1,70 @@
 import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/index.js";
+/**
+ * `GSeekable` is implemented by streams (implementations of
+ * [class@Gio.InputStream] or [class@Gio.OutputStream]) that support seeking.
+ *
+ * Seekable streams largely fall into two categories: resizable and
+ * fixed-size.
+ *
+ * `GSeekable` on fixed-sized streams is approximately the same as POSIX
+ * [`lseek()`](man:lseek(2)) on a block device (for example: attempting to seek
+ * past the end of the device is an error).  Fixed streams typically cannot be
+ * truncated.
+ *
+ * `GSeekable` on resizable streams is approximately the same as POSIX
+ * [`lseek()`](man:lseek(2)) on a normal file.  Seeking past the end and writing
+ * data will usually cause the stream to resize by introducing zero bytes.
+ */
 export declare class Seekable {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Seekable;
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek(): boolean;
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate(): boolean;
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+    /**
+     * Tells the current position within the stream.
+     */
     tell(): number;
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
 }

package/dist/generated/gio/seekable.js

@@ -1,5 +1,21 @@
 import { call } from "@gtkx/native";
 import { NativeError } from "@gtkx/ffi";
+/**
+ * `GSeekable` is implemented by streams (implementations of
+ * [class@Gio.InputStream] or [class@Gio.OutputStream]) that support seeking.
+ *
+ * Seekable streams largely fall into two categories: resizable and
+ * fixed-size.
+ *
+ * `GSeekable` on fixed-sized streams is approximately the same as POSIX
+ * [`lseek()`](man:lseek(2)) on a block device (for example: attempting to seek
+ * past the end of the device is an error).  Fixed streams typically cannot be
+ * truncated.
+ *
+ * `GSeekable` on resizable streams is approximately the same as POSIX
+ * [`lseek()`](man:lseek(2)) on a normal file.  Seeking past the end and writing
+ * data will usually cause the stream to resize by introducing zero bytes.
+ */
 export class Seekable {
     ptr;
     constructor(ptr) {
@@ -8,6 +24,9 @@ export class Seekable {
     static fromPtr(ptr) {
         return new Seekable(ptr);
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -16,6 +35,10 @@ export class Seekable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate() {
         return call("libgio-2.0.so.0", "g_seekable_can_truncate", [
             {
@@ -24,6 +47,25 @@ export class Seekable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset, type, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_seek", [
@@ -61,6 +103,9 @@ export class Seekable {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -69,6 +114,19 @@ export class Seekable {
             },
         ], { type: "int", size: 64, unsigned: false });
     }
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_truncate", [

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

@@ -1,16 +1,160 @@
 import { Ref } from "@gtkx/native";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * The `GSettingsBackend` interface defines a generic interface for
+ * non-strictly-typed data that is stored in a hierarchy. To implement
+ * an alternative storage backend for [class@Gio.Settings], you need to
+ * implement the `GSettingsBackend` interface and then make it implement the
+ * extension point `G_SETTINGS_BACKEND_EXTENSION_POINT_NAME`.
+ *
+ * The interface defines methods for reading and writing values, a
+ * method for determining if writing of certain values will fail
+ * (lockdown) and a change notification mechanism.
+ *
+ * The semantics of the interface are very precisely defined and
+ * implementations must carefully adhere to the expectations of
+ * callers that are documented on each of the interface methods.
+ *
+ * Some of the `GSettingsBackend` functions accept or return a
+ * [struct@GLib.Tree]. These trees always have strings as keys and
+ * [struct@GLib.Variant] as values.
+ *
+ * The `GSettingsBackend` API is exported to allow third-party
+ * implementations, but does not carry the same stability guarantees
+ * as the public GIO API. For this reason, you have to define the
+ * C preprocessor symbol `G_SETTINGS_ENABLE_BACKEND` before including
+ * `gio/gsettingsbackend.h`.
+ */
 export declare class SettingsBackend extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Calculate the longest common prefix of all keys in a tree and write
+     * out an array of the key names relative to that prefix and,
+     * optionally, the value to store at each of those keys.
+     *
+     * You must free the value returned in @path, `keys` and `values` using
+     * g_free().  You should not attempt to free or unref the contents of
+     * `keys` or @values.
+     * @param tree - a #GTree containing the changes
+     * @param path - the location to save the path
+     * @param keys - the
+     * @param values - the location to save the values, or %NULL
+     */
     static flattenTree(tree: GLib.Tree, path: Ref<string>, keys: Ref<string[]>, values?: Ref<GLib.Variant[]> | null): void;
+    /**
+     * Returns the default #GSettingsBackend. It is possible to override
+     * the default by setting the `GSETTINGS_BACKEND` environment variable
+     * to the name of a settings backend.
+     *
+     * The user gets a reference to the backend.
+     */
     static getDefault(): SettingsBackend;
+    /**
+     * Signals that a single key has possibly changed.  Backend
+     * implementations should call this if a key has possibly changed its
+     * value.
+     *
+     * `key` must be a valid key (ie starting with a slash, not containing
+     * '//', and not ending with a slash).
+     *
+     * The implementation must call this function during any call to
+     * g_settings_backend_write(), before the call returns (except in the
+     * case that no keys are actually changed and it cares to detect this
+     * fact).  It may not rely on the existence of a mainloop for
+     * dispatching the signal later.
+     *
+     * The implementation may call this function at any other time it likes
+     * in response to other events (such as changes occurring outside of the
+     * program).  These calls may originate from a mainloop or may originate
+     * in response to any other action (including from calls to
+     * g_settings_backend_write()).
+     *
+     * In the case that this call is in response to a call to
+     * g_settings_backend_write() then `origin_tag` must be set to the same
+     * value that was passed to that call.
+     * @param key - the name of the key
+     * @param originTag - the origin tag
+     */
     changed(key: string, originTag?: number | null): void;
+    /**
+     * This call is a convenience wrapper.  It gets the list of changes from
+     * @tree, computes the longest common prefix and calls
+     * g_settings_backend_changed().
+     * @param tree - a #GTree containing the changes
+     * @param originTag - the origin tag
+     */
     changedTree(tree: GLib.Tree, originTag?: number | null): void;
+    /**
+     * Signals that a list of keys have possibly changed.  Backend
+     * implementations should call this if keys have possibly changed their
+     * values.
+     *
+     * `path` must be a valid path (ie starting and ending with a slash and
+     * not containing '//').  Each string in `items` must form a valid key
+     * name when `path` is prefixed to it (ie: each item must not start or
+     * end with '/' and must not contain '//').
+     *
+     * The meaning of this signal is that any of the key names resulting
+     * from the concatenation of `path` with each item in `items` may have
+     * changed.
+     *
+     * The same rules for when notifications must occur apply as per
+     * g_settings_backend_changed().  These two calls can be used
+     * interchangeably if exactly one item has changed (although in that
+     * case g_settings_backend_changed() is definitely preferred).
+     *
+     * For efficiency reasons, the implementation should strive for `path` to
+     * be as long as possible (ie: the longest common prefix of all of the
+     * keys that were changed) but this is not strictly required.
+     * @param path - the path containing the changes
+     * @param items - the %NULL-terminated list of changed keys
+     * @param originTag - the origin tag
+     */
     keysChanged(path: string, items: string[], originTag?: number | null): void;
+    /**
+     * Signals that all keys below a given path may have possibly changed.
+     * Backend implementations should call this if an entire path of keys
+     * have possibly changed their values.
+     *
+     * `path` must be a valid path (ie starting and ending with a slash and
+     * not containing '//').
+     *
+     * The meaning of this signal is that any of the key which has a name
+     * starting with `path` may have changed.
+     *
+     * The same rules for when notifications must occur apply as per
+     * g_settings_backend_changed().  This call might be an appropriate
+     * reasponse to a 'reset' call but implementations are also free to
+     * explicitly list the keys that were affected by that call if they can
+     * easily do so.
+     *
+     * For efficiency reasons, the implementation should strive for `path` to
+     * be as long as possible (ie: the longest common prefix of all of the
+     * keys that were changed) but this is not strictly required.  As an
+     * example, if this function is called with the path of "/" then every
+     * single key in the application will be notified of a possible change.
+     * @param path - the path containing the changes
+     * @param originTag - the origin tag
+     */
     pathChanged(path: string, originTag?: number | null): void;
+    /**
+     * Signals that the writability of all keys below a given path may have
+     * changed.
+     *
+     * Since GSettings performs no locking operations for itself, this call
+     * will always be made in response to external events.
+     * @param path - the name of the path
+     */
     pathWritableChanged(path: string): void;
+    /**
+     * Signals that the writability of a single key has possibly changed.
+     *
+     * Since GSettings performs no locking operations for itself, this call
+     * will always be made in response to external events.
+     * @param key - the name of the key
+     */
     writableChanged(key: string): void;
     connect(signal: "notify", handler: (self: SettingsBackend, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/settings-backend.js

@@ -1,6 +1,31 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * The `GSettingsBackend` interface defines a generic interface for
+ * non-strictly-typed data that is stored in a hierarchy. To implement
+ * an alternative storage backend for [class@Gio.Settings], you need to
+ * implement the `GSettingsBackend` interface and then make it implement the
+ * extension point `G_SETTINGS_BACKEND_EXTENSION_POINT_NAME`.
+ *
+ * The interface defines methods for reading and writing values, a
+ * method for determining if writing of certain values will fail
+ * (lockdown) and a change notification mechanism.
+ *
+ * The semantics of the interface are very precisely defined and
+ * implementations must carefully adhere to the expectations of
+ * callers that are documented on each of the interface methods.
+ *
+ * Some of the `GSettingsBackend` functions accept or return a
+ * [struct@GLib.Tree]. These trees always have strings as keys and
+ * [struct@GLib.Variant] as values.
+ *
+ * The `GSettingsBackend` API is exported to allow third-party
+ * implementations, but does not carry the same stability guarantees
+ * as the public GIO API. For this reason, you have to define the
+ * C preprocessor symbol `G_SETTINGS_ENABLE_BACKEND` before including
+ * `gio/gsettingsbackend.h`.
+ */
 export class SettingsBackend extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -16,6 +41,19 @@ export class SettingsBackend extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Calculate the longest common prefix of all keys in a tree and write
+     * out an array of the key names relative to that prefix and,
+     * optionally, the value to store at each of those keys.
+     *
+     * You must free the value returned in @path, `keys` and `values` using
+     * g_free().  You should not attempt to free or unref the contents of
+     * `keys` or @values.
+     * @param tree - a #GTree containing the changes
+     * @param path - the location to save the path
+     * @param keys - the
+     * @param values - the location to save the values, or %NULL
+     */
     static flattenTree(tree, path, keys, values) {
         call("libgio-2.0.so.0", "g_settings_backend_flatten_tree", [
             {
@@ -55,6 +93,13 @@ export class SettingsBackend extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the default #GSettingsBackend. It is possible to override
+     * the default by setting the `GSETTINGS_BACKEND` environment variable
+     * to the name of a settings backend.
+     *
+     * The user gets a reference to the backend.
+     */
     static getDefault() {
         const ptr = call("libgio-2.0.so.0", "g_settings_backend_get_default", [], {
             type: "gobject",
@@ -62,6 +107,32 @@ export class SettingsBackend extends GObject.GObject {
         });
         return getObject(ptr, SettingsBackend);
     }
+    /**
+     * Signals that a single key has possibly changed.  Backend
+     * implementations should call this if a key has possibly changed its
+     * value.
+     *
+     * `key` must be a valid key (ie starting with a slash, not containing
+     * '//', and not ending with a slash).
+     *
+     * The implementation must call this function during any call to
+     * g_settings_backend_write(), before the call returns (except in the
+     * case that no keys are actually changed and it cares to detect this
+     * fact).  It may not rely on the existence of a mainloop for
+     * dispatching the signal later.
+     *
+     * The implementation may call this function at any other time it likes
+     * in response to other events (such as changes occurring outside of the
+     * program).  These calls may originate from a mainloop or may originate
+     * in response to any other action (including from calls to
+     * g_settings_backend_write()).
+     *
+     * In the case that this call is in response to a call to
+     * g_settings_backend_write() then `origin_tag` must be set to the same
+     * value that was passed to that call.
+     * @param key - the name of the key
+     * @param originTag - the origin tag
+     */
     changed(key, originTag) {
         call("libgio-2.0.so.0", "g_settings_backend_changed", [
             {
@@ -79,6 +150,13 @@ export class SettingsBackend extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This call is a convenience wrapper.  It gets the list of changes from
+     * @tree, computes the longest common prefix and calls
+     * g_settings_backend_changed().
+     * @param tree - a #GTree containing the changes
+     * @param originTag - the origin tag
+     */
     changedTree(tree, originTag) {
         call("libgio-2.0.so.0", "g_settings_backend_changed_tree", [
             {
@@ -101,6 +179,32 @@ export class SettingsBackend extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Signals that a list of keys have possibly changed.  Backend
+     * implementations should call this if keys have possibly changed their
+     * values.
+     *
+     * `path` must be a valid path (ie starting and ending with a slash and
+     * not containing '//').  Each string in `items` must form a valid key
+     * name when `path` is prefixed to it (ie: each item must not start or
+     * end with '/' and must not contain '//').
+     *
+     * The meaning of this signal is that any of the key names resulting
+     * from the concatenation of `path` with each item in `items` may have
+     * changed.
+     *
+     * The same rules for when notifications must occur apply as per
+     * g_settings_backend_changed().  These two calls can be used
+     * interchangeably if exactly one item has changed (although in that
+     * case g_settings_backend_changed() is definitely preferred).
+     *
+     * For efficiency reasons, the implementation should strive for `path` to
+     * be as long as possible (ie: the longest common prefix of all of the
+     * keys that were changed) but this is not strictly required.
+     * @param path - the path containing the changes
+     * @param items - the %NULL-terminated list of changed keys
+     * @param originTag - the origin tag
+     */
     keysChanged(path, items, originTag) {
         call("libgio-2.0.so.0", "g_settings_backend_keys_changed", [
             {
@@ -122,6 +226,31 @@ export class SettingsBackend extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Signals that all keys below a given path may have possibly changed.
+     * Backend implementations should call this if an entire path of keys
+     * have possibly changed their values.
+     *
+     * `path` must be a valid path (ie starting and ending with a slash and
+     * not containing '//').
+     *
+     * The meaning of this signal is that any of the key which has a name
+     * starting with `path` may have changed.
+     *
+     * The same rules for when notifications must occur apply as per
+     * g_settings_backend_changed().  This call might be an appropriate
+     * reasponse to a 'reset' call but implementations are also free to
+     * explicitly list the keys that were affected by that call if they can
+     * easily do so.
+     *
+     * For efficiency reasons, the implementation should strive for `path` to
+     * be as long as possible (ie: the longest common prefix of all of the
+     * keys that were changed) but this is not strictly required.  As an
+     * example, if this function is called with the path of "/" then every
+     * single key in the application will be notified of a possible change.
+     * @param path - the path containing the changes
+     * @param originTag - the origin tag
+     */
     pathChanged(path, originTag) {
         call("libgio-2.0.so.0", "g_settings_backend_path_changed", [
             {
@@ -139,6 +268,14 @@ export class SettingsBackend extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Signals that the writability of all keys below a given path may have
+     * changed.
+     *
+     * Since GSettings performs no locking operations for itself, this call
+     * will always be made in response to external events.
+     * @param path - the name of the path
+     */
     pathWritableChanged(path) {
         call("libgio-2.0.so.0", "g_settings_backend_path_writable_changed", [
             {
@@ -151,6 +288,13 @@ export class SettingsBackend extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Signals that the writability of a single key has possibly changed.
+     *
+     * Since GSettings performs no locking operations for itself, this call
+     * will always be made in response to external events.
+     * @param key - the name of the key
+     */
     writableChanged(key) {
         call("libgio-2.0.so.0", "g_settings_backend_writable_changed", [
             {

package/dist/generated/gio/settings-schema-key.d.ts

@@ -1,15 +1,114 @@
 import * as GLib from "../glib/index.js";
+/**
+ * #GSettingsSchemaKey is an opaque data structure and can only be accessed
+ * using the following functions.
+ */
 export declare class SettingsSchemaKey {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /**
+     * Gets the default value for @key.
+     *
+     * Note that this is the default value according to the schema.  System
+     * administrator defaults and lockdown are not visible via this API.
+     */
     getDefaultValue(): GLib.Variant;
+    /**
+     * Gets the description for @key.
+     *
+     * If no description has been provided in the schema for @key, returns
+     * %NULL.
+     *
+     * The description can be one sentence to several paragraphs in length.
+     * Paragraphs are delimited with a double newline.  Descriptions can be
+     * translated and the value returned from this function is is the
+     * current locale.
+     *
+     * This function is slow.  The summary and description information for
+     * the schemas is not stored in the compiled schema database so this
+     * function has to parse all of the source XML files in the schema
+     * directory.
+     */
     getDescription(): string | null;
+    /**
+     * Gets the name of @key.
+     */
     getName(): string;
+    /**
+     * Queries the range of a key.
+     *
+     * This function will return a #GVariant that fully describes the range
+     * of values that are valid for @key.
+     *
+     * The type of #GVariant returned is `(sv)`. The string describes
+     * the type of range restriction in effect. The type and meaning of
+     * the value contained in the variant depends on the string.
+     *
+     * If the string is `'type'` then the variant contains an empty array.
+     * The element type of that empty array is the expected type of value
+     * and all values of that type are valid.
+     *
+     * If the string is `'enum'` then the variant contains an array
+     * enumerating the possible values. Each item in the array is
+     * a possible valid value and no other values are valid.
+     *
+     * If the string is `'flags'` then the variant contains an array. Each
+     * item in the array is a value that may appear zero or one times in an
+     * array to be used as the value for this key. For example, if the
+     * variant contained the array `['x', 'y']` then the valid values for
+     * the key would be `[]`, `['x']`, `['y']`, `['x', 'y']` and
+     * `['y', 'x']`.
+     *
+     * Finally, if the string is `'range'` then the variant contains a pair
+     * of like-typed values -- the minimum and maximum permissible values
+     * for this key.
+     *
+     * This information should not be used by normal programs.  It is
+     * considered to be a hint for introspection purposes.  Normal programs
+     * should already know what is permitted by their own schema.  The
+     * format may change in any way in the future -- but particularly, new
+     * forms may be added to the possibilities described above.
+     *
+     * You should free the returned value with g_variant_unref() when it is
+     * no longer needed.
+     */
     getRange(): GLib.Variant;
+    /**
+     * Gets the summary for @key.
+     *
+     * If no summary has been provided in the schema for @key, returns
+     * %NULL.
+     *
+     * The summary is a short description of the purpose of the key; usually
+     * one short sentence.  Summaries can be translated and the value
+     * returned from this function is is the current locale.
+     *
+     * This function is slow.  The summary and description information for
+     * the schemas is not stored in the compiled schema database so this
+     * function has to parse all of the source XML files in the schema
+     * directory.
+     */
     getSummary(): string | null;
+    /**
+     * Gets the #GVariantType of @key.
+     */
     getValueType(): GLib.VariantType;
+    /**
+     * Checks if the given `value` is within the
+     * permitted range for @key.
+     *
+     * It is a programmer error if `value` is not of the correct type — you
+     * must check for this first.
+     * @param value - the value to check
+     */
     rangeCheck(value: GLib.Variant): boolean;
+    /**
+     * Increase the reference count of @key, returning a new reference.
+     */
     ref(): SettingsSchemaKey;
+    /**
+     * Decrease the reference count of @key, possibly freeing it.
+     */
     unref(): void;
 }