@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gio/file-input-stream.d.ts

@@ -3,15 +3,99 @@ import { Cancellable } from "./cancellable.js";
 import { FileInfo } from "./file-info.js";
 import * as GLib from "../glib/index.js";
 import { InputStream } from "./input-stream.js";
+/**
+ * `GFileInputStream` provides input streams that take their
+ * content from a file.
+ *
+ * `GFileInputStream` implements [iface@Gio.Seekable], which allows the input
+ * stream to jump to arbitrary positions in the file, provided the
+ * filesystem of the file allows it. To find the position of a file
+ * input stream, use [method@Gio.Seekable.tell]. To find out if a file input
+ * stream supports seeking, use [vfunc@Gio.Seekable.can_seek].
+ * To position a file input stream, use [vfunc@Gio.Seekable.seek].
+ */
 export declare class FileInputStream extends InputStream {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Queries a file input stream the given @attributes. This function blocks
+     * while querying the stream. For the asynchronous (non-blocking) version
+     * of this function, see g_file_input_stream_query_info_async(). While the
+     * stream is blocked, the stream will set the pending flag internally, and
+     * any other operations on the stream will fail with %G_IO_ERROR_PENDING.
+     * @param attributes - a file attribute query string.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     queryInfo(attributes: string, cancellable?: Cancellable | null): FileInfo;
+    /**
+     * Queries the stream information asynchronously.
+     * When the operation is finished `callback` will be called.
+     * You can then call g_file_input_stream_query_info_finish()
+     * to get the result of the operation.
+     *
+     * For the synchronous version of this function,
+     * see g_file_input_stream_query_info().
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
+     * @param attributes - a file attribute query string.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     queryInfoAsync(attributes: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous info query operation.
+     * @param result - a #GAsyncResult.
+     */
     queryInfoFinish(result: AsyncResult): FileInfo;
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek(): boolean;
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate(): boolean;
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+    /**
+     * Tells the current position within the stream.
+     */
     tell(): number;
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
 }

package/dist/generated/gio/file-input-stream.js

@@ -2,6 +2,17 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { FileInfo } from "./file-info.js";
 import { InputStream } from "./input-stream.js";
+/**
+ * `GFileInputStream` provides input streams that take their
+ * content from a file.
+ *
+ * `GFileInputStream` implements [iface@Gio.Seekable], which allows the input
+ * stream to jump to arbitrary positions in the file, provided the
+ * filesystem of the file allows it. To find the position of a file
+ * input stream, use [method@Gio.Seekable.tell]. To find out if a file input
+ * stream supports seeking, use [vfunc@Gio.Seekable.can_seek].
+ * To position a file input stream, use [vfunc@Gio.Seekable.seek].
+ */
 export class FileInputStream extends InputStream {
     constructor(...args) {
         super(...args);
@@ -17,6 +28,15 @@ export class FileInputStream extends InputStream {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Queries a file input stream the given @attributes. This function blocks
+     * while querying the stream. For the asynchronous (non-blocking) version
+     * of this function, see g_file_input_stream_query_info_async(). While the
+     * stream is blocked, the stream will set the pending flag internally, and
+     * any other operations on the stream will fail with %G_IO_ERROR_PENDING.
+     * @param attributes - a file attribute query string.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     queryInfo(attributes, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_file_input_stream_query_info", [
@@ -50,6 +70,24 @@ export class FileInputStream extends InputStream {
         }
         return getObject(ptr, FileInfo);
     }
+    /**
+     * Queries the stream information asynchronously.
+     * When the operation is finished `callback` will be called.
+     * You can then call g_file_input_stream_query_info_finish()
+     * to get the result of the operation.
+     *
+     * For the synchronous version of this function,
+     * see g_file_input_stream_query_info().
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
+     * @param attributes - a file attribute query string.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     queryInfoAsync(attributes, ioPriority, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_file_input_stream_query_info_async", [
             {
@@ -81,6 +119,10 @@ export class FileInputStream extends InputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an asynchronous info query operation.
+     * @param result - a #GAsyncResult.
+     */
     queryInfoFinish(result) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_file_input_stream_query_info_finish", [
@@ -109,6 +151,9 @@ export class FileInputStream extends InputStream {
         }
         return getObject(ptr, FileInfo);
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -117,6 +162,10 @@ export class FileInputStream extends InputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate() {
         return call("libgio-2.0.so.0", "g_seekable_can_truncate", [
             {
@@ -125,6 +174,25 @@ export class FileInputStream extends InputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset, type, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_seek", [
@@ -162,6 +230,9 @@ export class FileInputStream extends InputStream {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -170,6 +241,19 @@ export class FileInputStream extends InputStream {
             },
         ], { type: "int", size: 64, unsigned: false });
     }
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_truncate", [

package/dist/generated/gio/file-iostream.d.ts

@@ -3,16 +3,123 @@ import { Cancellable } from "./cancellable.js";
 import { FileInfo } from "./file-info.js";
 import * as GLib from "../glib/index.js";
 import { IOStream } from "./iostream.js";
+/**
+ * `GFileIOStream` provides I/O streams that both read and write to the same
+ * file handle.
+ *
+ * `GFileIOStream` implements [iface@Gio.Seekable], which allows the I/O
+ * stream to jump to arbitrary positions in the file and to truncate
+ * the file, provided the filesystem of the file supports these
+ * operations.
+ *
+ * To find the position of a file I/O stream, use [method@Gio.Seekable.tell].
+ *
+ * To find out if a file I/O stream supports seeking, use
+ * [method@Gio.Seekable.can_seek]. To position a file I/O stream, use
+ * [method@Gio.Seekable.seek]. To find out if a file I/O stream supports
+ * truncating, use [method@Gio.Seekable.can_truncate]. To truncate a file I/O
+ * stream, use [method@Gio.Seekable.truncate].
+ *
+ * The default implementation of all the `GFileIOStream` operations
+ * and the implementation of [iface@Gio.Seekable] just call into the same
+ * operations on the output stream.
+ */
 export declare class FileIOStream extends IOStream {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the entity tag for the file when it has been written.
+     * This must be called after the stream has been written
+     * and closed, as the etag can change while writing.
+     */
     getEtag(): string | null;
+    /**
+     * Queries a file io stream for the given @attributes.
+     * This function blocks while querying the stream. For the asynchronous
+     * version of this function, see g_file_io_stream_query_info_async().
+     * While the stream is blocked, the stream will set the pending flag
+     * internally, and any other operations on the stream will fail with
+     * %G_IO_ERROR_PENDING.
+     *
+     * Can fail if the stream was already closed (with `error` being set to
+     * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
+     * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
+     * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). I
+     * all cases of failure, %NULL will be returned.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
+     * be returned.
+     * @param attributes - a file attribute query string.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     queryInfo(attributes: string, cancellable?: Cancellable | null): FileInfo;
+    /**
+     * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+     * `callback` will be called with a #GAsyncResult which can be used to
+     * finish the operation with g_file_io_stream_query_info_finish().
+     *
+     * For the synchronous version of this function, see
+     * g_file_io_stream_query_info().
+     * @param attributes - a file attribute query string.
+     * @param ioPriority - the I/O priority of the
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     queryInfoAsync(attributes: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finalizes the asynchronous query started
+     * by g_file_io_stream_query_info_async().
+     * @param result - a #GAsyncResult.
+     */
     queryInfoFinish(result: AsyncResult): FileInfo;
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek(): boolean;
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate(): boolean;
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+    /**
+     * Tells the current position within the stream.
+     */
     tell(): number;
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
 }

package/dist/generated/gio/file-iostream.js

@@ -2,6 +2,27 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { FileInfo } from "./file-info.js";
 import { IOStream } from "./iostream.js";
+/**
+ * `GFileIOStream` provides I/O streams that both read and write to the same
+ * file handle.
+ *
+ * `GFileIOStream` implements [iface@Gio.Seekable], which allows the I/O
+ * stream to jump to arbitrary positions in the file and to truncate
+ * the file, provided the filesystem of the file supports these
+ * operations.
+ *
+ * To find the position of a file I/O stream, use [method@Gio.Seekable.tell].
+ *
+ * To find out if a file I/O stream supports seeking, use
+ * [method@Gio.Seekable.can_seek]. To position a file I/O stream, use
+ * [method@Gio.Seekable.seek]. To find out if a file I/O stream supports
+ * truncating, use [method@Gio.Seekable.can_truncate]. To truncate a file I/O
+ * stream, use [method@Gio.Seekable.truncate].
+ *
+ * The default implementation of all the `GFileIOStream` operations
+ * and the implementation of [iface@Gio.Seekable] just call into the same
+ * operations on the output stream.
+ */
 export class FileIOStream extends IOStream {
     constructor(...args) {
         super(...args);
@@ -17,6 +38,11 @@ export class FileIOStream extends IOStream {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the entity tag for the file when it has been written.
+     * This must be called after the stream has been written
+     * and closed, as the etag can change while writing.
+     */
     getEtag() {
         return call("libgio-2.0.so.0", "g_file_io_stream_get_etag", [
             {
@@ -25,6 +51,27 @@ export class FileIOStream extends IOStream {
             },
         ], { type: "string" });
     }
+    /**
+     * Queries a file io stream for the given @attributes.
+     * This function blocks while querying the stream. For the asynchronous
+     * version of this function, see g_file_io_stream_query_info_async().
+     * While the stream is blocked, the stream will set the pending flag
+     * internally, and any other operations on the stream will fail with
+     * %G_IO_ERROR_PENDING.
+     *
+     * Can fail if the stream was already closed (with `error` being set to
+     * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
+     * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
+     * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). I
+     * all cases of failure, %NULL will be returned.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
+     * be returned.
+     * @param attributes - a file attribute query string.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     queryInfo(attributes, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_file_io_stream_query_info", [
@@ -58,6 +105,19 @@ export class FileIOStream extends IOStream {
         }
         return getObject(ptr, FileInfo);
     }
+    /**
+     * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+     * `callback` will be called with a #GAsyncResult which can be used to
+     * finish the operation with g_file_io_stream_query_info_finish().
+     *
+     * For the synchronous version of this function, see
+     * g_file_io_stream_query_info().
+     * @param attributes - a file attribute query string.
+     * @param ioPriority - the I/O priority of the
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     queryInfoAsync(attributes, ioPriority, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_file_io_stream_query_info_async", [
             {
@@ -89,6 +149,11 @@ export class FileIOStream extends IOStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finalizes the asynchronous query started
+     * by g_file_io_stream_query_info_async().
+     * @param result - a #GAsyncResult.
+     */
     queryInfoFinish(result) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_file_io_stream_query_info_finish", [
@@ -117,6 +182,9 @@ export class FileIOStream extends IOStream {
         }
         return getObject(ptr, FileInfo);
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -125,6 +193,10 @@ export class FileIOStream extends IOStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate() {
         return call("libgio-2.0.so.0", "g_seekable_can_truncate", [
             {
@@ -133,6 +205,25 @@ export class FileIOStream extends IOStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset, type, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_seek", [
@@ -170,6 +261,9 @@ export class FileIOStream extends IOStream {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -178,6 +272,19 @@ export class FileIOStream extends IOStream {
             },
         ], { type: "int", size: 64, unsigned: false });
     }
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_truncate", [

package/dist/generated/gio/file-monitor.d.ts

@@ -4,9 +4,32 @@ import * as GObject from "../gobject/index.js";
 export declare class FileMonitor extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Cancels a file monitor.
+     */
     cancel(): boolean;
+    /**
+     * Emits the #GFileMonitor::changed signal if a change
+     * has taken place. Should be called from file monitor
+     * implementations only.
+     *
+     * Implementations are responsible to call this method from the
+     * thread-default main context (see [method@GLib.MainContext.push_thread_default])
+     * of the thread that the monitor was created in.
+     * @param child - a #GFile.
+     * @param otherFile - a #GFile, or %NULL.
+     * @param eventType - a set of #GFileMonitorEvent flags.
+     */
     emitEvent(child: File, eventType: FileMonitorEvent, otherFile?: File | null): void;
+    /**
+     * Returns whether the monitor is canceled.
+     */
     isCancelled(): boolean;
+    /**
+     * Sets the rate limit to which the `monitor` will report
+     * consecutive change events to the same file.
+     * @param limitMsecs - a non-negative integer with the limit in milliseconds
+     */
     setRateLimit(limitMsecs: number): void;
     connect(signal: "changed", handler: (self: FileMonitor, file: File, otherFile: File, eventType: FileMonitorEvent) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: FileMonitor, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gio/file-monitor.js

@@ -1,6 +1,21 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * Monitors a file or directory for changes.
+ *
+ * To obtain a `GFileMonitor` for a file or directory, use
+ * [method@Gio.File.monitor], [method@Gio.File.monitor_file], or
+ * [method@Gio.File.monitor_directory].
+ *
+ * To get informed about changes to the file or directory you are
+ * monitoring, connect to the [signal@Gio.FileMonitor::changed] signal. The
+ * signal will be emitted in the thread-default main context (see
+ * [method@GLib.MainContext.push_thread_default]) of the thread that the monitor
+ * was created in (though if the global default main context is blocked, this
+ * may cause notifications to be blocked even if the thread-default
+ * context is still running).
+ */
 const SIGNAL_META = {
     changed: {
         params: [
@@ -26,6 +41,9 @@ export class FileMonitor extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Cancels a file monitor.
+     */
     cancel() {
         return call("libgio-2.0.so.0", "g_file_monitor_cancel", [
             {
@@ -34,6 +52,18 @@ export class FileMonitor extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Emits the #GFileMonitor::changed signal if a change
+     * has taken place. Should be called from file monitor
+     * implementations only.
+     *
+     * Implementations are responsible to call this method from the
+     * thread-default main context (see [method@GLib.MainContext.push_thread_default])
+     * of the thread that the monitor was created in.
+     * @param child - a #GFile.
+     * @param otherFile - a #GFile, or %NULL.
+     * @param eventType - a set of #GFileMonitorEvent flags.
+     */
     emitEvent(child, eventType, otherFile) {
         call("libgio-2.0.so.0", "g_file_monitor_emit_event", [
             {
@@ -55,6 +85,9 @@ export class FileMonitor extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether the monitor is canceled.
+     */
     isCancelled() {
         return call("libgio-2.0.so.0", "g_file_monitor_is_cancelled", [
             {
@@ -63,6 +96,11 @@ export class FileMonitor extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the rate limit to which the `monitor` will report
+     * consecutive change events to the same file.
+     * @param limitMsecs - a non-negative integer with the limit in milliseconds
+     */
     setRateLimit(limitMsecs) {
         call("libgio-2.0.so.0", "g_file_monitor_set_rate_limit", [
             {