@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -6,27 +6,191 @@ import { File } from "./file.js";
 import { Icon } from "./icon.js";
 import { Mount } from "./mount.js";
 import { MountOperation } from "./mount-operation.js";
+/**
+ * The `GVolume` interface represents user-visible objects that can be
+ * mounted. For example, a file system partition on a USB flash drive, or an
+ * optical disc inserted into a disc drive.
+ *
+ * If a `GVolume` is currently mounted, the corresponding [iface@Gio.Mount] can
+ * be retrieved using [method@Gio.Volume.get_mount].
+ *
+ * Mounting a `GVolume` instance is an asynchronous operation. For more
+ * information about asynchronous operations, see [iface@Gio.AsyncResult] and
+ * [class@Gio.Task]. To mount a `GVolume`, first call [method@Gio.Volume.mount]
+ * with (at least) the `GVolume` instance, optionally a
+ * [class@Gio.MountOperation] object and a [type@Gio.AsyncReadyCallback].
+ *
+ * Typically, one will only want to pass `NULL` for the
+ * [class@Gio.MountOperation] if automounting all volumes when a desktop session
+ * starts since it’s not desirable to put up a lot of dialogs asking
+ * for credentials.
+ *
+ * The callback will be fired when the operation has resolved (either
+ * with success or failure), and a [iface@Gio.AsyncResult] instance will be
+ * passed to the callback.  That callback should then call
+ * [method@Gio.Volume.mount_finish] with the `GVolume` instance and the
+ * [iface@Gio.AsyncResult] data to see if the operation was completed
+ * successfully.  If a [type@GLib.Error] is present when
+ * [method@Gio.Volume.mount_finish] is called, then it will be filled with any
+ * error information.
+ *
+ * Note, when porting from GnomeVFS,
+ * `GVolume` is the moral equivalent of `GnomeVFSDrive`.
+ *
+ * ## Volume Identifiers
+ *
+ * It is sometimes necessary to directly access the underlying
+ * operating system object behind a volume (e.g. for passing a volume
+ * to an application via the command line). For this purpose, GIO
+ * allows to obtain an ‘identifier’ for the volume. There can be
+ * different kinds of identifiers, such as Hal UDIs, filesystem labels,
+ * traditional Unix devices (e.g. `/dev/sda2`), UUIDs. GIO uses predefined
+ * strings as names for the different kinds of identifiers:
+ * `G_VOLUME_IDENTIFIER_KIND_UUID`, `G_VOLUME_IDENTIFIER_KIND_LABEL`, etc.
+ * Use [method@Gio.Volume.get_identifier] to obtain an identifier for a volume.
+ *
+ * Note that `G_VOLUME_IDENTIFIER_KIND_HAL_UDI` will only be available
+ * when the GVFS hal volume monitor is in use. Other volume monitors
+ * will generally be able to provide the `G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE`
+ * identifier, which can be used to obtain a hal device by means of
+ * `libhal_manager_find_device_string_match()`.
+ */
 export declare class Volume {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Volume;
+    /**
+     * Checks if a volume can be ejected.
+     */
     canEject(): boolean;
+    /**
+     * Checks if a volume can be mounted.
+     */
     canMount(): boolean;
+    /**
+     * Ejects a volume. This is an asynchronous operation, and is
+     * finished by calling g_volume_eject_finish() with the `volume` and #GAsyncResult 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 that gets passed to @callback
+     */
     eject(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes ejecting a volume. 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: AsyncResult): boolean;
+    /**
+     * Ejects a volume. This is an asynchronous operation, and is
+     * finished by calling g_volume_eject_with_operation_finish() with the `volume` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param mountOperation - a #GMountOperation or %NULL to
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback, or %NULL
+     * @param userData - user data passed to @callback
+     */
     ejectWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes ejecting a volume. 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: AsyncResult): boolean;
+    /**
+     * Gets the kinds of [identifiers](#volume-identifiers) that `volume` has.
+     * Use g_volume_get_identifier() to obtain the identifiers themselves.
+     */
     enumerateIdentifiers(): string[];
+    /**
+     * Gets the activation root for a #GVolume if it is known ahead of
+     * mount time. Returns %NULL otherwise. If not %NULL and if `volume` is mounted, then the result of g_mount_get_root() on the
+     * #GMount object obtained from g_volume_get_mount() will always
+     * either be equal or a prefix of what this function returns. In
+     * other words, in code
+     *
+     * |[<!-- language="C" -->
+     * GMount *mount;
+     * GFile *mount_root
+     * GFile *volume_activation_root;
+     *
+     * mount = g_volume_get_mount (volume); // mounted, so never NULL
+     * mount_root = g_mount_get_root (mount);
+     * volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL
+     * ]|
+     * then the expression
+     * |[<!-- language="C" -->
+     * (g_file_has_prefix (volume_activation_root, mount_root) ||
+     * g_file_equal (volume_activation_root, mount_root))
+     * ]|
+     * will always be %TRUE.
+     *
+     * Activation roots are typically used in #GVolumeMonitor
+     * implementations to find the underlying mount to shadow, see
+     * g_mount_is_shadowed() for more details.
+     */
     getActivationRoot(): File | null;
+    /**
+     * Gets the drive for the @volume.
+     */
     getDrive(): Drive | null;
+    /**
+     * Gets the icon for @volume.
+     */
     getIcon(): Icon;
+    /**
+     * Gets the identifier of the given kind for @volume.
+     * See the [introduction](#volume-identifiers) for more
+     * information about volume identifiers.
+     * @param kind - the kind of identifier to return
+     */
     getIdentifier(kind: string): string | null;
+    /**
+     * Gets the mount for the @volume.
+     */
     getMount(): Mount | null;
+    /**
+     * Gets the name of @volume.
+     */
     getName(): string;
+    /**
+     * Gets the sort key for @volume, if any.
+     */
     getSortKey(): string | null;
+    /**
+     * Gets the symbolic icon for @volume.
+     */
     getSymbolicIcon(): Icon;
+    /**
+     * Gets the UUID for the @volume. The reference is typically based on
+     * the file system UUID for the volume in question and should be
+     * considered an opaque string. Returns %NULL if there is no UUID
+     * available.
+     */
     getUuid(): string | null;
+    /**
+     * Mounts a volume. This is an asynchronous operation, and is
+     * finished by calling g_volume_mount_finish() with the `volume` and #GAsyncResult returned in the @callback.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation or %NULL to avoid user interaction
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback, or %NULL
+     * @param userData - user data that gets passed to @callback
+     */
     mount(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes mounting a volume. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     *
+     * If the mount operation succeeded, g_volume_get_mount() on `volume` is guaranteed to return the mount right after calling this
+     * function; there's no need to listen for the 'mount-added' signal on
+     * #GVolumeMonitor.
+     * @param result - a #GAsyncResult
+     */
     mountFinish(result: AsyncResult): boolean;
+    /**
+     * Returns whether the volume should be automatically mounted.
+     */
     shouldAutomount(): boolean;
 }

package/dist/generated/gio/volume.js

@@ -4,6 +4,55 @@ import { Drive } from "./drive.js";
 import { File } from "./file.js";
 import { Icon } from "./icon.js";
 import { Mount } from "./mount.js";
+/**
+ * The `GVolume` interface represents user-visible objects that can be
+ * mounted. For example, a file system partition on a USB flash drive, or an
+ * optical disc inserted into a disc drive.
+ *
+ * If a `GVolume` is currently mounted, the corresponding [iface@Gio.Mount] can
+ * be retrieved using [method@Gio.Volume.get_mount].
+ *
+ * Mounting a `GVolume` instance is an asynchronous operation. For more
+ * information about asynchronous operations, see [iface@Gio.AsyncResult] and
+ * [class@Gio.Task]. To mount a `GVolume`, first call [method@Gio.Volume.mount]
+ * with (at least) the `GVolume` instance, optionally a
+ * [class@Gio.MountOperation] object and a [type@Gio.AsyncReadyCallback].
+ *
+ * Typically, one will only want to pass `NULL` for the
+ * [class@Gio.MountOperation] if automounting all volumes when a desktop session
+ * starts since it’s not desirable to put up a lot of dialogs asking
+ * for credentials.
+ *
+ * The callback will be fired when the operation has resolved (either
+ * with success or failure), and a [iface@Gio.AsyncResult] instance will be
+ * passed to the callback.  That callback should then call
+ * [method@Gio.Volume.mount_finish] with the `GVolume` instance and the
+ * [iface@Gio.AsyncResult] data to see if the operation was completed
+ * successfully.  If a [type@GLib.Error] is present when
+ * [method@Gio.Volume.mount_finish] is called, then it will be filled with any
+ * error information.
+ *
+ * Note, when porting from GnomeVFS,
+ * `GVolume` is the moral equivalent of `GnomeVFSDrive`.
+ *
+ * ## Volume Identifiers
+ *
+ * It is sometimes necessary to directly access the underlying
+ * operating system object behind a volume (e.g. for passing a volume
+ * to an application via the command line). For this purpose, GIO
+ * allows to obtain an ‘identifier’ for the volume. There can be
+ * different kinds of identifiers, such as Hal UDIs, filesystem labels,
+ * traditional Unix devices (e.g. `/dev/sda2`), UUIDs. GIO uses predefined
+ * strings as names for the different kinds of identifiers:
+ * `G_VOLUME_IDENTIFIER_KIND_UUID`, `G_VOLUME_IDENTIFIER_KIND_LABEL`, etc.
+ * Use [method@Gio.Volume.get_identifier] to obtain an identifier for a volume.
+ *
+ * Note that `G_VOLUME_IDENTIFIER_KIND_HAL_UDI` will only be available
+ * when the GVFS hal volume monitor is in use. Other volume monitors
+ * will generally be able to provide the `G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE`
+ * identifier, which can be used to obtain a hal device by means of
+ * `libhal_manager_find_device_string_match()`.
+ */
 export class Volume {
     ptr;
     constructor(ptr) {
@@ -12,6 +61,9 @@ export class Volume {
     static fromPtr(ptr) {
         return new Volume(ptr);
     }
+    /**
+     * Checks if a volume can be ejected.
+     */
     canEject() {
         return call("libgio-2.0.so.0", "g_volume_can_eject", [
             {
@@ -20,6 +72,9 @@ export class Volume {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a volume can be mounted.
+     */
     canMount() {
         return call("libgio-2.0.so.0", "g_volume_can_mount", [
             {
@@ -28,6 +83,14 @@ export class Volume {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Ejects a volume. This is an asynchronous operation, and is
+     * finished by calling g_volume_eject_finish() with the `volume` and #GAsyncResult 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 that gets passed to @callback
+     */
     eject(flags, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_volume_eject", [
             {
@@ -55,6 +118,11 @@ export class Volume {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes ejecting a volume. 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_volume_eject_finish", [
@@ -83,6 +151,15 @@ export class Volume {
         }
         return _result;
     }
+    /**
+     * Ejects a volume. This is an asynchronous operation, and is
+     * finished by calling g_volume_eject_with_operation_finish() with the `volume` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param mountOperation - a #GMountOperation or %NULL to
+     * @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_volume_eject_with_operation", [
             {
@@ -115,6 +192,11 @@ export class Volume {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes ejecting a volume. 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_volume_eject_with_operation_finish", [
@@ -143,6 +225,10 @@ export class Volume {
         }
         return _result;
     }
+    /**
+     * Gets the kinds of [identifiers](#volume-identifiers) that `volume` has.
+     * Use g_volume_get_identifier() to obtain the identifiers themselves.
+     */
     enumerateIdentifiers() {
         return call("libgio-2.0.so.0", "g_volume_enumerate_identifiers", [
             {
@@ -151,6 +237,33 @@ export class Volume {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Gets the activation root for a #GVolume if it is known ahead of
+     * mount time. Returns %NULL otherwise. If not %NULL and if `volume` is mounted, then the result of g_mount_get_root() on the
+     * #GMount object obtained from g_volume_get_mount() will always
+     * either be equal or a prefix of what this function returns. In
+     * other words, in code
+     *
+     * |[<!-- language="C" -->
+     * GMount *mount;
+     * GFile *mount_root
+     * GFile *volume_activation_root;
+     *
+     * mount = g_volume_get_mount (volume); // mounted, so never NULL
+     * mount_root = g_mount_get_root (mount);
+     * volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL
+     * ]|
+     * then the expression
+     * |[<!-- language="C" -->
+     * (g_file_has_prefix (volume_activation_root, mount_root) ||
+     * g_file_equal (volume_activation_root, mount_root))
+     * ]|
+     * will always be %TRUE.
+     *
+     * Activation roots are typically used in #GVolumeMonitor
+     * implementations to find the underlying mount to shadow, see
+     * g_mount_is_shadowed() for more details.
+     */
     getActivationRoot() {
         const ptr = call("libgio-2.0.so.0", "g_volume_get_activation_root", [
             {
@@ -162,6 +275,9 @@ export class Volume {
             return null;
         return getObject(ptr, File);
     }
+    /**
+     * Gets the drive for the @volume.
+     */
     getDrive() {
         const ptr = call("libgio-2.0.so.0", "g_volume_get_drive", [
             {
@@ -173,6 +289,9 @@ export class Volume {
             return null;
         return getObject(ptr, Drive);
     }
+    /**
+     * Gets the icon for @volume.
+     */
     getIcon() {
         const ptr = call("libgio-2.0.so.0", "g_volume_get_icon", [
             {
@@ -182,6 +301,12 @@ export class Volume {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Icon);
     }
+    /**
+     * Gets the identifier of the given kind for @volume.
+     * See the [introduction](#volume-identifiers) for more
+     * information about volume identifiers.
+     * @param kind - the kind of identifier to return
+     */
     getIdentifier(kind) {
         return call("libgio-2.0.so.0", "g_volume_get_identifier", [
             {
@@ -194,6 +319,9 @@ export class Volume {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the mount for the @volume.
+     */
     getMount() {
         const ptr = call("libgio-2.0.so.0", "g_volume_get_mount", [
             {
@@ -205,6 +333,9 @@ export class Volume {
             return null;
         return getObject(ptr, Mount);
     }
+    /**
+     * Gets the name of @volume.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_volume_get_name", [
             {
@@ -213,6 +344,9 @@ export class Volume {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the sort key for @volume, if any.
+     */
     getSortKey() {
         return call("libgio-2.0.so.0", "g_volume_get_sort_key", [
             {
@@ -221,6 +355,9 @@ export class Volume {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the symbolic icon for @volume.
+     */
     getSymbolicIcon() {
         const ptr = call("libgio-2.0.so.0", "g_volume_get_symbolic_icon", [
             {
@@ -230,6 +367,12 @@ export class Volume {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Icon);
     }
+    /**
+     * Gets the UUID for the @volume. The reference is typically based on
+     * the file system UUID for the volume 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_volume_get_uuid", [
             {
@@ -238,6 +381,15 @@ export class Volume {
             },
         ], { type: "string" });
     }
+    /**
+     * Mounts a volume. This is an asynchronous operation, and is
+     * finished by calling g_volume_mount_finish() with the `volume` and #GAsyncResult returned in the @callback.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation or %NULL to avoid user interaction
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback, or %NULL
+     * @param userData - user data that gets passed to @callback
+     */
     mount(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_volume_mount", [
             {
@@ -270,6 +422,15 @@ export class Volume {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes mounting a volume. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     *
+     * If the mount operation succeeded, g_volume_get_mount() on `volume` is guaranteed to return the mount right after calling this
+     * function; there's no need to listen for the 'mount-added' signal on
+     * #GVolumeMonitor.
+     * @param result - a #GAsyncResult
+     */
     mountFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_volume_mount_finish", [
@@ -298,6 +459,9 @@ export class Volume {
         }
         return _result;
     }
+    /**
+     * Returns whether the volume should be automatically mounted.
+     */
     shouldAutomount() {
         return call("libgio-2.0.so.0", "g_volume_should_automount", [
             {

package/dist/generated/gio/zlib-compressor.d.ts

@@ -3,16 +3,147 @@ import { ConverterFlags, ConverterResult, ZlibCompressorFormat } from "./enums.j
 import { FileInfo } from "./file-info.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GZlibCompressor` is an implementation of [iface@Gio.Converter] that
+ * compresses data using zlib.
+ */
 export declare class ZlibCompressor extends GObject.GObject {
+    /**
+     * Creates a compressor.
+     * @param format - the format to use for the compressed data
+     * @param level - compression level (`0`-`9`), `-1` for default
+     */
     constructor(format: ZlibCompressorFormat, level: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the [property@Gio.ZlibCompressor:file-info] property.
+     */
     getFileInfo(): FileInfo | null;
+    /**
+     * Gets the [property@Gio.ZlibCompressor:os] property.
+     */
     getOs(): number;
+    /**
+     * Sets the [property@Gio.ZlibCompressor:file-info] property.
+     *
+     * Note: it is an error to call this function while a compression is in
+     * progress; it may only be called immediately after creation of @compressor,
+     * or after resetting it with [method@Gio.Converter.reset].
+     * @param fileInfo - file info for the gzip header
+     */
     setFileInfo(fileInfo?: FileInfo | null): void;
+    /**
+     * Sets the [property@Gio.ZlibCompressor:os] property.
+     *
+     * Note: it is an error to call this function while a compression is in
+     * progress; it may only be called immediately after creation of @compressor,
+     * or after resetting it with [method@Gio.Converter.reset].
+     * @param os - the OS code to use, or `-1` to unset
+     */
     setOs(os: number): void;
+    /**
+     * This is the main operation used when converting data. It is to be called
+     * multiple times in a loop, and each time it will do some work, i.e.
+     * producing some output (in @outbuf) or consuming some input (from @inbuf) or
+     * both. If its not possible to do any work an error is returned.
+     *
+     * Note that a single call may not consume all input (or any input at all).
+     * Also a call may produce output even if given no input, due to state stored
+     * in the converter producing output.
+     *
+     * If any data was either produced or consumed, and then an error happens, then
+     * only the successful conversion is reported and the error is returned on the
+     * next call.
+     *
+     * A full conversion loop involves calling this method repeatedly, each time
+     * giving it new input and space output space. When there is no more input
+     * data after the data in @inbuf, the flag %G_CONVERTER_INPUT_AT_END must be set.
+     * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+     * each time until all data is consumed and all output is produced, then
+     * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+     * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+     * in a decompression converter where the end of data is detectable from the
+     * data (and there might even be other data after the end of the compressed data).
+     *
+     * When some data has successfully been converted `bytes_read` and is set to
+     * the number of bytes read from @inbuf, and `bytes_written` is set to indicate
+     * how many bytes was written to @outbuf. If there are more data to output
+     * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+     * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+     * then %G_CONVERTER_FINISHED is returned.
+     *
+     * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+     * Some errors need special handling:
+     *
+     * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+     * to write the resulting converted data, the application should
+     * call the function again with a larger `outbuf` to continue.
+     *
+     * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+     * input to fully determine what the conversion should produce,
+     * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+     * example with an incomplete multibyte sequence when converting text,
+     * or when a regexp matches up to the end of the input (and may match
+     * further input). It may also happen when `inbuf_size` is zero and
+     * there is no more data to produce.
+     *
+     * When this happens the application should read more input and then
+     * call the function again. If further input shows that there is no
+     * more data call the function again with the same data but with
+     * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+     * to finish as e.g. in the regexp match case (or, to fail again with
+     * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+     * input is actually partial).
+     *
+     * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+     * converter object is in an invalid state where its not allowed
+     * to call g_converter_convert() anymore. At this time you can only
+     * free the object or call g_converter_reset() to reset it to the
+     * initial state.
+     *
+     * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+     * to try to write out all internal state to the output. The application
+     * has to call the function multiple times with the flag set, and when
+     * the available input has been consumed and all internal state has
+     * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+     * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+     * This is somewhat similar to what happens at the end of the input stream,
+     * but done in the middle of the data.
+     *
+     * This has different meanings for different conversions. For instance
+     * in a compression converter it would mean that we flush all the
+     * compression state into output such that if you uncompress the
+     * compressed data you get back all the input data. Doing this may
+     * make the final file larger due to padding though. Another example
+     * is a regexp conversion, where if you at the end of the flushed data
+     * have a match, but there is also a potential longer match. In the
+     * non-flushed case we would ask for more input, but when flushing we
+     * treat this as the end of input and do the match.
+     *
+     * Flushing is not always possible (like if a charset converter flushes
+     * at a partial multibyte sequence). Converters are supposed to try
+     * to produce as much output as possible and then return an error
+     * (typically %G_IO_ERROR_PARTIAL_INPUT).
+     * @param inbuf - the buffer
+     * @param inbufSize - the number of bytes in @inbuf
+     * @param outbuf - a
+     * @param outbufSize - the number of bytes in @outbuf, must be at least one
+     * @param flags - a #GConverterFlags controlling the conversion details
+     * @param bytesRead - will be set to the number of bytes read
+     * @param bytesWritten - will be set to the number of bytes
+     */
     convert(inbuf: number[], inbufSize: number, outbuf: number[], outbufSize: number, flags: ConverterFlags, bytesRead: Ref<number>, bytesWritten: Ref<number>): ConverterResult;
+    /**
+     * Applies `converter` to the data in @bytes.
+     * @param bytes - the data to convert
+     */
     convertBytes(bytes: GLib.Bytes): GLib.Bytes;
+    /**
+     * Resets all internal state in the converter, making it behave
+     * as if it was just created. If the converter has any internal
+     * state that would produce output then that output is lost.
+     */
     reset(): void;
     connect(signal: "notify", handler: (self: ZlibCompressor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;