@gtkx/ffi 0.1.44 → 0.1.46

package/dist/generated/gio/functions.js

@@ -22,6 +22,16 @@ 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 const actionNameIsValid = (actionName) => {
     return call("libgio-2.0.so.0", "g_action_name_is_valid", [
         {
@@ -30,6 +40,41 @@ export const actionNameIsValid = (actionName) => {
         },
     ], { type: "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 const actionParseDetailedName = (detailedName, actionName, targetValue) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_action_parse_detailed_name", [
@@ -71,6 +116,19 @@ export const actionParseDetailedName = (detailedName, actionName, targetValue) =
     }
     return result;
 };
+/**
+ * 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 const actionPrintDetailedName = (actionName, targetValue) => {
     return call("libgio-2.0.so.0", "g_action_print_detailed_name", [
         {
@@ -89,6 +147,20 @@ export const actionPrintDetailedName = (actionName, targetValue) => {
         },
     ], { type: "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 const appInfoCreateFromCommandline = (commandline, flags, applicationName) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_app_info_create_from_commandline", [
@@ -122,6 +194,21 @@ export const appInfoCreateFromCommandline = (commandline, flags, applicationName
     }
     return getObject(ptr, 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 const appInfoGetAll = () => {
     return call("libgio-2.0.so.0", "g_app_info_get_all", [], {
         type: "array",
@@ -130,6 +217,13 @@ export const appInfoGetAll = () => {
         borrowed: true,
     });
 };
+/**
+ * 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 const appInfoGetAllForType = (contentType) => {
     return call("libgio-2.0.so.0", "g_app_info_get_all_for_type", [
         {
@@ -143,6 +237,11 @@ export const appInfoGetAllForType = (contentType) => {
         borrowed: true,
     });
 };
+/**
+ * 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 const appInfoGetDefaultForType = (contentType, mustSupportUris) => {
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_type", [
         {
@@ -158,6 +257,15 @@ export const appInfoGetDefaultForType = (contentType, mustSupportUris) => {
         return null;
     return getObject(ptr, AppInfo);
 };
+/**
+ * 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 const appInfoGetDefaultForTypeAsync = (contentType, mustSupportUris, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_app_info_get_default_for_type_async", [
         {
@@ -185,6 +293,14 @@ export const appInfoGetDefaultForTypeAsync = (contentType, mustSupportUris, canc
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const appInfoGetDefaultForTypeFinish = (result) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_type_finish", [
@@ -209,6 +325,13 @@ export const appInfoGetDefaultForTypeFinish = (result) => {
     }
     return getObject(ptr, 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 const appInfoGetDefaultForUriScheme = (uriScheme) => {
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_uri_scheme", [
         {
@@ -220,6 +343,16 @@ export const appInfoGetDefaultForUriScheme = (uriScheme) => {
         return null;
     return getObject(ptr, AppInfo);
 };
+/**
+ * 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 const appInfoGetDefaultForUriSchemeAsync = (uriScheme, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_app_info_get_default_for_uri_scheme_async", [
         {
@@ -243,6 +376,14 @@ export const appInfoGetDefaultForUriSchemeAsync = (uriScheme, cancellable, callb
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const appInfoGetDefaultForUriSchemeFinish = (result) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_uri_scheme_finish", [
@@ -267,6 +408,12 @@ export const appInfoGetDefaultForUriSchemeFinish = (result) => {
     }
     return getObject(ptr, 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 const appInfoGetFallbackForType = (contentType) => {
     return call("libgio-2.0.so.0", "g_app_info_get_fallback_for_type", [
         {
@@ -280,6 +427,16 @@ export const appInfoGetFallbackForType = (contentType) => {
         borrowed: true,
     });
 };
+/**
+ * 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 const appInfoGetRecommendedForType = (contentType) => {
     return call("libgio-2.0.so.0", "g_app_info_get_recommended_for_type", [
         {
@@ -293,6 +450,17 @@ export const appInfoGetRecommendedForType = (contentType) => {
         borrowed: true,
     });
 };
+/**
+ * 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 const appInfoLaunchDefaultForUri = (uri, context) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_app_info_launch_default_for_uri", [
@@ -322,6 +490,22 @@ export const appInfoLaunchDefaultForUri = (uri, context) => {
     }
     return result;
 };
+/**
+ * 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 const appInfoLaunchDefaultForUriAsync = (uri, context, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_app_info_launch_default_for_uri_async", [
         {
@@ -350,6 +534,10 @@ export const appInfoLaunchDefaultForUriAsync = (uri, context, cancellable, callb
         },
     ], { type: "undefined" });
 };
+/**
+ * Finishes an asynchronous launch-default-for-uri operation.
+ * @param result - the async result
+ */
 export const appInfoLaunchDefaultForUriFinish = (result) => {
     const error = { value: null };
     const _result = call("libgio-2.0.so.0", "g_app_info_launch_default_for_uri_finish", [
@@ -374,6 +562,14 @@ export const appInfoLaunchDefaultForUriFinish = (result) => {
     }
     return _result;
 };
+/**
+ * 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 const appInfoResetTypeAssociations = (contentType) => {
     call("libgio-2.0.so.0", "g_app_info_reset_type_associations", [
         {
@@ -382,6 +578,21 @@ export const appInfoResetTypeAssociations = (contentType) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const asyncInitableNewvAsync = (objectType, nParameters, parameters, ioPriority, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_async_initable_newv_async", [
         {
@@ -417,6 +628,19 @@ export const asyncInitableNewvAsync = (objectType, nParameters, parameters, ioPr
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const busGet = (busType, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_bus_get", [
         {
@@ -440,6 +664,21 @@ export const busGet = (busType, cancellable, callback, userData) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const busGetFinish = (res) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_bus_get_finish", [
@@ -464,6 +703,28 @@ export const busGetFinish = (res) => {
     }
     return getObject(ptr, 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 const busGetSync = (busType, cancellable) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_bus_get_sync", [
@@ -493,6 +754,64 @@ export const busGetSync = (busType, cancellable) => {
     }
     return getObject(ptr, 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 const busOwnName = (busType, name, flags, busAcquiredHandler, nameAcquiredHandler, nameLostHandler, userData, userDataFreeFunc) => {
     return call("libgio-2.0.so.0", "g_bus_own_name", [
         {
@@ -534,6 +853,17 @@ export const busOwnName = (busType, name, flags, busAcquiredHandler, nameAcquire
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busOwnNameOnConnection = (connection, name, flags, nameAcquiredHandler, nameLostHandler, userData, userDataFreeFunc) => {
     return call("libgio-2.0.so.0", "g_bus_own_name_on_connection", [
         {
@@ -570,6 +900,15 @@ export const busOwnNameOnConnection = (connection, name, flags, nameAcquiredHand
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busOwnNameOnConnectionWithClosures = (connection, name, flags, nameAcquiredClosure, nameLostClosure) => {
     return call("libgio-2.0.so.0", "g_bus_own_name_on_connection_with_closures", [
         {
@@ -606,6 +945,16 @@ export const busOwnNameOnConnectionWithClosures = (connection, name, flags, name
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busOwnNameWithClosures = (busType, name, flags, busAcquiredClosure, nameAcquiredClosure, nameLostClosure) => {
     return call("libgio-2.0.so.0", "g_bus_own_name_with_closures", [
         {
@@ -652,6 +1001,18 @@ export const busOwnNameWithClosures = (busType, name, flags, busAcquiredClosure,
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busUnownName = (ownerId) => {
     call("libgio-2.0.so.0", "g_bus_unown_name", [
         {
@@ -660,6 +1021,17 @@ export const busUnownName = (ownerId) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const busUnwatchName = (watcherId) => {
     call("libgio-2.0.so.0", "g_bus_unwatch_name", [
         {
@@ -668,6 +1040,43 @@ export const busUnwatchName = (watcherId) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const busWatchName = (busType, name, flags, nameAppearedHandler, nameVanishedHandler, userData, userDataFreeFunc) => {
     return call("libgio-2.0.so.0", "g_bus_watch_name", [
         {
@@ -704,6 +1113,17 @@ export const busWatchName = (busType, name, flags, nameAppearedHandler, nameVani
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busWatchNameOnConnection = (connection, name, flags, nameAppearedHandler, nameVanishedHandler, userData, userDataFreeFunc) => {
     return call("libgio-2.0.so.0", "g_bus_watch_name_on_connection", [
         {
@@ -740,6 +1160,15 @@ export const busWatchNameOnConnection = (connection, name, flags, nameAppearedHa
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busWatchNameOnConnectionWithClosures = (connection, name, flags, nameAppearedClosure, nameVanishedClosure) => {
     return call("libgio-2.0.so.0", "g_bus_watch_name_on_connection_with_closures", [
         {
@@ -776,6 +1205,15 @@ export const busWatchNameOnConnectionWithClosures = (connection, name, flags, na
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const busWatchNameWithClosures = (busType, name, flags, nameAppearedClosure, nameVanishedClosure) => {
     return call("libgio-2.0.so.0", "g_bus_watch_name_with_closures", [
         {
@@ -812,6 +1250,11 @@ export const busWatchNameWithClosures = (busType, name, flags, nameAppearedClosu
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * 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 const contentTypeCanBeExecutable = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_can_be_executable", [
         {
@@ -820,6 +1263,11 @@ export const contentTypeCanBeExecutable = (type) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Compares two content types for equality.
+ * @param type1 - a content type string
+ * @param type2 - a content type string
+ */
 export const contentTypeEquals = (type1, type2) => {
     return call("libgio-2.0.so.0", "g_content_type_equals", [
         {
@@ -832,6 +1280,10 @@ export const contentTypeEquals = (type1, type2) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Tries to find a content type based on the mime type name.
+ * @param mimeType - a mime type string
+ */
 export const contentTypeFromMimeType = (mimeType) => {
     return call("libgio-2.0.so.0", "g_content_type_from_mime_type", [
         {
@@ -840,6 +1292,10 @@ export const contentTypeFromMimeType = (mimeType) => {
         },
     ], { type: "string" });
 };
+/**
+ * Gets the human readable description of the content type.
+ * @param type - a content type string
+ */
 export const contentTypeGetDescription = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_get_description", [
         {
@@ -848,6 +1304,14 @@ export const contentTypeGetDescription = (type) => {
         },
     ], { type: "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 const contentTypeGetGenericIconName = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_get_generic_icon_name", [
         {
@@ -856,6 +1320,10 @@ export const contentTypeGetGenericIconName = (type) => {
         },
     ], { type: "string" });
 };
+/**
+ * Gets the icon for a content type.
+ * @param type - a content type string
+ */
 export const contentTypeGetIcon = (type) => {
     const ptr = call("libgio-2.0.so.0", "g_content_type_get_icon", [
         {
@@ -865,12 +1333,20 @@ export const contentTypeGetIcon = (type) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, Icon);
 };
+/**
+ * Get the list of directories which MIME data is loaded from. See
+ * g_content_type_set_mime_dirs() for details.
+ */
 export const contentTypeGetMimeDirs = () => {
     return call("libgio-2.0.so.0", "g_content_type_get_mime_dirs", [], {
         type: "array",
         itemType: { type: "string" },
     });
 };
+/**
+ * Gets the mime type for the content type, if one is registered.
+ * @param type - a content type string
+ */
 export const contentTypeGetMimeType = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_get_mime_type", [
         {
@@ -879,6 +1355,10 @@ export const contentTypeGetMimeType = (type) => {
         },
     ], { type: "string" });
 };
+/**
+ * Gets the symbolic icon for a content type.
+ * @param type - a content type string
+ */
 export const contentTypeGetSymbolicIcon = (type) => {
     const ptr = call("libgio-2.0.so.0", "g_content_type_get_symbolic_icon", [
         {
@@ -888,6 +1368,15 @@ export const contentTypeGetSymbolicIcon = (type) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const contentTypeGuess = (dataSize, filename, data, resultUncertain) => {
     return call("libgio-2.0.so.0", "g_content_type_guess", [
         {
@@ -914,6 +1403,21 @@ export const contentTypeGuess = (dataSize, filename, data, resultUncertain) => {
         },
     ], { type: "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 const contentTypeGuessForTree = (root) => {
     return call("libgio-2.0.so.0", "g_content_type_guess_for_tree", [
         {
@@ -922,6 +1426,11 @@ export const contentTypeGuessForTree = (root) => {
         },
     ], { type: "array", itemType: { type: "string" } });
 };
+/**
+ * Determines if `type` is a subset of @supertype.
+ * @param type - a content type string
+ * @param supertype - a content type string
+ */
 export const contentTypeIsA = (type, supertype) => {
     return call("libgio-2.0.so.0", "g_content_type_is_a", [
         {
@@ -934,6 +1443,12 @@ export const contentTypeIsA = (type, supertype) => {
         },
     ], { type: "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 const contentTypeIsMimeType = (type, mimeType) => {
     return call("libgio-2.0.so.0", "g_content_type_is_mime_type", [
         {
@@ -946,6 +1461,13 @@ export const contentTypeIsMimeType = (type, mimeType) => {
         },
     ], { type: "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 const contentTypeIsUnknown = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_is_unknown", [
         {
@@ -954,6 +1476,32 @@ export const contentTypeIsUnknown = (type) => {
         },
     ], { type: "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 const contentTypeSetMimeDirs = (dirs) => {
     call("libgio-2.0.so.0", "g_content_type_set_mime_dirs", [
         {
@@ -963,6 +1511,11 @@ export const contentTypeSetMimeDirs = (dirs) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const contentTypesGetRegistered = () => {
     return call("libgio-2.0.so.0", "g_content_types_get_registered", [], {
         type: "array",
@@ -971,6 +1524,16 @@ export const contentTypesGetRegistered = () => {
         borrowed: true,
     });
 };
+/**
+ * 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 const dbusAddressEscapeValue = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_address_escape_value", [
         {
@@ -979,6 +1542,16 @@ export const dbusAddressEscapeValue = (string) => {
         },
     ], { type: "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 const dbusAddressGetForBusSync = (busType, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_dbus_address_get_for_bus_sync", [
@@ -1008,6 +1581,23 @@ export const dbusAddressGetForBusSync = (busType, cancellable) => {
     }
     return result;
 };
+/**
+ * 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 const dbusAddressGetStream = (address, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_dbus_address_get_stream", [
         {
@@ -1031,6 +1621,14 @@ export const dbusAddressGetStream = (address, cancellable, callback, userData) =
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const dbusAddressGetStreamFinish = (res, outGuid) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dbus_address_get_stream_finish", [
@@ -1060,6 +1658,21 @@ export const dbusAddressGetStreamFinish = (res, outGuid) => {
     }
     return getObject(ptr, 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 const dbusAddressGetStreamSync = (address, outGuid, cancellable) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dbus_address_get_stream_sync", [
@@ -1094,6 +1707,13 @@ export const dbusAddressGetStreamSync = (address, outGuid, cancellable) => {
     }
     return getObject(ptr, 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 const dbusAnnotationInfoLookup = (name, annotations) => {
     return call("libgio-2.0.so.0", "g_dbus_annotation_info_lookup", [
         {
@@ -1114,6 +1734,23 @@ export const dbusAnnotationInfoLookup = (name, annotations) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * 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 const dbusErrorEncodeGerror = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_encode_gerror", [
         {
@@ -1127,6 +1764,15 @@ export const dbusErrorEncodeGerror = (error) => {
         },
     ], { type: "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 const dbusErrorGetRemoteError = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_get_remote_error", [
         {
@@ -1140,6 +1786,12 @@ export const dbusErrorGetRemoteError = (error) => {
         },
     ], { type: "string" });
 };
+/**
+ * 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 const dbusErrorIsRemoteError = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_is_remote_error", [
         {
@@ -1153,6 +1805,39 @@ export const dbusErrorIsRemoteError = (error) => {
         },
     ], { type: "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 const dbusErrorNewForDbusError = (dbusErrorName, dbusErrorMessage) => {
     const ptr = call("libgio-2.0.so.0", "g_dbus_error_new_for_dbus_error", [
         {
@@ -1178,6 +1863,16 @@ export const dbusErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * 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 const dbusErrorRegisterError = (errorDomain, errorCode, dbusErrorName) => {
     return call("libgio-2.0.so.0", "g_dbus_error_register_error", [
         {
@@ -1194,6 +1889,17 @@ export const dbusErrorRegisterError = (errorDomain, errorCode, dbusErrorName) =>
         },
     ], { type: "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 const dbusErrorRegisterErrorDomain = (errorDomainQuarkName, quarkVolatile, entries, numEntries) => {
     call("libgio-2.0.so.0", "g_dbus_error_register_error_domain", [
         {
@@ -1217,6 +1923,17 @@ export const dbusErrorRegisterErrorDomain = (errorDomainQuarkName, quarkVolatile
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const dbusErrorStripRemoteError = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_strip_remote_error", [
         {
@@ -1230,6 +1947,13 @@ export const dbusErrorStripRemoteError = (error) => {
         },
     ], { type: "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 const dbusErrorUnregisterError = (errorDomain, errorCode, dbusErrorName) => {
     return call("libgio-2.0.so.0", "g_dbus_error_unregister_error", [
         {
@@ -1246,6 +1970,10 @@ export const dbusErrorUnregisterError = (errorDomain, errorCode, dbusErrorName)
         },
     ], { type: "boolean" });
 };
+/**
+ * This is a language binding friendly version of g_dbus_escape_object_path_bytestring().
+ * @param s - the string to escape
+ */
 export const dbusEscapeObjectPath = (s) => {
     return call("libgio-2.0.so.0", "g_dbus_escape_object_path", [
         {
@@ -1254,6 +1982,25 @@ export const dbusEscapeObjectPath = (s) => {
         },
     ], { type: "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 const dbusEscapeObjectPathBytestring = (bytes) => {
     return call("libgio-2.0.so.0", "g_dbus_escape_object_path_bytestring", [
         {
@@ -1265,11 +2012,54 @@ export const dbusEscapeObjectPathBytestring = (bytes) => {
         },
     ], { type: "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 const dbusGenerateGuid = () => {
     return call("libgio-2.0.so.0", "g_dbus_generate_guid", [], {
         type: "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 const dbusGvalueToGvariant = (gvalue, type) => {
     const ptr = call("libgio-2.0.so.0", "g_dbus_gvalue_to_gvariant", [
         {
@@ -1298,6 +2088,21 @@ export const dbusGvalueToGvariant = (gvalue, type) => {
     });
     return getObject(ptr, 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 const dbusGvariantToGvalue = (value, outGvalue) => {
     call("libgio-2.0.so.0", "g_dbus_gvariant_to_gvalue", [
         {
@@ -1322,6 +2127,15 @@ export const dbusGvariantToGvalue = (value, outGvalue) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const dbusIsAddress = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_address", [
         {
@@ -1330,6 +2144,14 @@ export const dbusIsAddress = (string) => {
         },
     ], { type: "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 const dbusIsErrorName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_error_name", [
         {
@@ -1338,6 +2160,13 @@ export const dbusIsErrorName = (string) => {
         },
     ], { type: "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 const dbusIsGuid = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_guid", [
         {
@@ -1346,6 +2175,10 @@ export const dbusIsGuid = (string) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks if `string` is a valid D-Bus interface name.
+ * @param string - The string to check.
+ */
 export const dbusIsInterfaceName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_interface_name", [
         {
@@ -1354,6 +2187,10 @@ export const dbusIsInterfaceName = (string) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks if `string` is a valid D-Bus member (e.g. signal or method) name.
+ * @param string - The string to check.
+ */
 export const dbusIsMemberName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_member_name", [
         {
@@ -1362,6 +2199,10 @@ export const dbusIsMemberName = (string) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks if `string` is a valid D-Bus bus name (either unique or well-known).
+ * @param string - The string to check.
+ */
 export const dbusIsName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_name", [
         {
@@ -1370,6 +2211,13 @@ export const dbusIsName = (string) => {
         },
     ], { type: "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 const dbusIsSupportedAddress = (string) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_dbus_is_supported_address", [
@@ -1394,6 +2242,10 @@ export const dbusIsSupportedAddress = (string) => {
     }
     return result;
 };
+/**
+ * Checks if `string` is a valid D-Bus unique bus name.
+ * @param string - The string to check.
+ */
 export const dbusIsUniqueName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_unique_name", [
         {
@@ -1402,6 +2254,17 @@ export const dbusIsUniqueName = (string) => {
         },
     ], { type: "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 const dbusUnescapeObjectPath = (s) => {
     return call("libgio-2.0.so.0", "g_dbus_unescape_object_path", [
         {
@@ -1410,6 +2273,12 @@ export const dbusUnescapeObjectPath = (s) => {
         },
     ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
 };
+/**
+ * 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 const dtlsClientConnectionNew = (baseSocket, serverIdentity) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dtls_client_connection_new", [
@@ -1439,6 +2308,11 @@ export const dtlsClientConnectionNew = (baseSocket, serverIdentity) => {
     }
     return getObject(ptr, DtlsClientConnection);
 };
+/**
+ * Creates a new #GDtlsServerConnection wrapping @base_socket.
+ * @param baseSocket - the #GDatagramBased to wrap
+ * @param certificate - the default server certificate, or %NULL
+ */
 export const dtlsServerConnectionNew = (baseSocket, certificate) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dtls_server_connection_new", [
@@ -1468,6 +2342,14 @@ export const dtlsServerConnectionNew = (baseSocket, certificate) => {
     }
     return getObject(ptr, 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 const fileNewBuildFilenamev = (args) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_build_filenamev", [
         {
@@ -1477,6 +2359,23 @@ export const fileNewBuildFilenamev = (args) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const fileNewForCommandlineArg = (arg) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_commandline_arg", [
         {
@@ -1486,6 +2385,21 @@ export const fileNewForCommandlineArg = (arg) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const fileNewForCommandlineArgAndCwd = (arg, cwd) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_commandline_arg_and_cwd", [
         {
@@ -1499,6 +2413,12 @@ export const fileNewForCommandlineArgAndCwd = (arg, cwd) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const fileNewForPath = (path) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_path", [
         {
@@ -1508,6 +2428,13 @@ export const fileNewForPath = (path) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const fileNewForUri = (uri) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_uri", [
         {
@@ -1517,6 +2444,20 @@ export const fileNewForUri = (uri) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const fileNewTmp = (iostream, tmpl) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_file_new_tmp", [
@@ -1546,6 +2487,19 @@ export const fileNewTmp = (iostream, tmpl) => {
     }
     return getObject(ptr, 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 const fileNewTmpAsync = (ioPriority, tmpl, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_file_new_tmp_async", [
         {
@@ -1574,6 +2528,19 @@ export const fileNewTmpAsync = (ioPriority, tmpl, cancellable, callback, userDat
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const fileNewTmpDirAsync = (ioPriority, tmpl, cancellable, callback, userData) => {
     call("libgio-2.0.so.0", "g_file_new_tmp_dir_async", [
         {
@@ -1602,6 +2569,11 @@ export const fileNewTmpDirAsync = (ioPriority, tmpl, cancellable, callback, user
         },
     ], { type: "undefined" });
 };
+/**
+ * Finishes a temporary directory creation started by
+ * g_file_new_tmp_dir_async().
+ * @param result - a #GAsyncResult
+ */
 export const fileNewTmpDirFinish = (result) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_file_new_tmp_dir_finish", [
@@ -1626,6 +2598,11 @@ export const fileNewTmpDirFinish = (result) => {
     }
     return getObject(ptr, 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 const fileNewTmpFinish = (result, iostream) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_file_new_tmp_finish", [
@@ -1654,6 +2631,13 @@ export const fileNewTmpFinish = (result, iostream) => {
     }
     return getObject(ptr, 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 const fileParseName = (parseName) => {
     const ptr = call("libgio-2.0.so.0", "g_file_parse_name", [
         {
@@ -1663,6 +2647,10 @@ export const fileParseName = (parseName) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, File);
 };
+/**
+ * Deserializes a #GIcon previously serialized using g_icon_serialize().
+ * @param value - a #GVariant created with g_icon_serialize()
+ */
 export const iconDeserialize = (value) => {
     const ptr = call("libgio-2.0.so.0", "g_icon_deserialize", [
         {
@@ -1679,6 +2667,15 @@ export const iconDeserialize = (value) => {
         return null;
     return getObject(ptr, Icon);
 };
+/**
+ * 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 const iconNewForString = (str) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_icon_new_for_string", [
@@ -1703,6 +2700,15 @@ export const iconNewForString = (str) => {
     }
     return getObject(ptr, 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 const initableNewv = (objectType, nParameters, parameters, cancellable) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_initable_newv", [
@@ -1743,6 +2749,28 @@ export const initableNewv = (objectType, nParameters, parameters, cancellable) =
     }
     return getObject(ptr, 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 const ioErrorFromErrno = (errNo) => {
     return call("libgio-2.0.so.0", "g_io_error_from_errno", [
         {
@@ -1751,6 +2779,10 @@ export const ioErrorFromErrno = (errNo) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Converts #GFileError error codes into GIO error codes.
+ * @param fileError - a #GFileError.
+ */
 export const ioErrorFromFileError = (fileError) => {
     return call("libgio-2.0.so.0", "g_io_error_from_file_error", [
         {
@@ -1759,6 +2791,9 @@ export const ioErrorFromFileError = (fileError) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Gets the GIO Error Quark.
+ */
 export const ioErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_io_error_quark", [], {
         type: "int",
@@ -1766,6 +2801,17 @@ export const ioErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * 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 const ioExtensionPointImplement = (extensionPointName, type, extensionName, priority) => {
     return call("libgio-2.0.so.0", "g_io_extension_point_implement", [
         {
@@ -1786,6 +2832,10 @@ export const ioExtensionPointImplement = (extensionPointName, type, extensionNam
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Looks up an existing extension point.
+ * @param name - the name of the extension point
+ */
 export const ioExtensionPointLookup = (name) => {
     return call("libgio-2.0.so.0", "g_io_extension_point_lookup", [
         {
@@ -1794,6 +2844,10 @@ export const ioExtensionPointLookup = (name) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Registers an extension point.
+ * @param name - The name of the extension point
+ */
 export const ioExtensionPointRegister = (name) => {
     return call("libgio-2.0.so.0", "g_io_extension_point_register", [
         {
@@ -1802,6 +2856,14 @@ export const ioExtensionPointRegister = (name) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * 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 const ioModulesLoadAllInDirectory = (dirname) => {
     return call("libgio-2.0.so.0", "g_io_modules_load_all_in_directory", [
         {
@@ -1815,6 +2877,15 @@ export const ioModulesLoadAllInDirectory = (dirname) => {
         borrowed: true,
     });
 };
+/**
+ * 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 const ioModulesLoadAllInDirectoryWithScope = (dirname, scope) => {
     return call("libgio-2.0.so.0", "g_io_modules_load_all_in_directory_with_scope", [
         {
@@ -1832,6 +2903,20 @@ export const ioModulesLoadAllInDirectoryWithScope = (dirname, scope) => {
         borrowed: true,
     });
 };
+/**
+ * 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 const ioModulesScanAllInDirectory = (dirname) => {
     call("libgio-2.0.so.0", "g_io_modules_scan_all_in_directory", [
         {
@@ -1840,6 +2925,21 @@ export const ioModulesScanAllInDirectory = (dirname) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const ioModulesScanAllInDirectoryWithScope = (dirname, scope) => {
     call("libgio-2.0.so.0", "g_io_modules_scan_all_in_directory_with_scope", [
         {
@@ -1852,11 +2952,32 @@ export const ioModulesScanAllInDirectoryWithScope = (dirname, scope) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Cancels all cancellable I/O jobs.
+ *
+ * A job is cancellable if a #GCancellable was passed into
+ * g_io_scheduler_push_job().
+ */
 export const ioSchedulerCancelAllJobs = () => {
     call("libgio-2.0.so.0", "g_io_scheduler_cancel_all_jobs", [], {
         type: "undefined",
     });
 };
+/**
+ * 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 const ioSchedulerPushJob = (jobFunc, ioPriority, userData, notify, cancellable) => {
     call("libgio-2.0.so.0", "g_io_scheduler_push_job", [
         {
@@ -1884,6 +3005,60 @@ export const ioSchedulerPushJob = (jobFunc, ioPriority, userData, notify, cancel
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const keyfileSettingsBackendNew = (filename, rootPath, rootGroup) => {
     const ptr = call("libgio-2.0.so.0", "g_keyfile_settings_backend_new", [
         {
@@ -1902,6 +3077,9 @@ export const keyfileSettingsBackendNew = (filename, rootPath, rootGroup) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, SettingsBackend);
 };
+/**
+ * Gets a reference to the default #GMemoryMonitor for the system.
+ */
 export const memoryMonitorDupDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_memory_monitor_dup_default", [], {
         type: "gobject",
@@ -1909,6 +3087,13 @@ export const memoryMonitorDupDefault = () => {
     });
     return getObject(ptr, 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 const memorySettingsBackendNew = () => {
     const ptr = call("libgio-2.0.so.0", "g_memory_settings_backend_new", [], {
         type: "gobject",
@@ -1916,6 +3101,9 @@ export const memorySettingsBackendNew = () => {
     });
     return getObject(ptr, SettingsBackend);
 };
+/**
+ * Gets the default #GNetworkMonitor for the system.
+ */
 export const networkMonitorGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_network_monitor_get_default", [], {
         type: "gobject",
@@ -1923,9 +3111,21 @@ export const networkMonitorGetDefault = () => {
     });
     return getObject(ptr, 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 const networkingInit = () => {
     call("libgio-2.0.so.0", "g_networking_init", [], { type: "undefined" });
 };
+/**
+ * Creates a readonly #GSettingsBackend.
+ *
+ * This backend does not allow changes to settings, so all settings
+ * will always have their default values.
+ */
 export const nullSettingsBackendNew = () => {
     const ptr = call("libgio-2.0.so.0", "g_null_settings_backend_new", [], {
         type: "gobject",
@@ -1933,6 +3133,14 @@ export const nullSettingsBackendNew = () => {
     });
     return getObject(ptr, 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 const pollableSourceNew = (pollableStream) => {
     const ptr = call("libgio-2.0.so.0", "g_pollable_source_new", [
         {
@@ -1947,6 +3155,15 @@ export const pollableSourceNew = (pollableStream) => {
     });
     return getObject(ptr, 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 const pollableSourceNewFull = (pollableStream, childSource, cancellable) => {
     const ptr = call("libgio-2.0.so.0", "g_pollable_source_new_full", [
         {
@@ -1976,6 +3193,22 @@ export const pollableSourceNewFull = (pollableStream, childSource, cancellable)
     });
     return getObject(ptr, 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 const pollableStreamRead = (stream, buffer, count, blocking, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_pollable_stream_read", [
@@ -2020,6 +3253,23 @@ export const pollableStreamRead = (stream, buffer, count, blocking, cancellable)
     }
     return result;
 };
+/**
+ * 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 const pollableStreamWrite = (stream, buffer, count, blocking, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_pollable_stream_write", [
@@ -2064,6 +3314,32 @@ export const pollableStreamWrite = (stream, buffer, count, blocking, cancellable
     }
     return result;
 };
+/**
+ * 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 const pollableStreamWriteAll = (stream, buffer, count, blocking, bytesWritten, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_pollable_stream_write_all", [
@@ -2115,10 +3391,18 @@ export const pollableStreamWriteAll = (stream, buffer, count, blocking, bytesWri
     }
     return result;
 };
+/**
+ * Gets a reference to the default #GPowerProfileMonitor for the system.
+ */
 export const powerProfileMonitorDupDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_power_profile_monitor_dup_default", [], { type: "gobject", borrowed: true });
     return getObject(ptr, 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 const proxyGetDefaultForProtocol = (protocol) => {
     const ptr = call("libgio-2.0.so.0", "g_proxy_get_default_for_protocol", [
         {
@@ -2130,6 +3414,9 @@ export const proxyGetDefaultForProtocol = (protocol) => {
         return null;
     return getObject(ptr, Proxy);
 };
+/**
+ * Gets the default #GProxyResolver for the system.
+ */
 export const proxyResolverGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_proxy_resolver_get_default", [], {
         type: "gobject",
@@ -2137,6 +3424,9 @@ export const proxyResolverGetDefault = () => {
     });
     return getObject(ptr, ProxyResolver);
 };
+/**
+ * Gets the #GResolver Error Quark.
+ */
 export const resolverErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_resolver_error_quark", [], {
         type: "int",
@@ -2144,6 +3434,9 @@ export const resolverErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Gets the [struct@Gio.Resource] Error Quark.
+ */
 export const resourceErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_resource_error_quark", [], {
         type: "int",
@@ -2151,6 +3444,19 @@ export const resourceErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * 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 const resourceLoad = (filename) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_resource_load", [
@@ -2180,6 +3486,17 @@ export const resourceLoad = (filename) => {
     }
     return getObject(ptr, 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 const resourcesEnumerateChildren = (path, lookupFlags) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_resources_enumerate_children", [
@@ -2208,6 +3525,16 @@ export const resourcesEnumerateChildren = (path, lookupFlags) => {
     }
     return result;
 };
+/**
+ * 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 const resourcesGetInfo = (path, lookupFlags, size, flags) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_resources_get_info", [
@@ -2252,6 +3579,11 @@ export const resourcesGetInfo = (path, lookupFlags, size, flags) => {
     }
     return result;
 };
+/**
+ * Returns whether the specified `path` in the set of
+ * globally registered resources has children.
+ * @param path - A pathname
+ */
 export const resourcesHasChildren = (path) => {
     return call("libgio-2.0.so.0", "g_resources_has_children", [
         {
@@ -2260,6 +3592,24 @@ export const resourcesHasChildren = (path) => {
         },
     ], { type: "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 const resourcesLookupData = (path, lookupFlags) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_resources_lookup_data", [
@@ -2293,6 +3643,15 @@ export const resourcesLookupData = (path, lookupFlags) => {
     }
     return getObject(ptr, 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 const resourcesOpenStream = (path, lookupFlags) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_resources_open_stream", [
@@ -2321,6 +3680,14 @@ export const resourcesOpenStream = (path, lookupFlags) => {
     }
     return getObject(ptr, 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 const resourcesRegister = (resource) => {
     call("libgio-2.0.so.0", "g_resources_register", [
         {
@@ -2334,6 +3701,10 @@ export const resourcesRegister = (resource) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Unregisters the resource from the process-global set of resources.
+ * @param resource - A [struct@Gio.Resource]
+ */
 export const resourcesUnregister = (resource) => {
     call("libgio-2.0.so.0", "g_resources_unregister", [
         {
@@ -2347,6 +3718,21 @@ export const resourcesUnregister = (resource) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * 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 const settingsSchemaSourceGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_settings_schema_source_get_default", [], {
         type: "boxed",
@@ -2358,6 +3744,15 @@ export const settingsSchemaSourceGetDefault = () => {
         return null;
     return getObject(ptr, SettingsSchemaSource);
 };
+/**
+ * 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 const simpleAsyncReportGerrorInIdle = (error, object, callback, userData) => {
     call("libgio-2.0.so.0", "g_simple_async_report_gerror_in_idle", [
         {
@@ -2386,6 +3781,9 @@ export const simpleAsyncReportGerrorInIdle = (error, object, callback, userData)
         },
     ], { type: "undefined" });
 };
+/**
+ * Gets the default #GTlsBackend for the system.
+ */
 export const tlsBackendGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_tls_backend_get_default", [], {
         type: "gobject",
@@ -2393,6 +3791,9 @@ export const tlsBackendGetDefault = () => {
     });
     return getObject(ptr, TlsBackend);
 };
+/**
+ * Gets the TLS channel binding error quark.
+ */
 export const tlsChannelBindingErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_tls_channel_binding_error_quark", [], {
         type: "int",
@@ -2400,6 +3801,17 @@ export const tlsChannelBindingErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * 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 const tlsClientConnectionNew = (baseIoStream, serverIdentity) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_tls_client_connection_new", [
@@ -2429,6 +3841,9 @@ export const tlsClientConnectionNew = (baseIoStream, serverIdentity) => {
     }
     return getObject(ptr, TlsClientConnection);
 };
+/**
+ * Gets the TLS error quark.
+ */
 export const tlsErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_tls_error_quark", [], {
         type: "int",
@@ -2436,6 +3851,13 @@ export const tlsErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * 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 const tlsFileDatabaseNew = (anchors) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_tls_file_database_new", [
@@ -2460,6 +3882,16 @@ export const tlsFileDatabaseNew = (anchors) => {
     }
     return getObject(ptr, 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 const tlsServerConnectionNew = (baseIoStream, certificate) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_tls_server_connection_new", [