@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/mount.js

@@ -4,6 +4,33 @@ import { Drive } from "./drive.js";
 import { File } from "./file.js";
 import { Icon } from "./icon.js";
 import { Volume } from "./volume.js";
+/**
+ * The `GMount` interface represents a user-visible mount, such as a mounted
+ * file system.
+ *
+ * `GMount` is a ‘mounted’ filesystem that you can access. Mounted is in
+ * quotes because it’s not the same as a UNIX mount, it might be a GVFS
+ * mount, but you can still access the files on it if you use GIO.
+ *
+ * A `GMount` might be associated with a [iface@Gio.Volume] (such as a USB flash
+ * drive) which hosts it.
+ *
+ * Unmounting a `GMount` instance is an asynchronous operation. For
+ * more information about asynchronous operations, see [iface@Gio.AsyncResult]
+ * and [class@Gio.Task]. To unmount a `GMount` instance, first call
+ * [method@Gio.Mount.unmount_with_operation] with (at least) the `GMount`
+ * instance and a [type@Gio.AsyncReadyCallback].  The callback will be fired
+ * when the operation has resolved (either with success or failure), and a
+ * [iface@Gio.AsyncResult] structure will be passed to the callback.  That
+ * callback should then call [method@Gio.Mount.unmount_with_operation_finish]
+ * with the `GMount` and the [iface@Gio.AsyncResult] data to see if the
+ * operation was completed successfully.  If an `error` is present when
+ * [method@Gio.Mount.unmount_with_operation_finish] is called, then it will be
+ * filled with any error information.
+ *
+ * Note, when porting from GnomeVFS, `GMount` is the
+ * moral equivalent of `GnomeVFSVolume`.
+ */
 export class Mount {
     ptr;
     constructor(ptr) {
@@ -12,6 +39,9 @@ export class Mount {
     static fromPtr(ptr) {
         return new Mount(ptr);
     }
+    /**
+     * Checks if `mount` can be ejected.
+     */
     canEject() {
         return call("libgio-2.0.so.0", "g_mount_can_eject", [
             {
@@ -20,6 +50,9 @@ export class Mount {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if `mount` can be unmounted.
+     */
     canUnmount() {
         return call("libgio-2.0.so.0", "g_mount_can_unmount", [
             {
@@ -28,6 +61,14 @@ export class Mount {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Ejects a mount. This is an asynchronous operation, and is
+     * finished by calling g_mount_eject_finish() with the `mount` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     eject(flags, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_mount_eject", [
             {
@@ -55,6 +96,11 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes ejecting a mount. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     ejectFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_mount_eject_finish", [
@@ -83,6 +129,15 @@ export class Mount {
         }
         return _result;
     }
+    /**
+     * Ejects a mount. This is an asynchronous operation, and is
+     * finished by calling g_mount_eject_with_operation_finish() with the `mount` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     ejectWithOperation(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_mount_eject_with_operation", [
             {
@@ -115,6 +170,11 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes ejecting a mount. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     ejectWithOperationFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_mount_eject_with_operation_finish", [
@@ -143,6 +203,11 @@ export class Mount {
         }
         return _result;
     }
+    /**
+     * Gets the default location of @mount. The default location of the given
+     * `mount` is a path that reflects the main entry point for the user (e.g.
+     * the home directory, or the root of the volume).
+     */
     getDefaultLocation() {
         const ptr = call("libgio-2.0.so.0", "g_mount_get_default_location", [
             {
@@ -152,6 +217,12 @@ export class Mount {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, File);
     }
+    /**
+     * Gets the drive for the @mount.
+     *
+     * This is a convenience method for getting the #GVolume and then
+     * using that object to get the #GDrive.
+     */
     getDrive() {
         const ptr = call("libgio-2.0.so.0", "g_mount_get_drive", [
             {
@@ -163,6 +234,9 @@ export class Mount {
             return null;
         return getObject(ptr, Drive);
     }
+    /**
+     * Gets the icon for @mount.
+     */
     getIcon() {
         const ptr = call("libgio-2.0.so.0", "g_mount_get_icon", [
             {
@@ -172,6 +246,9 @@ export class Mount {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Icon);
     }
+    /**
+     * Gets the name of @mount.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_mount_get_name", [
             {
@@ -180,6 +257,9 @@ export class Mount {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the root directory on @mount.
+     */
     getRoot() {
         const ptr = call("libgio-2.0.so.0", "g_mount_get_root", [
             {
@@ -189,6 +269,9 @@ export class Mount {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, File);
     }
+    /**
+     * Gets the sort key for @mount, if any.
+     */
     getSortKey() {
         return call("libgio-2.0.so.0", "g_mount_get_sort_key", [
             {
@@ -197,6 +280,9 @@ export class Mount {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the symbolic icon for @mount.
+     */
     getSymbolicIcon() {
         const ptr = call("libgio-2.0.so.0", "g_mount_get_symbolic_icon", [
             {
@@ -206,6 +292,12 @@ export class Mount {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Icon);
     }
+    /**
+     * Gets the UUID for the @mount. The reference is typically based on
+     * the file system UUID for the mount in question and should be
+     * considered an opaque string. Returns %NULL if there is no UUID
+     * available.
+     */
     getUuid() {
         return call("libgio-2.0.so.0", "g_mount_get_uuid", [
             {
@@ -214,6 +306,9 @@ export class Mount {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the volume for the @mount.
+     */
     getVolume() {
         const ptr = call("libgio-2.0.so.0", "g_mount_get_volume", [
             {
@@ -225,6 +320,23 @@ export class Mount {
             return null;
         return getObject(ptr, Volume);
     }
+    /**
+     * Tries to guess the type of content stored on @mount. Returns one or
+     * more textual identifiers of well-known content types (typically
+     * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+     * memory cards. See the
+     * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+     * specification for more on x-content types.
+     *
+     * This is an asynchronous operation (see
+     * g_mount_guess_content_type_sync() for the synchronous version), and
+     * is finished by calling g_mount_guess_content_type_finish() with the
+     * `mount` and #GAsyncResult data returned in the @callback.
+     * @param forceRescan - Whether to force a rescan of the content.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - user data passed to @callback
+     */
     guessContentType(forceRescan, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_mount_guess_content_type", [
             {
@@ -252,6 +364,14 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes guessing content types of @mount. If any errors occurred
+     * during the operation, `error` will be set to contain the errors and
+     * %FALSE will be returned. In particular, you may get an
+     * %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content
+     * guessing.
+     * @param result - a #GAsyncResult
+     */
     guessContentTypeFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_mount_guess_content_type_finish", [
@@ -280,6 +400,19 @@ export class Mount {
         }
         return _result;
     }
+    /**
+     * Tries to guess the type of content stored on @mount. Returns one or
+     * more textual identifiers of well-known content types (typically
+     * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+     * memory cards. See the
+     * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+     * specification for more on x-content types.
+     *
+     * This is a synchronous operation and as such may block doing IO;
+     * see g_mount_guess_content_type() for the asynchronous version.
+     * @param forceRescan - Whether to force a rescan of the content.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     */
     guessContentTypeSync(forceRescan, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_mount_guess_content_type_sync", [
@@ -313,6 +446,31 @@ export class Mount {
         }
         return result;
     }
+    /**
+     * Determines if `mount` is shadowed. Applications or libraries should
+     * avoid displaying `mount` in the user interface if it is shadowed.
+     *
+     * A mount is said to be shadowed if there exists one or more user
+     * visible objects (currently #GMount objects) with a root that is
+     * inside the root of @mount.
+     *
+     * One application of shadow mounts is when exposing a single file
+     * system that is used to address several logical volumes. In this
+     * situation, a #GVolumeMonitor implementation would create two
+     * #GVolume objects (for example, one for the camera functionality of
+     * the device and one for a SD card reader on the device) with
+     * activation URIs `gphoto2://[usb:001,002]/store1/`
+     * and `gphoto2://[usb:001,002]/store2/`. When the
+     * underlying mount (with root
+     * `gphoto2://[usb:001,002]/`) is mounted, said
+     * #GVolumeMonitor implementation would create two #GMount objects
+     * (each with their root matching the corresponding volume activation
+     * root) that would shadow the original mount.
+     *
+     * The proxy monitor in GVfs 2.26 and later, automatically creates and
+     * manage shadow mounts (and shadows the underlying mount) if the
+     * activation root on a #GVolume is set.
+     */
     isShadowed() {
         return call("libgio-2.0.so.0", "g_mount_is_shadowed", [
             {
@@ -321,6 +479,21 @@ export class Mount {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Remounts a mount. This is an asynchronous operation, and is
+     * finished by calling g_mount_remount_finish() with the `mount` and #GAsyncResults data returned in the @callback.
+     *
+     * Remounting is useful when some setting affecting the operation
+     * of the volume has been changed, as these may need a remount to
+     * take affect. While this is semantically equivalent with unmounting
+     * and then remounting not all backends might need to actually be
+     * unmounted.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     remount(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_mount_remount", [
             {
@@ -353,6 +526,11 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes remounting a mount. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     remountFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_mount_remount_finish", [
@@ -381,6 +559,12 @@ export class Mount {
         }
         return _result;
     }
+    /**
+     * Increments the shadow count on @mount. Usually used by
+     * #GVolumeMonitor implementations when creating a shadow mount for
+     * @mount, see g_mount_is_shadowed() for more information. The caller
+     * will need to emit the #GMount::changed signal on `mount` manually.
+     */
     shadow() {
         call("libgio-2.0.so.0", "g_mount_shadow", [
             {
@@ -389,6 +573,14 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unmounts a mount. This is an asynchronous operation, and is
+     * finished by calling g_mount_unmount_finish() with the `mount` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the operation
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     unmount(flags, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_mount_unmount", [
             {
@@ -416,6 +608,11 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes unmounting a mount. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     unmountFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_mount_unmount_finish", [
@@ -444,6 +641,15 @@ export class Mount {
         }
         return _result;
     }
+    /**
+     * Unmounts a mount. This is an asynchronous operation, and is
+     * finished by calling g_mount_unmount_with_operation_finish() with the `mount` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     unmountWithOperation(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_mount_unmount_with_operation", [
             {
@@ -476,6 +682,11 @@ export class Mount {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes unmounting a mount. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     unmountWithOperationFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_mount_unmount_with_operation_finish", [
@@ -504,6 +715,12 @@ export class Mount {
         }
         return _result;
     }
+    /**
+     * Decrements the shadow count on @mount. Usually used by
+     * #GVolumeMonitor implementations when destroying a shadow mount for
+     * @mount, see g_mount_is_shadowed() for more information. The caller
+     * will need to emit the #GMount::changed signal on `mount` manually.
+     */
     unshadow() {
         call("libgio-2.0.so.0", "g_mount_unshadow", [
             {

package/dist/generated/gio/native-socket-address.d.ts

@@ -1,5 +1,16 @@
 import { SocketAddress } from "./socket-address.js";
+/**
+ * A socket address of some unknown native type.
+ *
+ * This corresponds to a general `struct sockaddr` of a type not otherwise
+ * handled by GLib.
+ */
 export declare class NativeSocketAddress extends SocketAddress {
+    /**
+     * Creates a new #GNativeSocketAddress for `native` and @len.
+     * @param native - a native address object
+     * @param len - the length of @native, in bytes
+     */
     constructor(len: number, native?: number | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gio/native-socket-address.js

@@ -1,5 +1,11 @@
 import { call } from "@gtkx/native";
 import { SocketAddress } from "./socket-address.js";
+/**
+ * A socket address of some unknown native type.
+ *
+ * This corresponds to a general `struct sockaddr` of a type not otherwise
+ * handled by GLib.
+ */
 export class NativeSocketAddress extends SocketAddress {
     constructor(...args) {
         super(...args);

package/dist/generated/gio/network-address.d.ts

@@ -1,17 +1,122 @@
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GNetworkAddress` provides an easy way to resolve a hostname and
+ * then attempt to connect to that host, handling the possibility of
+ * multiple IP addresses and multiple address families.
+ *
+ * The enumeration results of resolved addresses *may* be cached as long
+ * as this object is kept alive which may have unexpected results if
+ * alive for too long.
+ *
+ * See [iface@Gio.SocketConnectable] for an example of using the connectable
+ * interface.
+ */
 export declare class NetworkAddress extends GObject.GObject {
+    /**
+     * Creates a new #GSocketConnectable for connecting to the given
+     * `hostname` and @port.
+     *
+     * Note that depending on the configuration of the machine, a
+     * `hostname` of `localhost` may refer to the IPv4 loopback address
+     * only, or to both IPv4 and IPv6; use
+     * g_network_address_new_loopback() to create a #GNetworkAddress that
+     * is guaranteed to resolve to both addresses.
+     * @param hostname - the hostname
+     * @param port - the port
+     */
     constructor(hostname: string, port: number);
     constructor(...args: unknown[]);
+    /**
+     * Creates a new #GSocketConnectable for connecting to the local host
+     * over a loopback connection to the given @port. This is intended for
+     * use in connecting to local services which may be running on IPv4 or
+     * IPv6.
+     *
+     * The connectable will return IPv4 and IPv6 loopback addresses,
+     * regardless of how the host resolves `localhost`. By contrast,
+     * g_network_address_new() will often only return an IPv4 address when
+     * resolving `localhost`, and an IPv6 address for `localhost6`.
+     *
+     * g_network_address_get_hostname() will always return `localhost` for
+     * a #GNetworkAddress created with this constructor.
+     * @param port - the port
+     */
     static addressNewLoopback(port: number): NetworkAddress;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Creates a new #GSocketConnectable for connecting to the given
+     * `hostname` and @port. May fail and return %NULL in case
+     * parsing `host_and_port` fails.
+     *
+     * `host_and_port` may be in any of a number of recognised formats; an IPv6
+     * address, an IPv4 address, or a domain name (in which case a DNS
+     * lookup is performed). Quoting with [] is supported for all address
+     * types. A port override may be specified in the usual way with a
+     * colon.
+     *
+     * If no port is specified in `host_and_port` then `default_port` will be
+     * used as the port number to connect to.
+     *
+     * In general, `host_and_port` is expected to be provided by the user
+     * (allowing them to give the hostname, and a port override if necessary)
+     * and `default_port` is expected to be provided by the application.
+     *
+     * (The port component of `host_and_port` can also be specified as a
+     * service name rather than as a numeric port, but this functionality
+     * is deprecated, because it depends on the contents of /etc/services,
+     * which is generally quite sparse on platforms other than Linux.)
+     * @param hostAndPort - the hostname and optionally a port
+     * @param defaultPort - the default port if not in @host_and_port
+     */
     static parse(hostAndPort: string, defaultPort: number): NetworkAddress;
+    /**
+     * Creates a new #GSocketConnectable for connecting to the given
+     * @uri. May fail and return %NULL in case parsing `uri` fails.
+     *
+     * Using this rather than g_network_address_new() or
+     * g_network_address_parse() allows #GSocketClient to determine
+     * when to use application-specific proxy protocols.
+     * @param uri - the hostname and optionally a port
+     * @param defaultPort - The default port if none is found in the URI
+     */
     static parseUri(uri: string, defaultPort: number): NetworkAddress;
+    /**
+     * Gets @addr's hostname. This might be either UTF-8 or ASCII-encoded,
+     * depending on what `addr` was created with.
+     */
     getHostname(): string;
+    /**
+     * Gets @addr's port number
+     */
     getPort(): number;
+    /**
+     * Gets @addr's scheme
+     */
     getScheme(): string | null;
+    /**
+     * Creates a #GSocketAddressEnumerator for @connectable.
+     */
     enumerate(): SocketAddressEnumerator;
+    /**
+     * Creates a #GSocketAddressEnumerator for `connectable` that will
+     * return a #GProxyAddress for each of its addresses that you must connect
+     * to via a proxy.
+     *
+     * If `connectable` does not implement
+     * g_socket_connectable_proxy_enumerate(), this will fall back to
+     * calling g_socket_connectable_enumerate().
+     */
     proxyEnumerate(): SocketAddressEnumerator;
+    /**
+     * Format a #GSocketConnectable as a string. This is a human-readable format for
+     * use in debugging output, and is not a stable serialization format. It is not
+     * suitable for use in user interfaces as it exposes too much information for a
+     * user.
+     *
+     * If the #GSocketConnectable implementation does not support string formatting,
+     * the implementation’s type name will be returned as a fallback.
+     */
     toString(): string;
     connect(signal: "notify", handler: (self: NetworkAddress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;