@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -32,140 +32,1572 @@ import { TlsFileDatabase } from "./tls-file-database.js";
 import { TlsServerConnection } from "./tls-server-connection.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Checks if `action_name` is valid.
+ *
+ * `action_name` is valid if it consists only of alphanumeric characters,
+ * plus `-` and `.`.  The empty string is not a valid action name.
+ *
+ * It is an error to call this function with a non-UTF-8 @action_name.
+ * `action_name` must not be `NULL`.
+ * @param actionName - a potential action name
+ */
 export declare const actionNameIsValid: (actionName: string) => boolean;
+/**
+ * Parses a detailed action name into its separate name and target
+ * components.
+ *
+ * Detailed action names can have three formats.
+ *
+ * The first format is used to represent an action name with no target
+ * value and consists of just an action name containing no whitespace
+ * nor the characters `:`, `(` or `)`.  For example: `app.action`.
+ *
+ * The second format is used to represent an action with a target value
+ * that is a non-empty string consisting only of alphanumerics, plus `-`
+ * and `.`.  In that case, the action name and target value are
+ * separated by a double colon (`::`).  For example:
+ * `app.action::target`.
+ *
+ * The third format is used to represent an action with any type of
+ * target value, including strings.  The target value follows the action
+ * name, surrounded in parens.  For example: `app.action(42)`.  The
+ * target value is parsed using [func@GLib.Variant.parse].  If a tuple-typed
+ * value is desired, it must be specified in the same way, resulting in
+ * two sets of parens, for example: `app.action((1,2,3))`.  A string
+ * target can be specified this way as well: `app.action('target')`.
+ * For strings, this third format must be used if target value is
+ * empty or contains characters other than alphanumerics, `-` and `.`.
+ *
+ * If this function returns `TRUE`, a non-`NULL` value is guaranteed to be returned
+ * in `action_name` (if a pointer is passed in). A `NULL` value may still be
+ * returned in @target_value, as the `detailed_name` may not contain a target.
+ *
+ * If returned, the [type@GLib.Variant] in `target_value` is guaranteed to not be floating.
+ * @param detailedName - a detailed action name
+ * @param actionName - the action name
+ * @param targetValue - the target value,
+ */
 export declare const actionParseDetailedName: (detailedName: string, actionName?: Ref<string> | null, targetValue?: Ref<GLib.Variant> | null) => boolean;
+/**
+ * Formats a detailed action name from `action_name` and @target_value.
+ *
+ * It is an error to call this function with an invalid action name.
+ *
+ * This function is the opposite of [func@Gio.Action.parse_detailed_name].
+ * It will produce a string that can be parsed back to the `action_name` and `target_value` by that function.
+ *
+ * See that function for the types of strings that will be printed by
+ * this function.
+ * @param actionName - a valid action name
+ * @param targetValue - a [type@GLib.Variant] target value, or `NULL`
+ */
 export declare const actionPrintDetailedName: (actionName: string, targetValue?: GLib.Variant | null) => string;
+/**
+ * Creates a new [iface@Gio.AppInfo] from the given information.
+ *
+ * Note that for @commandline, the quoting rules of the `Exec` key of the
+ * [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
+ * are applied. For example, if the `commandline` contains
+ * percent-encoded URIs, the percent-character must be doubled in order to prevent it from
+ * being swallowed by `Exec` key unquoting. See
+ * the specification
+ * for exact quoting rules.
+ * @param commandline - the command line to use
+ * @param applicationName - the application name, or `NULL` to use @commandline
+ * @param flags - flags that can specify details of the created [iface@Gio.AppInfo]
+ */
 export declare const appInfoCreateFromCommandline: (commandline: string, flags: AppInfoCreateFlags, applicationName?: string | null) => AppInfo;
+/**
+ * Gets a list of all of the applications currently registered
+ * on this system.
+ *
+ * For desktop files, this includes applications that have
+ * `NoDisplay=true`
+ * set or are excluded from display by means of
+ * `OnlyShowIn`
+ * or `NotShowIn`.
+ * See [method@Gio.AppInfo.should_show].
+ *
+ * The returned list does not include applications which have the
+ * `Hidden` key
+ * set.
+ */
 export declare const appInfoGetAll: () => AppInfo[];
+/**
+ * Gets a list of all [iface@Gio.AppInfo]s for a given content type,
+ * including the recommended and fallback [iface@Gio.AppInfo]s. See
+ * [func@Gio.AppInfo.get_recommended_for_type] and
+ * [func@Gio.AppInfo.get_fallback_for_type].
+ * @param contentType - the content type to find a [iface@Gio.AppInfo] for
+ */
 export declare const appInfoGetAllForType: (contentType: string) => AppInfo[];
+/**
+ * Gets the default [iface@Gio.AppInfo] for a given content type.
+ * @param contentType - the content type to find a [iface@Gio.AppInfo] for
+ * @param mustSupportUris - if `TRUE`, the [iface@Gio.AppInfo] is expected to
+ */
 export declare const appInfoGetDefaultForType: (contentType: string, mustSupportUris: boolean) => AppInfo | null;
+/**
+ * Asynchronously gets the default [iface@Gio.AppInfo] for a given content
+ * type.
+ * @param contentType - the content type to find a [iface@Gio.AppInfo] for
+ * @param mustSupportUris - if `TRUE`, the [iface@Gio.AppInfo] is expected to
+ * @param cancellable - a [class@Gio.Cancellable]
+ * @param callback - a [type@Gio.AsyncReadyCallback] to call
+ * @param userData - data to pass to @callback
+ */
 export declare const appInfoGetDefaultForTypeAsync: (contentType: string, mustSupportUris: boolean, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Finishes a default [iface@Gio.AppInfo] lookup started by
+ * [func@Gio.AppInfo.get_default_for_type_async].
+ *
+ * If no #[iface@Gio.AppInfo] is found, then `error` will be set to
+ * [error@Gio.IOErrorEnum.NOT_FOUND].
+ * @param result - the async result
+ */
 export declare const appInfoGetDefaultForTypeFinish: (result: AsyncResult) => AppInfo;
+/**
+ * Gets the default application for handling URIs with the given URI scheme.
+ *
+ * A URI scheme is the initial part of the URI, up to but not including the `:`.
+ * For example, `http`, `ftp` or `sip`.
+ * @param uriScheme - a string containing a URI scheme.
+ */
 export declare const appInfoGetDefaultForUriScheme: (uriScheme: string) => AppInfo | null;
+/**
+ * Asynchronously gets the default application for handling URIs with
+ * the given URI scheme. A URI scheme is the initial part
+ * of the URI, up to but not including the `:`, e.g. `http`,
+ * `ftp` or `sip`.
+ * @param uriScheme - a string containing a URI scheme.
+ * @param cancellable - a [class@Gio.Cancellable]
+ * @param callback - a [type@Gio.AsyncReadyCallback] to call
+ * @param userData - data to pass to @callback
+ */
 export declare const appInfoGetDefaultForUriSchemeAsync: (uriScheme: string, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Finishes a default [iface@Gio.AppInfo] lookup started by
+ * [func@Gio.AppInfo.get_default_for_uri_scheme_async].
+ *
+ * If no [iface@Gio.AppInfo] is found, then `error` will be set to
+ * [error@Gio.IOErrorEnum.NOT_FOUND].
+ * @param result - the async result
+ */
 export declare const appInfoGetDefaultForUriSchemeFinish: (result: AsyncResult) => AppInfo;
+/**
+ * Gets a list of fallback [iface@Gio.AppInfo]s for a given content type, i.e.
+ * those applications which claim to support the given content type by MIME
+ * type subclassing and not directly.
+ * @param contentType - the content type to find a [iface@Gio.AppInfo] for
+ */
 export declare const appInfoGetFallbackForType: (contentType: string) => AppInfo[];
+/**
+ * Gets a list of recommended [iface@Gio.AppInfo]s for a given content type,
+ * i.e. those applications which claim to support the given content type
+ * exactly, and not by MIME type subclassing.
+ *
+ * Note that the first application of the list is the last used one, i.e.
+ * the last one for which [method@Gio.AppInfo.set_as_last_used_for_type] has
+ * been called.
+ * @param contentType - the content type to find a [iface@Gio.AppInfo] for
+ */
 export declare const appInfoGetRecommendedForType: (contentType: string) => AppInfo[];
+/**
+ * Utility function that launches the default application registered to handle
+ * the specified uri. Synchronous I/O is done on the uri to detect the type of
+ * the file if required.
+ *
+ * The D-Bus–activated applications don’t have to be started if your application
+ * terminates too soon after this function. To prevent this, use
+ * [func@Gio.AppInfo.launch_default_for_uri_async] instead.
+ * @param uri - the uri to show
+ * @param context - optional launch context
+ */
 export declare const appInfoLaunchDefaultForUri: (uri: string, context?: AppLaunchContext | null) => boolean;
+/**
+ * Async version of [func@Gio.AppInfo.launch_default_for_uri].
+ *
+ * This version is useful if you are interested in receiving error information
+ * in the case where the application is sandboxed and the portal may present an
+ * application chooser dialog to the user.
+ *
+ * This is also useful if you want to be sure that the D-Bus–activated
+ * applications are really started before termination and if you are interested
+ * in receiving error information from their activation.
+ * @param uri - the uri to show
+ * @param context - optional launch context
+ * @param cancellable - a [class@Gio.Cancellable]
+ * @param callback - a [type@Gio.AsyncReadyCallback] to call
+ * @param userData - data to pass to @callback
+ */
 export declare const appInfoLaunchDefaultForUriAsync: (uri: string, context?: AppLaunchContext | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Finishes an asynchronous launch-default-for-uri operation.
+ * @param result - the async result
+ */
 export declare const appInfoLaunchDefaultForUriFinish: (result: AsyncResult) => boolean;
+/**
+ * Removes all changes to the type associations done by
+ * [method@Gio.AppInfo.set_as_default_for_type],
+ * [method@Gio.AppInfo.set_as_default_for_extension],
+ * [method@Gio.AppInfo.add_supports_type] or
+ * [method@Gio.AppInfo.remove_supports_type].
+ * @param contentType - a content type
+ */
 export declare const appInfoResetTypeAssociations: (contentType: string) => void;
+/**
+ * Helper function for constructing #GAsyncInitable object. This is
+ * similar to g_object_newv() but also initializes the object asynchronously.
+ *
+ * When the initialization is finished, `callback` will be called. You can
+ * then call g_async_initable_new_finish() to get the new object and check
+ * for any errors.
+ * @param objectType - a #GType supporting #GAsyncInitable.
+ * @param nParameters - the number of parameters in @parameters
+ * @param parameters - the parameters to use to construct the object
+ * @param ioPriority - the I/O priority of the operation
+ * @param cancellable - optional #GCancellable object, %NULL to ignore.
+ * @param callback - a #GAsyncReadyCallback to call when the initialization is
+ * @param userData - the data to pass to callback function
+ */
 export declare const asyncInitableNewvAsync: (objectType: number, nParameters: number, parameters: number, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Asynchronously connects to the message bus specified by @bus_type.
+ *
+ * When the operation is finished, `callback` will be invoked. You can
+ * then call g_bus_get_finish() to get the result of the operation.
+ *
+ * This is an asynchronous failable function. See g_bus_get_sync() for
+ * the synchronous version.
+ * @param busType - a #GBusType
+ * @param cancellable - a #GCancellable or %NULL
+ * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
+ * @param userData - the data to pass to @callback
+ */
 export declare const busGet: (busType: BusType, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Finishes an operation started with g_bus_get().
+ *
+ * The returned object is a singleton, that is, shared with other
+ * callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the
+ * event that you need a private message bus connection, use
+ * g_dbus_address_get_for_bus_sync() and
+ * g_dbus_connection_new_for_address() with
+ * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
+ * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
+ *
+ * Note that the returned #GDBusConnection object will (usually) have
+ * the #GDBusConnection:exit-on-close property set to %TRUE.
+ * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
+ */
 export declare const busGetFinish: (res: AsyncResult) => DBusConnection;
+/**
+ * Synchronously connects to the message bus specified by @bus_type.
+ * Note that the returned object may shared with other callers,
+ * e.g. if two separate parts of a process calls this function with
+ * the same @bus_type, they will share the same object.
+ *
+ * This is a synchronous failable function. See g_bus_get() and
+ * g_bus_get_finish() for the asynchronous version.
+ *
+ * The returned object is a singleton, that is, shared with other
+ * callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the
+ * event that you need a private message bus connection, use
+ * g_dbus_address_get_for_bus_sync() and
+ * g_dbus_connection_new_for_address() with
+ * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
+ * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
+ *
+ * Note that the returned #GDBusConnection object will (usually) have
+ * the #GDBusConnection:exit-on-close property set to %TRUE.
+ * @param busType - a #GBusType
+ * @param cancellable - a #GCancellable or %NULL
+ */
 export declare const busGetSync: (busType: BusType, cancellable?: Cancellable | null) => DBusConnection;
+/**
+ * Requests ownership of `name` on the bus specified by @bus_type.
+ *
+ * It asynchronously calls `name_acquired_handler` and `name_lost_handler` when
+ * the name is acquired and lost, respectively.
+ *
+ * Callbacks will be invoked in the thread-default
+ * main context (see [method@GLib.MainContext.push_thread_default])
+ * of the thread you are calling this function from.
+ *
+ * You are guaranteed that one of the `name_acquired_handler` and `name_lost_handler` callbacks will be invoked after calling this function — there are three
+ * possible cases:
+ *
+ * - `name_lost_handler` with a `NULL` connection (if a connection to the bus
+ * can’t be made).
+ * - `bus_acquired_handler` then `name_lost_handler` (if the name can’t be
+ * obtained).
+ * - `bus_acquired_handler` then `name_acquired_handler` (if the name was
+ * obtained).
+ *
+ * When you are done owning the name, call [func@Gio.bus_unown_name] with the
+ * owner ID this function returns.
+ *
+ * If the name is acquired or lost (for example another application
+ * could acquire the name if you allow replacement or the application
+ * currently owning the name exits), the handlers are also invoked.
+ * If the [class@Gio.DBusConnection] that is used for attempting to own the name
+ * closes, then `name_lost_handler` is invoked since it is no longer
+ * possible for other processes to access the process.
+ *
+ * You cannot use [func@Gio.bus_own_name] several times for the same name (unless
+ * interleaved with calls to [func@Gio.bus_unown_name]) — only the first call
+ * will work.
+ *
+ * Another guarantee is that invocations of `name_acquired_handler` and `name_lost_handler` are guaranteed to alternate; that
+ * is, if `name_acquired_handler` is invoked then you are
+ * guaranteed that the next time one of the handlers is invoked, it
+ * will be @name_lost_handler. The reverse is also true.
+ *
+ * If you plan on exporting objects (using, for example,
+ * [method@Gio.DBusConnection.register_object]), note that it is generally too late
+ * to export the objects in @name_acquired_handler. Instead, you can do this
+ * in `bus_acquired_handler` since you are guaranteed that this will run
+ * before `name` is requested from the bus.
+ *
+ * This behavior makes it very simple to write applications that want
+ * to own names and export objects.
+ * Simply register objects to be exported in `bus_acquired_handler` and
+ * unregister the objects (if any) in @name_lost_handler.
+ * @param busType - the type of bus to own a name on
+ * @param name - the well-known name to own
+ * @param flags - a set of flags with ownership options
+ * @param busAcquiredHandler - handler to invoke when
+ * @param nameAcquiredHandler - handler to invoke when
+ * @param nameLostHandler - handler to invoke when `name`   is lost, or `NULL` to ignore
+ * @param userData - user data to pass to handlers
+ * @param userDataFreeFunc - function for freeing @user_data
+ */
 export declare const busOwnName: (busType: BusType, name: string, flags: BusNameOwnerFlags, busAcquiredHandler?: (...args: unknown[]) => unknown | null, nameAcquiredHandler?: (...args: unknown[]) => unknown | null, nameLostHandler?: (...args: unknown[]) => unknown | null, userData?: number | null, userDataFreeFunc?: () => void | null) => number;
+/**
+ * Like [func@Gio.bus_own_name] but takes a [class@Gio.DBusConnection] instead
+ * of a [enum@Gio.BusType].
+ * @param connection - a bus connection
+ * @param name - the well-known name to own
+ * @param flags - a set of flags with ownership options
+ * @param nameAcquiredHandler - handler to invoke when
+ * @param nameLostHandler - handler to invoke when `name`   is lost, or `NULL` to ignore
+ * @param userData - user data to pass to handlers
+ * @param userDataFreeFunc - function for freeing @user_data
+ */
 export declare const busOwnNameOnConnection: (connection: DBusConnection, name: string, flags: BusNameOwnerFlags, nameAcquiredHandler?: (...args: unknown[]) => unknown | null, nameLostHandler?: (...args: unknown[]) => unknown | null, userData?: number | null, userDataFreeFunc?: () => void | null) => number;
+/**
+ * Version of [func@Gio.bus_own_name_on_connection] using closures instead of
+ * callbacks for easier binding in other languages.
+ * @param connection - a bus connection
+ * @param name - the well-known name to own
+ * @param flags - a set of flags with ownership options
+ * @param nameAcquiredClosure - closure to invoke when `name` is
+ * @param nameLostClosure - closure to invoke when `name` is lost,
+ */
 export declare const busOwnNameOnConnectionWithClosures: (connection: DBusConnection, name: string, flags: BusNameOwnerFlags, nameAcquiredClosure?: GObject.Closure | null, nameLostClosure?: GObject.Closure | null) => number;
+/**
+ * Version of [func@Gio.bus_own_name using closures instead of callbacks for
+ * easier binding in other languages.
+ * @param busType - the type of bus to own a name on
+ * @param name - the well-known name to own
+ * @param flags - a set of flags with ownership options
+ * @param busAcquiredClosure - closure to invoke when connected to
+ * @param nameAcquiredClosure - closure to invoke when `name` is
+ * @param nameLostClosure - closure to invoke when `name` is lost, or
+ */
 export declare const busOwnNameWithClosures: (busType: BusType, name: string, flags: BusNameOwnerFlags, busAcquiredClosure?: GObject.Closure | null, nameAcquiredClosure?: GObject.Closure | null, nameLostClosure?: GObject.Closure | null) => number;
+/**
+ * Stops owning a name.
+ *
+ * Note that there may still be D-Bus traffic to process (relating to owning
+ * and unowning the name) in the current thread-default
+ * [struct@GLib.MainContext] after this function has returned. You should
+ * continue to iterate the [struct@GLib.MainContext] until the
+ * [callback@GLib.DestroyNotify] function passed to [func@Gio.bus_own_name] is
+ * called, in order to avoid memory leaks through callbacks queued on the
+ * [struct@GLib.MainContext] after it’s stopped being iterated.
+ * @param ownerId - an identifier obtained from [func@Gio.bus_own_name]
+ */
 export declare const busUnownName: (ownerId: number) => void;
+/**
+ * Stops watching a name.
+ *
+ * Note that there may still be D-Bus traffic to process (relating to watching
+ * and unwatching the name) in the current thread-default #GMainContext after
+ * this function has returned. You should continue to iterate the #GMainContext
+ * until the #GDestroyNotify function passed to g_bus_watch_name() is called, in
+ * order to avoid memory leaks through callbacks queued on the #GMainContext
+ * after it’s stopped being iterated.
+ * @param watcherId - An identifier obtained from g_bus_watch_name()
+ */
 export declare const busUnwatchName: (watcherId: number) => void;
+/**
+ * Starts watching `name` on the bus specified by `bus_type` and calls
+ * `name_appeared_handler` and `name_vanished_handler` when the name is
+ * known to have an owner respectively known to lose its
+ * owner. Callbacks will be invoked in the thread-default main context
+ * (see [method@GLib.MainContext.push_thread_default])
+ * of the thread you are calling this function from.
+ *
+ * You are guaranteed that one of the handlers will be invoked after
+ * calling this function. When you are done watching the name, just
+ * call g_bus_unwatch_name() with the watcher id this function
+ * returns.
+ *
+ * If the name vanishes or appears (for example the application owning
+ * the name could restart), the handlers are also invoked. If the
+ * #GDBusConnection that is used for watching the name disconnects, then
+ * `name_vanished_handler` is invoked since it is no longer
+ * possible to access the name.
+ *
+ * Another guarantee is that invocations of `name_appeared_handler` and `name_vanished_handler` are guaranteed to alternate; that
+ * is, if `name_appeared_handler` is invoked then you are
+ * guaranteed that the next time one of the handlers is invoked, it
+ * will be @name_vanished_handler. The reverse is also true.
+ *
+ * This behavior makes it very simple to write applications that want
+ * to take action when a certain name exists.
+ * Basically, the application should create object proxies in
+ * `name_appeared_handler` and destroy them again (if any) in
+ * @name_vanished_handler.
+ * @param busType - The type of bus to watch a name on.
+ * @param name - The name (well-known or unique) to watch.
+ * @param flags - Flags from the #GBusNameWatcherFlags enumeration.
+ * @param nameAppearedHandler - Handler to invoke when
+ * @param nameVanishedHandler - Handler to invoke when
+ * @param userData - User data to pass to handlers.
+ * @param userDataFreeFunc - Function for freeing `user_data` or %NULL.
+ */
 export declare const busWatchName: (busType: BusType, name: string, flags: BusNameWatcherFlags, nameAppearedHandler?: (...args: unknown[]) => unknown | null, nameVanishedHandler?: (...args: unknown[]) => unknown | null, userData?: number | null, userDataFreeFunc?: () => void | null) => number;
+/**
+ * Like g_bus_watch_name() but takes a #GDBusConnection instead of a
+ * #GBusType.
+ * @param connection - A #GDBusConnection.
+ * @param name - The name (well-known or unique) to watch.
+ * @param flags - Flags from the #GBusNameWatcherFlags enumeration.
+ * @param nameAppearedHandler - Handler to invoke when
+ * @param nameVanishedHandler - Handler to invoke when
+ * @param userData - User data to pass to handlers.
+ * @param userDataFreeFunc - Function for freeing `user_data` or %NULL.
+ */
 export declare const busWatchNameOnConnection: (connection: DBusConnection, name: string, flags: BusNameWatcherFlags, nameAppearedHandler?: (...args: unknown[]) => unknown | null, nameVanishedHandler?: (...args: unknown[]) => unknown | null, userData?: number | null, userDataFreeFunc?: () => void | null) => number;
+/**
+ * Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
+ * easier binding in other languages.
+ * @param connection - A #GDBusConnection.
+ * @param name - The name (well-known or unique) to watch.
+ * @param flags - Flags from the #GBusNameWatcherFlags enumeration.
+ * @param nameAppearedClosure - #GClosure to invoke when `name` is known
+ * @param nameVanishedClosure - #GClosure to invoke when `name` is known
+ */
 export declare const busWatchNameOnConnectionWithClosures: (connection: DBusConnection, name: string, flags: BusNameWatcherFlags, nameAppearedClosure?: GObject.Closure | null, nameVanishedClosure?: GObject.Closure | null) => number;
+/**
+ * Version of g_bus_watch_name() using closures instead of callbacks for
+ * easier binding in other languages.
+ * @param busType - The type of bus to watch a name on.
+ * @param name - The name (well-known or unique) to watch.
+ * @param flags - Flags from the #GBusNameWatcherFlags enumeration.
+ * @param nameAppearedClosure - #GClosure to invoke when `name` is known
+ * @param nameVanishedClosure - #GClosure to invoke when `name` is known
+ */
 export declare const busWatchNameWithClosures: (busType: BusType, name: string, flags: BusNameWatcherFlags, nameAppearedClosure?: GObject.Closure | null, nameVanishedClosure?: GObject.Closure | null) => number;
+/**
+ * Checks if a content type can be executable. Note that for instance
+ * things like text files can be executables (i.e. scripts and batch files).
+ * @param type - a content type string
+ */
 export declare const contentTypeCanBeExecutable: (type: string) => boolean;
+/**
+ * Compares two content types for equality.
+ * @param type1 - a content type string
+ * @param type2 - a content type string
+ */
 export declare const contentTypeEquals: (type1: string, type2: string) => boolean;
+/**
+ * Tries to find a content type based on the mime type name.
+ * @param mimeType - a mime type string
+ */
 export declare const contentTypeFromMimeType: (mimeType: string) => string | null;
+/**
+ * Gets the human readable description of the content type.
+ * @param type - a content type string
+ */
 export declare const contentTypeGetDescription: (type: string) => string;
+/**
+ * Gets the generic icon name for a content type.
+ *
+ * See the
+ * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+ * specification for more on the generic icon name.
+ * @param type - a content type string
+ */
 export declare const contentTypeGetGenericIconName: (type: string) => string | null;
+/**
+ * Gets the icon for a content type.
+ * @param type - a content type string
+ */
 export declare const contentTypeGetIcon: (type: string) => Icon;
+/**
+ * Get the list of directories which MIME data is loaded from. See
+ * g_content_type_set_mime_dirs() for details.
+ */
 export declare const contentTypeGetMimeDirs: () => string[];
+/**
+ * Gets the mime type for the content type, if one is registered.
+ * @param type - a content type string
+ */
 export declare const contentTypeGetMimeType: (type: string) => string | null;
+/**
+ * Gets the symbolic icon for a content type.
+ * @param type - a content type string
+ */
 export declare const contentTypeGetSymbolicIcon: (type: string) => Icon;
+/**
+ * Guesses the content type based on example data. If the function is
+ * uncertain, `result_uncertain` will be set to %TRUE. Either `filename` or `data` may be %NULL, in which case the guess will be based solely
+ * on the other argument.
+ * @param filename - a path, or %NULL
+ * @param data - a stream of data, or %NULL
+ * @param dataSize - the size of @data
+ * @param resultUncertain - return location for the certainty
+ */
 export declare const contentTypeGuess: (dataSize: number, filename?: string | null, data?: number[] | null, resultUncertain?: Ref<boolean> | null) => string;
+/**
+ * Tries to guess the type of the tree with root @root, by
+ * looking at the files it contains. The result is an array
+ * of content types, with the best guess coming first.
+ *
+ * The types returned all have the form x-content/foo, e.g.
+ * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
+ * (for a camera memory card). See the
+ * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+ * specification for more on x-content types.
+ *
+ * This function is useful in the implementation of
+ * g_mount_guess_content_type().
+ * @param root - the root of the tree to guess a type for
+ */
 export declare const contentTypeGuessForTree: (root: File) => string[];
+/**
+ * Determines if `type` is a subset of @supertype.
+ * @param type - a content type string
+ * @param supertype - a content type string
+ */
 export declare const contentTypeIsA: (type: string, supertype: string) => boolean;
+/**
+ * Determines if `type` is a subset of @mime_type.
+ * Convenience wrapper around g_content_type_is_a().
+ * @param type - a content type string
+ * @param mimeType - a mime type string
+ */
 export declare const contentTypeIsMimeType: (type: string, mimeType: string) => boolean;
+/**
+ * Checks if the content type is the generic "unknown" type.
+ * On UNIX this is the "application/octet-stream" mimetype,
+ * while on win32 it is "*" and on OSX it is a dynamic type
+ * or octet-stream.
+ * @param type - a content type string
+ */
 export declare const contentTypeIsUnknown: (type: string) => boolean;
+/**
+ * Set the list of directories used by GIO to load the MIME database.
+ * If `dirs` is %NULL, the directories used are the default:
+ *
+ * - the `mime` subdirectory of the directory in `$XDG_DATA_HOME`
+ * - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS`
+ *
+ * This function is intended to be used when writing tests that depend on
+ * information stored in the MIME database, in order to control the data.
+ *
+ * Typically, in case your tests use %G_TEST_OPTION_ISOLATE_DIRS, but they
+ * depend on the system’s MIME database, you should call this function
+ * with `dirs` set to %NULL before calling g_test_init(), for instance:
+ *
+ * |[<!-- language="C" -->
+ * // Load MIME data from the system
+ * g_content_type_set_mime_dirs (NULL);
+ * // Isolate the environment
+ * g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
+ *
+ * …
+ *
+ * return g_test_run ();
+ * ]|
+ * @param dirs - %NULL-terminated list of
+ */
 export declare const contentTypeSetMimeDirs: (dirs?: string[] | null) => void;
+/**
+ * Gets a list of strings containing all the registered content types
+ * known to the system. The list and its data should be freed using
+ * `g_list_free_full (list, g_free)`.
+ */
 export declare const contentTypesGetRegistered: () => string[];
+/**
+ * Escape `string` so it can appear in a D-Bus address as the value
+ * part of a key-value pair.
+ *
+ * For instance, if `string` is `/run/bus-for-:0`,
+ * this function would return `/run/bus-for-%3A0`,
+ * which could be used in a D-Bus address like
+ * `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0`.
+ * @param string - an unescaped string to be included in a D-Bus address
+ */
 export declare const dbusAddressEscapeValue: (string: string) => string;
+/**
+ * Synchronously looks up the D-Bus address for the well-known message
+ * bus instance specified by @bus_type. This may involve using various
+ * platform specific mechanisms.
+ *
+ * The returned address will be in the
+ * D-Bus address format.
+ * @param busType - a #GBusType
+ * @param cancellable - a #GCancellable or %NULL
+ */
 export declare const dbusAddressGetForBusSync: (busType: BusType, cancellable?: Cancellable | null) => string;
+/**
+ * Asynchronously connects to an endpoint specified by `address` and
+ * sets up the connection so it is in a state to run the client-side
+ * of the D-Bus authentication conversation. `address` must be in the
+ * D-Bus address format.
+ *
+ * When the operation is finished, `callback` will be invoked. You can
+ * then call g_dbus_address_get_stream_finish() to get the result of
+ * the operation.
+ *
+ * This is an asynchronous failable function. See
+ * g_dbus_address_get_stream_sync() for the synchronous version.
+ * @param address - A valid D-Bus address.
+ * @param cancellable - A #GCancellable or %NULL.
+ * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
+ * @param userData - Data to pass to @callback.
+ */
 export declare const dbusAddressGetStream: (address: string, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Finishes an operation started with g_dbus_address_get_stream().
+ *
+ * A server is not required to set a GUID, so `out_guid` may be set to %NULL
+ * even on success.
+ * @param res - A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
+ * @param outGuid - %NULL or return location to store the GUID extracted from @address, if any.
+ */
 export declare const dbusAddressGetStreamFinish: (res: AsyncResult, outGuid?: Ref<string> | null) => IOStream;
+/**
+ * Synchronously connects to an endpoint specified by `address` and
+ * sets up the connection so it is in a state to run the client-side
+ * of the D-Bus authentication conversation. `address` must be in the
+ * D-Bus address format.
+ *
+ * A server is not required to set a GUID, so `out_guid` may be set to %NULL
+ * even on success.
+ *
+ * This is a synchronous failable function. See
+ * g_dbus_address_get_stream() for the asynchronous version.
+ * @param address - A valid D-Bus address.
+ * @param outGuid - %NULL or return location to store the GUID extracted from @address, if any.
+ * @param cancellable - A #GCancellable or %NULL.
+ */
 export declare const dbusAddressGetStreamSync: (address: string, outGuid?: Ref<string> | null, cancellable?: Cancellable | null) => IOStream;
+/**
+ * Looks up the value of an annotation.
+ *
+ * The cost of this function is O(n) in number of annotations.
+ * @param annotations - A %NULL-terminated array of annotations or %NULL.
+ * @param name - The name of the annotation to look up.
+ */
 export declare const dbusAnnotationInfoLookup: (name: string, annotations?: DBusAnnotationInfo[] | null) => string | null;
+/**
+ * Creates a D-Bus error name to use for @error.
+ *
+ * If `error` matches a registered error (see
+ * [func@Gio.DBusError.register_error]), the corresponding D-Bus error name
+ * will be returned.
+ *
+ * Otherwise the a name of the form
+ * `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE`
+ * will be used. This allows other GDBus applications to map the error
+ * on the wire back to a [type@GLib.Error] using
+ * [func@Gio.DBusError.new_for_dbus_error].
+ *
+ * This function is typically only used in object mappings to put a
+ * [type@GLib.Error] on the wire. Regular applications should not use it.
+ * @param error - an error
+ */
 export declare const dbusErrorEncodeGerror: (error: GLib.GError) => string;
+/**
+ * Gets the D-Bus error name used for @error, if any.
+ *
+ * This function is guaranteed to return a D-Bus error name for all
+ * [type@GLib.Error]s returned from functions handling remote method calls
+ * (for example, [method@Gio.DBusConnection.call_finish]) unless
+ * [func@Gio.DBusError.strip_remote_error] has already been used on @error.
+ * @param error - an error
+ */
 export declare const dbusErrorGetRemoteError: (error: GLib.GError) => string | null;
+/**
+ * Checks if `error` represents an error received via D-Bus from a remote peer.
+ *
+ * If so, use [func@Gio.DBusError.get_remote_error] to get the name of the error.
+ * @param error - an error
+ */
 export declare const dbusErrorIsRemoteError: (error: GLib.GError) => boolean;
+/**
+ * Creates a [type@GLib.Error] based on the contents of `dbus_error_name` and
+ * @dbus_error_message.
+ *
+ * Errors registered with [func@Gio.DBusError.register_error] will be looked
+ * up using `dbus_error_name` and if a match is found, the error domain
+ * and code is used. Applications can use [func@Gio.DBusError.get_remote_error]
+ * to recover @dbus_error_name.
+ *
+ * If a match against a registered error is not found and the D-Bus
+ * error name is in a form as returned by [func@Gio.DBusError.encode_gerror]
+ * the error domain and code encoded in the name is used to
+ * create the [type@GLib.Error]. Also, `dbus_error_name` is added to the error
+ * message such that it can be recovered with
+ * [func@Gio.DBusError.get_remote_error].
+ *
+ * Otherwise, a [type@GLib.Error] with the error code
+ * [error@Gio.IOErrorEnum.DBUS_ERROR]
+ * in the [error@Gio.IOErrorEnum] error domain is returned. Also, `dbus_error_name` is
+ * added to the error message such that it can be recovered with
+ * [func@Gio.DBusError.get_remote_error].
+ *
+ * In all three cases, `dbus_error_name` can always be recovered from the
+ * returned [type@GLib.Error] using the [func@Gio.DBusError.get_remote_error]
+ * function (unless [func@Gio.DBusError.strip_remote_error] hasn’t been used on
+ * the returned error).
+ *
+ * This function is typically only used in object mappings to prepare
+ * [type@GLib.Error] instances for applications. Regular applications should not
+ * use it.
+ * @param dbusErrorName - D-Bus error name
+ * @param dbusErrorMessage - D-Bus error message
+ */
 export declare const dbusErrorNewForDbusError: (dbusErrorName: string, dbusErrorMessage: string) => GLib.GError;
 export declare const dbusErrorQuark: () => number;
+/**
+ * Creates an association mapping between `dbus_error_name` and
+ * [type@GLib.Error]s specified by `error_domain` and @error_code.
+ *
+ * This is typically done in the function that returns the [type@GLib.Quark] for
+ * an error domain.
+ * @param errorDomain - a [type@GLib.Quark] for an error domain
+ * @param errorCode - an error code
+ * @param dbusErrorName - a D-Bus error name
+ */
 export declare const dbusErrorRegisterError: (errorDomain: number, errorCode: number, dbusErrorName: string) => boolean;
+/**
+ * Helper function for associating a [type@GLib.Error] error domain with D-Bus
+ * error names.
+ *
+ * While `quark_volatile` has a `volatile` qualifier, this is a historical
+ * artifact and the argument passed to it should not be `volatile`.
+ * @param errorDomainQuarkName - the error domain name
+ * @param quarkVolatile - return location for the [type@GLib.Quark] representing the
+ * @param entries - items to register
+ * @param numEntries - number of items to register
+ */
 export declare const dbusErrorRegisterErrorDomain: (errorDomainQuarkName: string, quarkVolatile: number, entries: number[], numEntries: number) => void;
+/**
+ * Looks for extra information in the error message used to recover
+ * the D-Bus error name and strips it if found.
+ *
+ * If stripped, the
+ * message field in `error` will correspond exactly to what was
+ * received on the wire.
+ *
+ * This is typically used when presenting errors to the end user.
+ * @param error - an error
+ */
 export declare const dbusErrorStripRemoteError: (error: GLib.GError) => boolean;
+/**
+ * Destroys an association previously set up with
+ * [func@Gio.DBusError.register_error].
+ * @param errorDomain - a [type@GLib.Quark] for an error domain
+ * @param errorCode - an error code
+ * @param dbusErrorName - a D-Bus error name
+ */
 export declare const dbusErrorUnregisterError: (errorDomain: number, errorCode: number, dbusErrorName: string) => boolean;
+/**
+ * This is a language binding friendly version of g_dbus_escape_object_path_bytestring().
+ * @param s - the string to escape
+ */
 export declare const dbusEscapeObjectPath: (s: string) => string;
+/**
+ * Escapes `bytes` for use in a D-Bus object path component.
+ * `bytes` is an array of zero or more nonzero bytes in an
+ * unspecified encoding, followed by a single zero byte.
+ *
+ * The escaping method consists of replacing all non-alphanumeric
+ * characters (see g_ascii_isalnum()) with their hexadecimal value
+ * preceded by an underscore (`_`). For example:
+ * `foo.bar.baz` will become `foo_2ebar_2ebaz`.
+ *
+ * This method is appropriate to use when the input is nearly
+ * a valid object path component but is not when your input
+ * is far from being a valid object path component.
+ * Other escaping algorithms are also valid to use with
+ * D-Bus object paths.
+ *
+ * This can be reversed with g_dbus_unescape_object_path().
+ * @param bytes - the string of bytes to escape
+ */
 export declare const dbusEscapeObjectPathBytestring: (bytes: number[]) => string;
+/**
+ * Generate a D-Bus GUID that can be used with
+ * e.g. g_dbus_connection_new().
+ *
+ * See the
+ * D-Bus specification
+ * regarding what strings are valid D-Bus GUIDs. The specification refers to
+ * these as ‘UUIDs’ whereas GLib (for historical reasons) refers to them as
+ * ‘GUIDs’. The terms are interchangeable.
+ *
+ * Note that D-Bus GUIDs do not follow
+ * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122).
+ */
 export declare const dbusGenerateGuid: () => string;
+/**
+ * Converts a #GValue to a #GVariant of the type indicated by the `type` parameter.
+ *
+ * The conversion is using the following rules:
+ *
+ * - `G_TYPE_STRING`: 's', 'o', 'g' or 'ay'
+ * - `G_TYPE_STRV`: 'as', 'ao' or 'aay'
+ * - `G_TYPE_BOOLEAN`: 'b'
+ * - `G_TYPE_UCHAR`: 'y'
+ * - `G_TYPE_INT`: 'i', 'n'
+ * - `G_TYPE_UINT`: 'u', 'q'
+ * - `G_TYPE_INT64`: 'x'
+ * - `G_TYPE_UINT64`: 't'
+ * - `G_TYPE_DOUBLE`: 'd'
+ * - `G_TYPE_VARIANT`: Any #GVariantType
+ *
+ * This can fail if e.g. `gvalue` is of type %G_TYPE_STRING and `type` is 'i', i.e. %G_VARIANT_TYPE_INT32. It will also fail for any #GType
+ * (including e.g. %G_TYPE_OBJECT and %G_TYPE_BOXED derived-types) not
+ * in the table above.
+ *
+ * Note that if `gvalue` is of type %G_TYPE_VARIANT and its value is
+ * %NULL, the empty #GVariant instance (never %NULL) for `type` is
+ * returned (e.g. 0 for scalar types, the empty string for string types,
+ * '/' for object path types, the empty array for any array type and so on).
+ *
+ * See the g_dbus_gvariant_to_gvalue() function for how to convert a
+ * #GVariant to a #GValue.
+ * @param gvalue - A #GValue to convert to a #GVariant
+ * @param type - A #GVariantType
+ */
 export declare const dbusGvalueToGvariant: (gvalue: GObject.Value, type: GLib.VariantType) => GLib.Variant;
+/**
+ * Converts a #GVariant to a #GValue. If `value` is floating, it is consumed.
+ *
+ * The rules specified in the g_dbus_gvalue_to_gvariant() function are
+ * used - this function is essentially its reverse form. So, a #GVariant
+ * containing any basic or string array type will be converted to a #GValue
+ * containing a basic value or string array. Any other #GVariant (handle,
+ * variant, tuple, dict entry) will be converted to a #GValue containing that
+ * #GVariant.
+ *
+ * The conversion never fails - a valid #GValue is always returned in
+ * @out_gvalue.
+ * @param value - A #GVariant.
+ * @param outGvalue - Return location pointing to a zero-filled (uninitialized) #GValue.
+ */
 export declare const dbusGvariantToGvalue: (value: GLib.Variant, outGvalue: Ref<GObject.Value>) => void;
+/**
+ * Checks if `string` is a
+ * D-Bus address.
+ *
+ * This doesn't check if `string` is actually supported by #GDBusServer
+ * or #GDBusConnection - use g_dbus_is_supported_address() to do more
+ * checks.
+ * @param string - A string.
+ */
 export declare const dbusIsAddress: (string: string) => boolean;
+/**
+ * Check whether `string` is a valid D-Bus error name.
+ *
+ * This function returns the same result as g_dbus_is_interface_name(),
+ * because D-Bus error names are defined to have exactly the
+ * same syntax as interface names.
+ * @param string - The string to check.
+ */
 export declare const dbusIsErrorName: (string: string) => boolean;
+/**
+ * Checks if `string` is a D-Bus GUID.
+ *
+ * See the documentation for g_dbus_generate_guid() for more information about
+ * the format of a GUID.
+ * @param string - The string to check.
+ */
 export declare const dbusIsGuid: (string: string) => boolean;
+/**
+ * Checks if `string` is a valid D-Bus interface name.
+ * @param string - The string to check.
+ */
 export declare const dbusIsInterfaceName: (string: string) => boolean;
+/**
+ * Checks if `string` is a valid D-Bus member (e.g. signal or method) name.
+ * @param string - The string to check.
+ */
 export declare const dbusIsMemberName: (string: string) => boolean;
+/**
+ * Checks if `string` is a valid D-Bus bus name (either unique or well-known).
+ * @param string - The string to check.
+ */
 export declare const dbusIsName: (string: string) => boolean;
+/**
+ * Like g_dbus_is_address() but also checks if the library supports the
+ * transports in `string` and that key/value pairs for each transport
+ * are valid. See the specification of the
+ * D-Bus address format.
+ * @param string - A string.
+ */
 export declare const dbusIsSupportedAddress: (string: string) => boolean;
+/**
+ * Checks if `string` is a valid D-Bus unique bus name.
+ * @param string - The string to check.
+ */
 export declare const dbusIsUniqueName: (string: string) => boolean;
+/**
+ * Unescapes an string that was previously escaped with
+ * g_dbus_escape_object_path(). If the string is in a format that could
+ * not have been returned by g_dbus_escape_object_path(), this function
+ * returns %NULL.
+ *
+ * Encoding alphanumeric characters which do not need to be
+ * encoded is not allowed (e.g `_63` is not valid, the string
+ * should contain `c` instead).
+ * @param s - the string to unescape
+ */
 export declare const dbusUnescapeObjectPath: (s: string) => number[] | null;
+/**
+ * Creates a new #GDtlsClientConnection wrapping `base_socket` which is
+ * assumed to communicate with the server identified by @server_identity.
+ * @param baseSocket - the #GDatagramBased to wrap
+ * @param serverIdentity - the expected identity of the server
+ */
 export declare const dtlsClientConnectionNew: (baseSocket: DatagramBased, serverIdentity?: SocketConnectable | null) => DtlsClientConnection;
+/**
+ * Creates a new #GDtlsServerConnection wrapping @base_socket.
+ * @param baseSocket - the #GDatagramBased to wrap
+ * @param certificate - the default server certificate, or %NULL
+ */
 export declare const dtlsServerConnectionNew: (baseSocket: DatagramBased, certificate?: TlsCertificate | null) => DtlsServerConnection;
+/**
+ * Constructs a #GFile from a vector of elements using the correct
+ * separator for filenames.
+ *
+ * Using this function is equivalent to calling g_build_filenamev(),
+ * followed by g_file_new_for_path() on the result.
+ * @param args - %NULL-terminated
+ */
 export declare const fileNewBuildFilenamev: (args: string[]) => File;
+/**
+ * Creates a #GFile with the given argument from the command line.
+ * The value of `arg` can be either a URI, an absolute path or a
+ * relative path resolved relative to the current working directory.
+ * This operation never fails, but the returned object might not
+ * support any I/O operation if `arg` points to a malformed path.
+ *
+ * Note that on Windows, this function expects its argument to be in
+ * UTF-8 -- not the system code page.  This means that you
+ * should not use this function with string from argv as it is passed
+ * to main().  g_win32_get_command_line() will return a UTF-8 version of
+ * the commandline.  #GApplication also uses UTF-8 but
+ * g_application_command_line_create_file_for_arg() may be more useful
+ * for you there.  It is also always possible to use this function with
+ * #GOptionContext arguments of type %G_OPTION_ARG_FILENAME.
+ * @param arg - a command line string
+ */
 export declare const fileNewForCommandlineArg: (arg: string) => File;
+/**
+ * Creates a #GFile with the given argument from the command line.
+ *
+ * This function is similar to g_file_new_for_commandline_arg() except
+ * that it allows for passing the current working directory as an
+ * argument instead of using the current working directory of the
+ * process.
+ *
+ * This is useful if the commandline argument was given in a context
+ * other than the invocation of the current process.
+ *
+ * See also g_application_command_line_create_file_for_arg().
+ * @param arg - a command line string
+ * @param cwd - the current working directory of the commandline
+ */
 export declare const fileNewForCommandlineArgAndCwd: (arg: string, cwd: string) => File;
+/**
+ * Constructs a #GFile for a given path. This operation never
+ * fails, but the returned object might not support any I/O
+ * operation if `path` is malformed.
+ * @param path - a string containing a relative or absolute path.
+ */
 export declare const fileNewForPath: (path: string) => File;
+/**
+ * Constructs a #GFile for a given URI. This operation never
+ * fails, but the returned object might not support any I/O
+ * operation if `uri` is malformed or if the uri type is
+ * not supported.
+ * @param uri - a UTF-8 string containing a URI
+ */
 export declare const fileNewForUri: (uri: string) => File;
+/**
+ * Opens a file in the preferred directory for temporary files (as
+ * returned by g_get_tmp_dir()) and returns a #GFile and
+ * #GFileIOStream pointing to it.
+ *
+ * `tmpl` should be a string in the GLib file name encoding
+ * containing a sequence of six 'X' characters, and containing no
+ * directory components. If it is %NULL, a default template is used.
+ *
+ * Unlike the other #GFile constructors, this will return %NULL if
+ * a temporary file could not be created.
+ * @param tmpl - Template for the file
+ * @param iostream - on return, a #GFileIOStream for the created file
+ */
 export declare const fileNewTmp: (iostream: Ref<FileIOStream>, tmpl?: string | null) => File;
+/**
+ * Asynchronously opens a file in the preferred directory for temporary files
+ * (as returned by g_get_tmp_dir()) as g_file_new_tmp().
+ *
+ * `tmpl` should be a string in the GLib file name encoding
+ * containing a sequence of six 'X' characters, and containing no
+ * directory components. If it is %NULL, a default template is used.
+ * @param tmpl - Template for the file
+ * @param ioPriority - the I/O priority of the request
+ * @param cancellable - optional #GCancellable object, %NULL to ignore
+ * @param callback - a #GAsyncReadyCallback to call when the request is done
+ * @param userData - data to pass to @callback
+ */
 export declare const fileNewTmpAsync: (ioPriority: number, tmpl?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Asynchronously creates a directory in the preferred directory for
+ * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
+ *
+ * `tmpl` should be a string in the GLib file name encoding
+ * containing a sequence of six 'X' characters, and containing no
+ * directory components. If it is %NULL, a default template is used.
+ * @param tmpl - Template for the file
+ * @param ioPriority - the I/O priority of the request
+ * @param cancellable - optional #GCancellable object, %NULL to ignore
+ * @param callback - a #GAsyncReadyCallback to call when the request is done
+ * @param userData - data to pass to @callback
+ */
 export declare const fileNewTmpDirAsync: (ioPriority: number, tmpl?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Finishes a temporary directory creation started by
+ * g_file_new_tmp_dir_async().
+ * @param result - a #GAsyncResult
+ */
 export declare const fileNewTmpDirFinish: (result: AsyncResult) => File;
+/**
+ * Finishes a temporary file creation started by g_file_new_tmp_async().
+ * @param result - a #GAsyncResult
+ * @param iostream - on return, a #GFileIOStream for the created file
+ */
 export declare const fileNewTmpFinish: (result: AsyncResult, iostream: Ref<FileIOStream>) => File;
+/**
+ * Constructs a #GFile with the given `parse_name` (i.e. something
+ * given by g_file_get_parse_name()). This operation never fails,
+ * but the returned object might not support any I/O operation if
+ * the `parse_name` cannot be parsed.
+ * @param parseName - a file name or path to be parsed
+ */
 export declare const fileParseName: (parseName: string) => File;
+/**
+ * Deserializes a #GIcon previously serialized using g_icon_serialize().
+ * @param value - a #GVariant created with g_icon_serialize()
+ */
 export declare const iconDeserialize: (value: GLib.Variant) => Icon | null;
+/**
+ * Generate a #GIcon instance from @str. This function can fail if
+ * `str` is not valid - see g_icon_to_string() for discussion.
+ *
+ * If your application or library provides one or more #GIcon
+ * implementations you need to ensure that each #GType is registered
+ * with the type system prior to calling g_icon_new_for_string().
+ * @param str - A string obtained via g_icon_to_string().
+ */
 export declare const iconNewForString: (str: string) => Icon;
+/**
+ * Helper function for constructing #GInitable object. This is
+ * similar to g_object_newv() but also initializes the object
+ * and returns %NULL, setting an error on failure.
+ * @param objectType - a #GType supporting #GInitable.
+ * @param nParameters - the number of parameters in @parameters
+ * @param parameters - the parameters to use to construct the object
+ * @param cancellable - optional #GCancellable object, %NULL to ignore.
+ */
 export declare const initableNewv: (objectType: number, nParameters: number, parameters: number[], cancellable?: Cancellable | null) => GObject.GObject;
+/**
+ * Converts `errno.h` error codes into GIO error codes.
+ *
+ * The fallback value %G_IO_ERROR_FAILED is returned for error codes not
+ * currently handled (but note that future GLib releases may return a more
+ * specific value instead).
+ *
+ * As `errno` is global and may be modified by intermediate function
+ * calls, you should save its value immediately after the call returns,
+ * and use the saved value instead of `errno`:
+ *
+ *
+ * |[<!-- language="C" -->
+ * int saved_errno;
+ *
+ * ret = read (blah);
+ * saved_errno = errno;
+ *
+ * g_io_error_from_errno (saved_errno);
+ * ]|
+ * @param errNo - Error number as defined in errno.h.
+ */
 export declare const ioErrorFromErrno: (errNo: number) => IOErrorEnum;
+/**
+ * Converts #GFileError error codes into GIO error codes.
+ * @param fileError - a #GFileError.
+ */
 export declare const ioErrorFromFileError: (fileError: GLib.FileError) => IOErrorEnum;
+/**
+ * Gets the GIO Error Quark.
+ */
 export declare const ioErrorQuark: () => number;
+/**
+ * Registers `type` as extension for the extension point with name
+ * @extension_point_name.
+ *
+ * If `type` has already been registered as an extension for this
+ * extension point, the existing #GIOExtension object is returned.
+ * @param extensionPointName - the name of the extension point
+ * @param type - the #GType to register as extension
+ * @param extensionName - the name for the extension
+ * @param priority - the priority for the extension
+ */
 export declare const ioExtensionPointImplement: (extensionPointName: string, type: number, extensionName: string, priority: number) => number;
+/**
+ * Looks up an existing extension point.
+ * @param name - the name of the extension point
+ */
 export declare const ioExtensionPointLookup: (name: string) => number;
+/**
+ * Registers an extension point.
+ * @param name - The name of the extension point
+ */
 export declare const ioExtensionPointRegister: (name: string) => number;
+/**
+ * Loads all the modules in the specified directory.
+ *
+ * If don't require all modules to be initialized (and thus registering
+ * all gtypes) then you can use g_io_modules_scan_all_in_directory()
+ * which allows delayed/lazy loading of modules.
+ * @param dirname - pathname for a directory containing modules
+ */
 export declare const ioModulesLoadAllInDirectory: (dirname: string) => IOModule[];
+/**
+ * Loads all the modules in the specified directory.
+ *
+ * If don't require all modules to be initialized (and thus registering
+ * all gtypes) then you can use g_io_modules_scan_all_in_directory()
+ * which allows delayed/lazy loading of modules.
+ * @param dirname - pathname for a directory containing modules
+ * @param scope - a scope to use when scanning the modules.
+ */
 export declare const ioModulesLoadAllInDirectoryWithScope: (dirname: string, scope: number) => IOModule[];
+/**
+ * Scans all the modules in the specified directory, ensuring that
+ * any extension point implemented by a module is registered.
+ *
+ * This may not actually load and initialize all the types in each
+ * module, some modules may be lazily loaded and initialized when
+ * an extension point it implements is used with e.g.
+ * g_io_extension_point_get_extensions() or
+ * g_io_extension_point_get_extension_by_name().
+ *
+ * If you need to guarantee that all types are loaded in all the modules,
+ * use g_io_modules_load_all_in_directory().
+ * @param dirname - pathname for a directory containing modules
+ */
 export declare const ioModulesScanAllInDirectory: (dirname: string) => void;
+/**
+ * Scans all the modules in the specified directory, ensuring that
+ * any extension point implemented by a module is registered.
+ *
+ * This may not actually load and initialize all the types in each
+ * module, some modules may be lazily loaded and initialized when
+ * an extension point it implements is used with e.g.
+ * g_io_extension_point_get_extensions() or
+ * g_io_extension_point_get_extension_by_name().
+ *
+ * If you need to guarantee that all types are loaded in all the modules,
+ * use g_io_modules_load_all_in_directory().
+ * @param dirname - pathname for a directory containing modules
+ * @param scope - a scope to use when scanning the modules
+ */
 export declare const ioModulesScanAllInDirectoryWithScope: (dirname: string, scope: number) => void;
+/**
+ * Cancels all cancellable I/O jobs.
+ *
+ * A job is cancellable if a #GCancellable was passed into
+ * g_io_scheduler_push_job().
+ */
 export declare const ioSchedulerCancelAllJobs: () => void;
+/**
+ * Schedules the I/O job to run in another thread.
+ *
+ * `notify` will be called on `user_data` after `job_func` has returned,
+ * regardless whether the job was cancelled or has run to completion.
+ *
+ * If `cancellable` is not %NULL, it can be used to cancel the I/O job
+ * by calling g_cancellable_cancel() or by calling
+ * g_io_scheduler_cancel_all_jobs().
+ * @param jobFunc - a #GIOSchedulerJobFunc.
+ * @param userData - data to pass to @job_func
+ * @param notify - a #GDestroyNotify for @user_data, or %NULL
+ * @param ioPriority - the I/O priority
+ * @param cancellable - optional #GCancellable object, %NULL to ignore.
+ */
 export declare const ioSchedulerPushJob: (jobFunc: (...args: unknown[]) => unknown, ioPriority: number, userData?: number | null, notify?: () => void | null, cancellable?: Cancellable | null) => void;
+/**
+ * Creates a keyfile-backed [class@Gio.SettingsBackend].
+ *
+ * The filename of the keyfile to use is given by @filename.
+ *
+ * All settings read to or written from the backend must fall under the
+ * path given in `root_path` (which must start and end with a slash and
+ * not contain two consecutive slashes).  `root_path` may be `"/"`.
+ *
+ * If `root_group` is non-`NULL` then it specifies the name of the keyfile
+ * group used for keys that are written directly below @root_path.  For
+ * example, if `root_path` is `"/apps/example/"` and `root_group` is
+ * `"toplevel"`, then setting the key `"/apps/example/enabled"` to true will
+ * cause the following to appear in the keyfile:
+ *
+ * ```
+ * [toplevel]
+ * enabled=true
+ * ```
+ *
+ * If `root_group` is `NULL` then it is not permitted to store keys
+ * directly below the @root_path.
+ *
+ * For keys not stored directly below `root_path` (ie: in a sub-path),
+ * the name of the subpath (with the final slash stripped) is used as
+ * the name of the keyfile group.  To continue the example, if
+ * `"/apps/example/profiles/default/font-size"` were set to
+ * `12` then the following would appear in the keyfile:
+ *
+ * ```
+ * [profiles/default]
+ * font-size=12
+ * ```
+ *
+ * The backend will refuse writes (and return writability as being
+ * false) for keys outside of `root_path` and, in the event that
+ * `root_group` is `NULL`, also for keys directly under @root_path.
+ * Writes will also be refused if the backend detects that it has the
+ * inability to rewrite the keyfile (ie: the containing directory is not
+ * writable).
+ *
+ * There is no checking done for your key namespace clashing with the
+ * syntax of the key file format.  For example, if you have `[` or `]`
+ * characters in your path names or `=` in your key names you may be in
+ * trouble.
+ *
+ * The backend reads default values from a keyfile called `defaults` in
+ * the directory specified by the `GKeyfileSettingsBackend:defaults-dir`
+ * property, and a list of locked keys from a text file with the name `locks` in
+ * the same location.
+ * @param filename - the filename of the keyfile
+ * @param rootPath - the path under which all settings keys appear
+ * @param rootGroup - the group name corresponding to @root_path, or
+ */
 export declare const keyfileSettingsBackendNew: (filename: string, rootPath: string, rootGroup?: string | null) => SettingsBackend;
+/**
+ * Gets a reference to the default #GMemoryMonitor for the system.
+ */
 export declare const memoryMonitorDupDefault: () => MemoryMonitor;
+/**
+ * Creates a memory-backed #GSettingsBackend.
+ *
+ * This backend allows changes to settings, but does not write them
+ * to any backing storage, so the next time you run your application,
+ * the memory backend will start out with the default values again.
+ */
 export declare const memorySettingsBackendNew: () => SettingsBackend;
+/**
+ * Gets the default #GNetworkMonitor for the system.
+ */
 export declare const networkMonitorGetDefault: () => NetworkMonitor;
+/**
+ * Initializes the platform networking libraries (eg, on Windows, this
+ * calls WSAStartup()). GLib will call this itself if it is needed, so
+ * you only need to call it if you directly call system networking
+ * functions (without calling any GLib networking functions first).
+ */
 export declare const networkingInit: () => void;
+/**
+ * Creates a readonly #GSettingsBackend.
+ *
+ * This backend does not allow changes to settings, so all settings
+ * will always have their default values.
+ */
 export declare const nullSettingsBackendNew: () => SettingsBackend;
+/**
+ * Utility method for #GPollableInputStream and #GPollableOutputStream
+ * implementations. Creates a new #GSource that expects a callback of
+ * type #GPollableSourceFunc. The new source does not actually do
+ * anything on its own; use g_source_add_child_source() to add other
+ * sources to it to cause it to trigger.
+ * @param pollableStream - the stream associated with the new source
+ */
 export declare const pollableSourceNew: (pollableStream: GObject.GObject) => GLib.Source;
+/**
+ * Utility method for #GPollableInputStream and #GPollableOutputStream
+ * implementations. Creates a new #GSource, as with
+ * g_pollable_source_new(), but also attaching `child_source` (with a
+ * dummy callback), and @cancellable, if they are non-%NULL.
+ * @param pollableStream - the stream associated with the
+ * @param childSource - optional child source to attach
+ * @param cancellable - optional #GCancellable to attach
+ */
 export declare const pollableSourceNewFull: (pollableStream: GObject.GObject, childSource?: GLib.Source | null, cancellable?: Cancellable | null) => GLib.Source;
+/**
+ * Tries to read from @stream, as with g_input_stream_read() (if
+ * `blocking` is %TRUE) or g_pollable_input_stream_read_nonblocking()
+ * (if `blocking` is %FALSE). This can be used to more easily share
+ * code between blocking and non-blocking implementations of a method.
+ *
+ * If `blocking` is %FALSE, then `stream` must be a
+ * #GPollableInputStream for which g_pollable_input_stream_can_poll()
+ * returns %TRUE, or else the behavior is undefined. If `blocking` is
+ * %TRUE, then `stream` does not need to be a #GPollableInputStream.
+ * @param stream - a #GInputStream
+ * @param buffer - a buffer to
+ * @param count - the number of bytes to read
+ * @param blocking - whether to do blocking I/O
+ * @param cancellable - optional #GCancellable object, %NULL to ignore.
+ */
 export declare const pollableStreamRead: (stream: InputStream, buffer: number[], count: number, blocking: boolean, cancellable?: Cancellable | null) => number;
+/**
+ * Tries to write to @stream, as with g_output_stream_write() (if
+ * `blocking` is %TRUE) or g_pollable_output_stream_write_nonblocking()
+ * (if `blocking` is %FALSE). This can be used to more easily share
+ * code between blocking and non-blocking implementations of a method.
+ *
+ * If `blocking` is %FALSE, then `stream` must be a
+ * #GPollableOutputStream for which
+ * g_pollable_output_stream_can_poll() returns %TRUE or else the
+ * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
+ * need to be a #GPollableOutputStream.
+ * @param stream - a #GOutputStream.
+ * @param buffer - the buffer
+ * @param count - the number of bytes to write
+ * @param blocking - whether to do blocking I/O
+ * @param cancellable - optional #GCancellable object, %NULL to ignore.
+ */
 export declare const pollableStreamWrite: (stream: OutputStream, buffer: number[], count: number, blocking: boolean, cancellable?: Cancellable | null) => number;
+/**
+ * Tries to write `count` bytes to @stream, as with
+ * g_output_stream_write_all(), but using g_pollable_stream_write()
+ * rather than g_output_stream_write().
+ *
+ * On a successful write of `count` bytes, %TRUE is returned, and
+ * `bytes_written` is set to @count.
+ *
+ * If there is an error during the operation (including
+ * %G_IO_ERROR_WOULD_BLOCK in the non-blocking case), %FALSE is
+ * returned and `error` is set to indicate the error status,
+ * `bytes_written` is updated to contain the number of bytes written
+ * into the stream before the error occurred.
+ *
+ * As with g_pollable_stream_write(), if `blocking` is %FALSE, then
+ * `stream` must be a #GPollableOutputStream for which
+ * g_pollable_output_stream_can_poll() returns %TRUE or else the
+ * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
+ * need to be a #GPollableOutputStream.
+ * @param stream - a #GOutputStream.
+ * @param buffer - the buffer
+ * @param count - the number of bytes to write
+ * @param blocking - whether to do blocking I/O
+ * @param bytesWritten - location to store the number of bytes that was
+ * @param cancellable - optional #GCancellable object, %NULL to ignore.
+ */
 export declare const pollableStreamWriteAll: (stream: OutputStream, buffer: number[], count: number, blocking: boolean, bytesWritten: Ref<number>, cancellable?: Cancellable | null) => boolean;
+/**
+ * Gets a reference to the default #GPowerProfileMonitor for the system.
+ */
 export declare const powerProfileMonitorDupDefault: () => PowerProfileMonitor;
+/**
+ * Find the `gio-proxy` extension point for a proxy implementation that supports
+ * the specified protocol.
+ * @param protocol - the proxy protocol name (e.g. http, socks, etc)
+ */
 export declare const proxyGetDefaultForProtocol: (protocol: string) => Proxy | null;
+/**
+ * Gets the default #GProxyResolver for the system.
+ */
 export declare const proxyResolverGetDefault: () => ProxyResolver;
+/**
+ * Gets the #GResolver Error Quark.
+ */
 export declare const resolverErrorQuark: () => number;
+/**
+ * Gets the [struct@Gio.Resource] Error Quark.
+ */
 export declare const resourceErrorQuark: () => number;
+/**
+ * Loads a binary resource bundle and creates a [struct@Gio.Resource]
+ * representation of it, allowing you to query it for data.
+ *
+ * If you want to use this resource in the global resource namespace you need
+ * to register it with [func@Gio.resources_register].
+ *
+ * If `filename` is empty or the data in it is corrupt,
+ * %G_RESOURCE_ERROR_INTERNAL will be returned. If `filename` doesn’t exist, or
+ * there is an error in reading it, an error from [ctor@GLib.MappedFile.new]
+ * will be returned.
+ * @param filename - the path of a filename to load, in the GLib filename encoding
+ */
 export declare const resourceLoad: (filename: string) => Resource;
+/**
+ * Returns all the names of children at the specified `path` in the set of
+ * globally registered resources.
+ *
+ * The return result is a `NULL` terminated list of strings which should
+ * be released with [func@GLib.strfreev].
+ *
+ * `lookup_flags` controls the behaviour of the lookup.
+ * @param path - A path name inside the resource
+ * @param lookupFlags - A [flags@Gio.ResourceLookupFlags]
+ */
 export declare const resourcesEnumerateChildren: (path: string, lookupFlags: ResourceLookupFlags) => string[];
+/**
+ * Looks for a file at the specified `path` in the set of
+ * globally registered resources and if found returns information about it.
+ *
+ * `lookup_flags` controls the behaviour of the lookup.
+ * @param path - A path name inside the resource
+ * @param lookupFlags - A [flags@Gio.ResourceLookupFlags]
+ * @param size - a location to place the length of the contents of the file,
+ * @param flags - a location to place the [flags@Gio.ResourceFlags] about the file,
+ */
 export declare const resourcesGetInfo: (path: string, lookupFlags: ResourceLookupFlags, size?: Ref<number> | null, flags?: Ref<number> | null) => boolean;
+/**
+ * Returns whether the specified `path` in the set of
+ * globally registered resources has children.
+ * @param path - A pathname
+ */
 export declare const resourcesHasChildren: (path: string) => boolean;
+/**
+ * Looks for a file at the specified `path` in the set of
+ * globally registered resources and returns a [struct@GLib.Bytes] that
+ * lets you directly access the data in memory.
+ *
+ * The data is always followed by a zero byte, so you
+ * can safely use the data as a C string. However, that byte
+ * is not included in the size of the [struct@GLib.Bytes].
+ *
+ * For uncompressed resource files this is a pointer directly into
+ * the resource bundle, which is typically in some read-only data section
+ * in the program binary. For compressed files we allocate memory on
+ * the heap and automatically uncompress the data.
+ *
+ * `lookup_flags` controls the behaviour of the lookup.
+ * @param path - A path name inside the resource
+ * @param lookupFlags - A [flags@Gio.ResourceLookupFlags]
+ */
 export declare const resourcesLookupData: (path: string, lookupFlags: ResourceLookupFlags) => GLib.Bytes;
+/**
+ * Looks for a file at the specified `path` in the set of
+ * globally registered resources and returns a [class@Gio.InputStream]
+ * that lets you read the data.
+ *
+ * `lookup_flags` controls the behaviour of the lookup.
+ * @param path - A path name inside the resource
+ * @param lookupFlags - A [flags@Gio.ResourceLookupFlags]
+ */
 export declare const resourcesOpenStream: (path: string, lookupFlags: ResourceLookupFlags) => InputStream;
+/**
+ * Registers the resource with the process-global set of resources.
+ *
+ * Once a resource is registered the files in it can be accessed
+ * with the global resource lookup functions like
+ * [func@Gio.resources_lookup_data].
+ * @param resource - A [struct@Gio.Resource]
+ */
 export declare const resourcesRegister: (resource: Resource) => void;
+/**
+ * Unregisters the resource from the process-global set of resources.
+ * @param resource - A [struct@Gio.Resource]
+ */
 export declare const resourcesUnregister: (resource: Resource) => void;
+/**
+ * Gets the default system schema source.
+ *
+ * This function is not required for normal uses of #GSettings but it
+ * may be useful to authors of plugin management systems or to those who
+ * want to introspect the content of schemas.
+ *
+ * If no schemas are installed, %NULL will be returned.
+ *
+ * The returned source may actually consist of multiple schema sources
+ * from different directories, depending on which directories were given
+ * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
+ * lookups performed against the default source should probably be done
+ * recursively.
+ */
 export declare const settingsSchemaSourceGetDefault: () => SettingsSchemaSource | null;
+/**
+ * Reports an error in an idle function. Similar to
+ * g_simple_async_report_error_in_idle(), but takes a #GError rather
+ * than building a new one.
+ * @param object - a #GObject, or %NULL
+ * @param callback - a #GAsyncReadyCallback.
+ * @param userData - user data passed to @callback.
+ * @param error - the #GError to report
+ */
 export declare const simpleAsyncReportGerrorInIdle: (error: GLib.GError, object?: GObject.GObject | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null) => void;
+/**
+ * Gets the default #GTlsBackend for the system.
+ */
 export declare const tlsBackendGetDefault: () => TlsBackend;
+/**
+ * Gets the TLS channel binding error quark.
+ */
 export declare const tlsChannelBindingErrorQuark: () => number;
+/**
+ * Creates a new #GTlsClientConnection wrapping `base_io_stream` (which
+ * must have pollable input and output streams) which is assumed to
+ * communicate with the server identified by @server_identity.
+ *
+ * See the documentation for #GTlsConnection:base-io-stream for restrictions
+ * on when application code can run operations on the `base_io_stream` after
+ * this function has returned.
+ * @param baseIoStream - the #GIOStream to wrap
+ * @param serverIdentity - the expected identity of the server
+ */
 export declare const tlsClientConnectionNew: (baseIoStream: IOStream, serverIdentity?: SocketConnectable | null) => TlsClientConnection;
+/**
+ * Gets the TLS error quark.
+ */
 export declare const tlsErrorQuark: () => number;
+/**
+ * Creates a new #GTlsFileDatabase which uses anchor certificate authorities
+ * in `anchors` to verify certificate chains.
+ *
+ * The certificates in `anchors` must be PEM encoded.
+ * @param anchors - filename of anchor certificate authorities.
+ */
 export declare const tlsFileDatabaseNew: (anchors: string) => TlsFileDatabase;
+/**
+ * Creates a new #GTlsServerConnection wrapping `base_io_stream` (which
+ * must have pollable input and output streams).
+ *
+ * See the documentation for #GTlsConnection:base-io-stream for restrictions
+ * on when application code can run operations on the `base_io_stream` after
+ * this function has returned.
+ * @param baseIoStream - the #GIOStream to wrap
+ * @param certificate - the default server certificate, or %NULL
+ */
 export declare const tlsServerConnectionNew: (baseIoStream: IOStream, certificate?: TlsCertificate | null) => TlsServerConnection;