@gtkx/ffi 0.1.44 → 0.1.46

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

@@ -4,19 +4,166 @@ import { Cancellable } from "./cancellable.js";
 import { InputStream } from "./input-stream.js";
 import { OutputStream } from "./output-stream.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GIOStream` represents an object that has both read and write streams.
+ * Generally the two streams act as separate input and output streams,
+ * but they share some common resources and state. For instance, for
+ * seekable streams, both streams may use the same position.
+ *
+ * Examples of `GIOStream` objects are [class@Gio.SocketConnection], which represents
+ * a two-way network connection; and [class@Gio.FileIOStream], which represents a
+ * file handle opened in read-write mode.
+ *
+ * To do the actual reading and writing you need to get the substreams
+ * with [method@Gio.IOStream.get_input_stream] and
+ * [method@Gio.IOStream.get_output_stream].
+ *
+ * The `GIOStream` object owns the input and the output streams, not the other
+ * way around, so keeping the substreams alive will not keep the `GIOStream`
+ * object alive. If the `GIOStream` object is freed it will be closed, thus
+ * closing the substreams, so even if the substreams stay alive they will
+ * always return `G_IO_ERROR_CLOSED` for all operations.
+ *
+ * To close a stream use [method@Gio.IOStream.close] which will close the common
+ * stream object and also the individual substreams. You can also close
+ * the substreams themselves. In most cases this only marks the
+ * substream as closed, so further I/O on it fails but common state in the
+ * `GIOStream` may still be open. However, some streams may support
+ * ‘half-closed’ states where one direction of the stream is actually shut down.
+ *
+ * Operations on `GIOStream`s cannot be started while another operation on the
+ * `GIOStream` or its substreams is in progress. Specifically, an application can
+ * read from the [class@Gio.InputStream] and write to the
+ * [class@Gio.OutputStream] simultaneously (either in separate threads, or as
+ * asynchronous operations in the same thread), but an application cannot start
+ * any `GIOStream` operation while there is a `GIOStream`, `GInputStream` or
+ * `GOutputStream` operation in progress, and an application can’t start any
+ * `GInputStream` or `GOutputStream` operation while there is a `GIOStream`
+ * operation in progress.
+ *
+ * This is a product of individual stream operations being associated with a
+ * given [type@GLib.MainContext] (the thread-default context at the time the
+ * operation was started), rather than entire streams being associated with a
+ * single `GMainContext`.
+ *
+ * GIO may run operations on `GIOStream`s from other (worker) threads, and this
+ * may be exposed to application code in the behaviour of wrapper streams, such
+ * as [class@Gio.BufferedInputStream] or [class@Gio.TlsConnection]. With such
+ * wrapper APIs, application code may only run operations on the base (wrapped)
+ * stream when the wrapper stream is idle. Note that the semantics of such
+ * operations may not be well-defined due to the state the wrapper stream leaves
+ * the base stream in (though they are guaranteed not to crash).
+ */
 export declare class IOStream extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Finishes an asynchronous io stream splice operation.
+     * @param result - a #GAsyncResult.
+     */
     static spliceFinish(result: AsyncResult): boolean;
+    /**
+     * Clears the pending flag on @stream.
+     */
     clearPending(): void;
+    /**
+     * Closes the stream, releasing resources related to it. This will also
+     * close the individual input and output streams, if they are not already
+     * closed.
+     *
+     * Once the stream is closed, all other operations will return
+     * %G_IO_ERROR_CLOSED. Closing a stream multiple times will not
+     * return an error.
+     *
+     * Closing a stream will automatically flush any outstanding buffers
+     * in the stream.
+     *
+     * Streams will be automatically closed when the last reference
+     * is dropped, but you might want to call this function to make sure
+     * resources are released as early as possible.
+     *
+     * Some streams might keep the backing store of the stream (e.g. a file
+     * descriptor) open after the stream is closed. See the documentation for
+     * the individual stream for details.
+     *
+     * On failure the first error that happened will be reported, but the
+     * close operation will finish as much as possible. A stream that failed
+     * to close will still return %G_IO_ERROR_CLOSED for all operations.
+     * Still, it is important to check and report the error to the user,
+     * otherwise there might be a loss of data as all data might not be written.
+     *
+     * 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.
+     * Cancelling a close will still leave the stream closed, but some streams
+     * can use a faster close that doesn't block to e.g. check errors.
+     *
+     * The default implementation of this method just calls close on the
+     * individual input/output streams.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     */
     close(cancellable?: Cancellable | null): boolean;
+    /**
+     * Requests an asynchronous close of the stream, releasing resources
+     * related to it. When the operation is finished `callback` will be
+     * called. You can then call g_io_stream_close_finish() to get
+     * the result of the operation.
+     *
+     * For behaviour details see g_io_stream_close().
+     *
+     * The asynchronous methods have a default fallback that uses threads
+     * to implement asynchronicity, so they are optional for inheriting
+     * classes. However, if you override one you must override all.
+     * @param ioPriority - the io priority of the request
+     * @param cancellable - optional cancellable object
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     closeAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Closes a stream.
+     * @param result - a #GAsyncResult
+     */
     closeFinish(result: AsyncResult): boolean;
+    /**
+     * Gets the input stream for this object. This is used
+     * for reading.
+     */
     getInputStream(): InputStream;
+    /**
+     * Gets the output stream for this object. This is used for
+     * writing.
+     */
     getOutputStream(): OutputStream;
+    /**
+     * Checks if a stream has pending actions.
+     */
     hasPending(): boolean;
+    /**
+     * Checks if a stream is closed.
+     */
     isClosed(): boolean;
+    /**
+     * Sets `stream` to have actions pending. If the pending flag is
+     * already set or `stream` is closed, it will return %FALSE and set
+     * @error.
+     */
     setPending(): boolean;
+    /**
+     * Asynchronously splice the output stream of `stream1` to the input stream of
+     * @stream2, and splice the output stream of `stream2` to the input stream of
+     * @stream1.
+     *
+     * When the operation is finished `callback` will be called.
+     * You can then call g_io_stream_splice_finish() to get the
+     * result of the operation.
+     * @param stream2 - a #GIOStream.
+     * @param flags - a set of #GIOStreamSpliceFlags.
+     * @param ioPriority - the io 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
+     */
     spliceAsync(stream2: IOStream, flags: IOStreamSpliceFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     connect(signal: "notify", handler: (self: IOStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/iostream.js

@@ -3,6 +3,56 @@ import { NativeError, getObject } from "@gtkx/ffi";
 import { InputStream } from "./input-stream.js";
 import { OutputStream } from "./output-stream.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GIOStream` represents an object that has both read and write streams.
+ * Generally the two streams act as separate input and output streams,
+ * but they share some common resources and state. For instance, for
+ * seekable streams, both streams may use the same position.
+ *
+ * Examples of `GIOStream` objects are [class@Gio.SocketConnection], which represents
+ * a two-way network connection; and [class@Gio.FileIOStream], which represents a
+ * file handle opened in read-write mode.
+ *
+ * To do the actual reading and writing you need to get the substreams
+ * with [method@Gio.IOStream.get_input_stream] and
+ * [method@Gio.IOStream.get_output_stream].
+ *
+ * The `GIOStream` object owns the input and the output streams, not the other
+ * way around, so keeping the substreams alive will not keep the `GIOStream`
+ * object alive. If the `GIOStream` object is freed it will be closed, thus
+ * closing the substreams, so even if the substreams stay alive they will
+ * always return `G_IO_ERROR_CLOSED` for all operations.
+ *
+ * To close a stream use [method@Gio.IOStream.close] which will close the common
+ * stream object and also the individual substreams. You can also close
+ * the substreams themselves. In most cases this only marks the
+ * substream as closed, so further I/O on it fails but common state in the
+ * `GIOStream` may still be open. However, some streams may support
+ * ‘half-closed’ states where one direction of the stream is actually shut down.
+ *
+ * Operations on `GIOStream`s cannot be started while another operation on the
+ * `GIOStream` or its substreams is in progress. Specifically, an application can
+ * read from the [class@Gio.InputStream] and write to the
+ * [class@Gio.OutputStream] simultaneously (either in separate threads, or as
+ * asynchronous operations in the same thread), but an application cannot start
+ * any `GIOStream` operation while there is a `GIOStream`, `GInputStream` or
+ * `GOutputStream` operation in progress, and an application can’t start any
+ * `GInputStream` or `GOutputStream` operation while there is a `GIOStream`
+ * operation in progress.
+ *
+ * This is a product of individual stream operations being associated with a
+ * given [type@GLib.MainContext] (the thread-default context at the time the
+ * operation was started), rather than entire streams being associated with a
+ * single `GMainContext`.
+ *
+ * GIO may run operations on `GIOStream`s from other (worker) threads, and this
+ * may be exposed to application code in the behaviour of wrapper streams, such
+ * as [class@Gio.BufferedInputStream] or [class@Gio.TlsConnection]. With such
+ * wrapper APIs, application code may only run operations on the base (wrapped)
+ * stream when the wrapper stream is idle. Note that the semantics of such
+ * operations may not be well-defined due to the state the wrapper stream leaves
+ * the base stream in (though they are guaranteed not to crash).
+ */
 export class IOStream extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -18,6 +68,10 @@ export class IOStream extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Finishes an asynchronous io stream splice operation.
+     * @param result - a #GAsyncResult.
+     */
     static spliceFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_io_stream_splice_finish", [
@@ -42,6 +96,9 @@ export class IOStream extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Clears the pending flag on @stream.
+     */
     clearPending() {
         call("libgio-2.0.so.0", "g_io_stream_clear_pending", [
             {
@@ -50,6 +107,42 @@ export class IOStream extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Closes the stream, releasing resources related to it. This will also
+     * close the individual input and output streams, if they are not already
+     * closed.
+     *
+     * Once the stream is closed, all other operations will return
+     * %G_IO_ERROR_CLOSED. Closing a stream multiple times will not
+     * return an error.
+     *
+     * Closing a stream will automatically flush any outstanding buffers
+     * in the stream.
+     *
+     * Streams will be automatically closed when the last reference
+     * is dropped, but you might want to call this function to make sure
+     * resources are released as early as possible.
+     *
+     * Some streams might keep the backing store of the stream (e.g. a file
+     * descriptor) open after the stream is closed. See the documentation for
+     * the individual stream for details.
+     *
+     * On failure the first error that happened will be reported, but the
+     * close operation will finish as much as possible. A stream that failed
+     * to close will still return %G_IO_ERROR_CLOSED for all operations.
+     * Still, it is important to check and report the error to the user,
+     * otherwise there might be a loss of data as all data might not be written.
+     *
+     * 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.
+     * Cancelling a close will still leave the stream closed, but some streams
+     * can use a faster close that doesn't block to e.g. check errors.
+     *
+     * The default implementation of this method just calls close on the
+     * individual input/output streams.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     */
     close(cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_io_stream_close", [
@@ -79,6 +172,22 @@ export class IOStream extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Requests an asynchronous close of the stream, releasing resources
+     * related to it. When the operation is finished `callback` will be
+     * called. You can then call g_io_stream_close_finish() to get
+     * the result of the operation.
+     *
+     * For behaviour details see g_io_stream_close().
+     *
+     * The asynchronous methods have a default fallback that uses threads
+     * to implement asynchronicity, so they are optional for inheriting
+     * classes. However, if you override one you must override all.
+     * @param ioPriority - the io priority of the request
+     * @param cancellable - optional cancellable object
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     closeAsync(ioPriority, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_io_stream_close_async", [
             {
@@ -106,6 +215,10 @@ export class IOStream extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Closes a stream.
+     * @param result - a #GAsyncResult
+     */
     closeFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_io_stream_close_finish", [
@@ -134,6 +247,10 @@ export class IOStream extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Gets the input stream for this object. This is used
+     * for reading.
+     */
     getInputStream() {
         const ptr = call("libgio-2.0.so.0", "g_io_stream_get_input_stream", [
             {
@@ -143,6 +260,10 @@ export class IOStream extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, InputStream);
     }
+    /**
+     * Gets the output stream for this object. This is used for
+     * writing.
+     */
     getOutputStream() {
         const ptr = call("libgio-2.0.so.0", "g_io_stream_get_output_stream", [
             {
@@ -152,6 +273,9 @@ export class IOStream extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, OutputStream);
     }
+    /**
+     * Checks if a stream has pending actions.
+     */
     hasPending() {
         return call("libgio-2.0.so.0", "g_io_stream_has_pending", [
             {
@@ -160,6 +284,9 @@ export class IOStream extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a stream is closed.
+     */
     isClosed() {
         return call("libgio-2.0.so.0", "g_io_stream_is_closed", [
             {
@@ -168,6 +295,11 @@ export class IOStream extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets `stream` to have actions pending. If the pending flag is
+     * already set or `stream` is closed, it will return %FALSE and set
+     * @error.
+     */
     setPending() {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_io_stream_set_pending", [
@@ -192,6 +324,21 @@ export class IOStream extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Asynchronously splice the output stream of `stream1` to the input stream of
+     * @stream2, and splice the output stream of `stream2` to the input stream of
+     * @stream1.
+     *
+     * When the operation is finished `callback` will be called.
+     * You can then call g_io_stream_splice_finish() to get the
+     * result of the operation.
+     * @param stream2 - a #GIOStream.
+     * @param flags - a set of #GIOStreamSpliceFlags.
+     * @param ioPriority - the io 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
+     */
     spliceAsync(stream2, flags, ioPriority, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_io_stream_splice_async", [
             {

package/dist/generated/gio/list-model.d.ts

@@ -1,10 +1,133 @@
 import * as GObject from "../gobject/index.js";
+/**
+ * `GListModel` is an interface that represents a mutable list of
+ * [class@GObject.Object]. Its main intention is as a model for various widgets
+ * in user interfaces, such as list views, but it can also be used as a
+ * convenient method of returning lists of data, with support for
+ * updates.
+ *
+ * Each object in the list may also report changes in itself via some
+ * mechanism (normally the [signal@GObject.Object::notify] signal).  Taken
+ * together with the [signal@Gio.ListModel::items-changed] signal, this provides
+ * for a list that can change its membership, and in which the members can
+ * change their individual properties.
+ *
+ * A good example would be the list of visible wireless network access
+ * points, where each access point can report dynamic properties such as
+ * signal strength.
+ *
+ * It is important to note that the `GListModel` itself does not report
+ * changes to the individual items.  It only reports changes to the list
+ * membership.  If you want to observe changes to the objects themselves
+ * then you need to connect signals to the objects that you are
+ * interested in.
+ *
+ * All items in a `GListModel` are of (or derived from) the same type.
+ * [method@Gio.ListModel.get_item_type] returns that type.  The type may be an
+ * interface, in which case all objects in the list must implement it.
+ *
+ * The semantics are close to that of an array:
+ * [method@Gio.ListModel.get_n_items] returns the number of items in the list
+ * and [method@Gio.ListModel.get_item] returns an item at a (0-based) position.
+ * In order to allow implementations to calculate the list length lazily,
+ * you can also iterate over items: starting from 0, repeatedly call
+ * [method@Gio.ListModel.get_item] until it returns `NULL`.
+ *
+ * An implementation may create objects lazily, but must take care to
+ * return the same object for a given position until all references to
+ * it are gone.
+ *
+ * On the other side, a consumer is expected only to hold references on
+ * objects that are currently ‘user visible’, in order to facilitate the
+ * maximum level of laziness in the implementation of the list and to
+ * reduce the required number of signal connections at a given time.
+ *
+ * This interface is intended only to be used from a single thread.  The
+ * thread in which it is appropriate to use it depends on the particular
+ * implementation, but typically it will be from the thread that owns
+ * the thread-default main context (see
+ * [method@GLib.MainContext.push_thread_default]) in effect at the time that the
+ * model was created.
+ *
+ * Over time, it has established itself as good practice for list model
+ * implementations to provide properties `item-type` and `n-items` to
+ * ease working with them. While it is not required, it is recommended
+ * that implementations provide these two properties. They should return
+ * the values of [method@Gio.ListModel.get_item_type] and
+ * [method@Gio.ListModel.get_n_items] respectively and be defined as such:
+ *
+ * ```c
+ * properties[PROP_ITEM_TYPE] =
+ * g_param_spec_gtype ("item-type", NULL, NULL, G_TYPE_OBJECT,
+ * G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+ * properties[PROP_N_ITEMS] =
+ * g_param_spec_uint ("n-items", NULL, NULL, 0, G_MAXUINT, 0,
+ * G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+ * ```
+ */
 export declare class ListModel {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): ListModel;
+    /**
+     * Gets the type of the items in @list.
+     *
+     * All items returned from g_list_model_get_item() are of the type
+     * returned by this function, or a subtype, or if the type is an
+     * interface, they are an implementation of that interface.
+     *
+     * The item type of a #GListModel can not change during the life of the
+     * model.
+     */
     getItemType(): number;
+    /**
+     * Gets the number of items in @list.
+     *
+     * Depending on the model implementation, calling this function may be
+     * less efficient than iterating the list with increasing values for
+     * `position` until g_list_model_get_item() returns %NULL.
+     */
     getNItems(): number;
+    /**
+     * Get the item at @position.
+     *
+     * If `position` is greater than the number of items in @list, %NULL is
+     * returned.
+     *
+     * %NULL is never returned for an index that is smaller than the length
+     * of the list.
+     *
+     * This function is meant to be used by language bindings in place
+     * of g_list_model_get_item().
+     *
+     * See also: g_list_model_get_n_items()
+     * @param position - the position of the item to fetch
+     */
     getObject(position: number): GObject.GObject | null;
+    /**
+     * Emits the #GListModel::items-changed signal on @list.
+     *
+     * This function should only be called by classes implementing
+     * #GListModel. It has to be called after the internal representation
+     * of `list` has been updated, because handlers connected to this signal
+     * might query the new state of the list.
+     *
+     * Implementations must only make changes to the model (as visible to
+     * its consumer) in places that will not cause problems for that
+     * consumer.  For models that are driven directly by a write API (such
+     * as #GListStore), changes can be reported in response to uses of that
+     * API.  For models that represent remote data, changes should only be
+     * made from a fresh mainloop dispatch.  It is particularly not
+     * permitted to make changes in response to a call to the #GListModel
+     * consumer API.
+     *
+     * Stated another way: in general, it is assumed that code making a
+     * series of accesses to the model via the API, without returning to the
+     * mainloop, and without calling other code, will continue to view the
+     * same contents of the model.
+     * @param position - the position at which `list` changed
+     * @param removed - the number of items removed
+     * @param added - the number of items added
+     */
     itemsChanged(position: number, removed: number, added: number): void;
 }

package/dist/generated/gio/list-model.js

@@ -1,6 +1,72 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GListModel` is an interface that represents a mutable list of
+ * [class@GObject.Object]. Its main intention is as a model for various widgets
+ * in user interfaces, such as list views, but it can also be used as a
+ * convenient method of returning lists of data, with support for
+ * updates.
+ *
+ * Each object in the list may also report changes in itself via some
+ * mechanism (normally the [signal@GObject.Object::notify] signal).  Taken
+ * together with the [signal@Gio.ListModel::items-changed] signal, this provides
+ * for a list that can change its membership, and in which the members can
+ * change their individual properties.
+ *
+ * A good example would be the list of visible wireless network access
+ * points, where each access point can report dynamic properties such as
+ * signal strength.
+ *
+ * It is important to note that the `GListModel` itself does not report
+ * changes to the individual items.  It only reports changes to the list
+ * membership.  If you want to observe changes to the objects themselves
+ * then you need to connect signals to the objects that you are
+ * interested in.
+ *
+ * All items in a `GListModel` are of (or derived from) the same type.
+ * [method@Gio.ListModel.get_item_type] returns that type.  The type may be an
+ * interface, in which case all objects in the list must implement it.
+ *
+ * The semantics are close to that of an array:
+ * [method@Gio.ListModel.get_n_items] returns the number of items in the list
+ * and [method@Gio.ListModel.get_item] returns an item at a (0-based) position.
+ * In order to allow implementations to calculate the list length lazily,
+ * you can also iterate over items: starting from 0, repeatedly call
+ * [method@Gio.ListModel.get_item] until it returns `NULL`.
+ *
+ * An implementation may create objects lazily, but must take care to
+ * return the same object for a given position until all references to
+ * it are gone.
+ *
+ * On the other side, a consumer is expected only to hold references on
+ * objects that are currently ‘user visible’, in order to facilitate the
+ * maximum level of laziness in the implementation of the list and to
+ * reduce the required number of signal connections at a given time.
+ *
+ * This interface is intended only to be used from a single thread.  The
+ * thread in which it is appropriate to use it depends on the particular
+ * implementation, but typically it will be from the thread that owns
+ * the thread-default main context (see
+ * [method@GLib.MainContext.push_thread_default]) in effect at the time that the
+ * model was created.
+ *
+ * Over time, it has established itself as good practice for list model
+ * implementations to provide properties `item-type` and `n-items` to
+ * ease working with them. While it is not required, it is recommended
+ * that implementations provide these two properties. They should return
+ * the values of [method@Gio.ListModel.get_item_type] and
+ * [method@Gio.ListModel.get_n_items] respectively and be defined as such:
+ *
+ * ```c
+ * properties[PROP_ITEM_TYPE] =
+ * g_param_spec_gtype ("item-type", NULL, NULL, G_TYPE_OBJECT,
+ * G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+ * properties[PROP_N_ITEMS] =
+ * g_param_spec_uint ("n-items", NULL, NULL, 0, G_MAXUINT, 0,
+ * G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+ * ```
+ */
 export class ListModel {
     ptr;
     constructor(ptr) {
@@ -9,6 +75,16 @@ export class ListModel {
     static fromPtr(ptr) {
         return new ListModel(ptr);
     }
+    /**
+     * Gets the type of the items in @list.
+     *
+     * All items returned from g_list_model_get_item() are of the type
+     * returned by this function, or a subtype, or if the type is an
+     * interface, they are an implementation of that interface.
+     *
+     * The item type of a #GListModel can not change during the life of the
+     * model.
+     */
     getItemType() {
         return call("libgio-2.0.so.0", "g_list_model_get_item_type", [
             {
@@ -17,6 +93,13 @@ export class ListModel {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the number of items in @list.
+     *
+     * Depending on the model implementation, calling this function may be
+     * less efficient than iterating the list with increasing values for
+     * `position` until g_list_model_get_item() returns %NULL.
+     */
     getNItems() {
         return call("libgio-2.0.so.0", "g_list_model_get_n_items", [
             {
@@ -25,6 +108,21 @@ export class ListModel {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Get the item at @position.
+     *
+     * If `position` is greater than the number of items in @list, %NULL is
+     * returned.
+     *
+     * %NULL is never returned for an index that is smaller than the length
+     * of the list.
+     *
+     * This function is meant to be used by language bindings in place
+     * of g_list_model_get_item().
+     *
+     * See also: g_list_model_get_n_items()
+     * @param position - the position of the item to fetch
+     */
     getObject(position) {
         const ptr = call("libgio-2.0.so.0", "g_list_model_get_object", [
             {
@@ -40,6 +138,31 @@ export class ListModel {
             return null;
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Emits the #GListModel::items-changed signal on @list.
+     *
+     * This function should only be called by classes implementing
+     * #GListModel. It has to be called after the internal representation
+     * of `list` has been updated, because handlers connected to this signal
+     * might query the new state of the list.
+     *
+     * Implementations must only make changes to the model (as visible to
+     * its consumer) in places that will not cause problems for that
+     * consumer.  For models that are driven directly by a write API (such
+     * as #GListStore), changes can be reported in response to uses of that
+     * API.  For models that represent remote data, changes should only be
+     * made from a fresh mainloop dispatch.  It is particularly not
+     * permitted to make changes in response to a call to the #GListModel
+     * consumer API.
+     *
+     * Stated another way: in general, it is assumed that code making a
+     * series of accesses to the model via the API, without returning to the
+     * mainloop, and without calling other code, will continue to view the
+     * same contents of the model.
+     * @param position - the position at which `list` changed
+     * @param removed - the number of items removed
+     * @param added - the number of items added
+     */
     itemsChanged(position, removed, added) {
         call("libgio-2.0.so.0", "g_list_model_items_changed", [
             {