@gtkx/ffi 0.9.4 → 0.10.1

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

@@ -19,6 +19,12 @@ import * as GObject from "../gobject/index.js";
  *
  * All of these functions have async variants too.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class InputStream extends GObject.GObject {
     static glibTypeName = "GInputStream";
     static objectType = "gobject";
@@ -586,12 +592,26 @@ export class InputStream extends GObject.GObject {
         return _result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -1,9 +1,4 @@
 import * as GObject from "../gobject/index.js";
-/**
- * Provides an interface and default functions for loading and unloading
- * modules. This is used internally to make GIO extensible, but can also
- * be used by others to implement module loading.
- */
 export declare class IOModule extends GObject.TypeModule {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/iomodule.js

@@ -8,6 +8,12 @@ import * as GObject from "../gobject/index.js";
  * modules. This is used internally to make GIO extensible, but can also
  * be used by others to implement module loading.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class IOModule extends GObject.TypeModule {
     static glibTypeName = "GIOModule";
     static objectType = "gobject";
@@ -27,7 +33,7 @@ export class IOModule extends GObject.TypeModule {
                     type: { type: "string" },
                     value: filename,
                 },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -74,12 +80,26 @@ export class IOModule extends GObject.TypeModule {
         });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -3,56 +3,6 @@ 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 {@link Gio.SocketConnection}, which represents
- * a two-way network connection; and {@link 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 {@link Gio.IOStream.get_input_stream} and
- * {@link 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 {@link 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 {@link Gio.InputStream} and write to the
- * {@link 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 {@link 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 {@link Gio.BufferedInputStream} or {@link 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 {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/iostream.js

@@ -53,6 +53,12 @@ import * as GObject from "../gobject/index.js";
  * 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).
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class IOStream extends GObject.GObject {
     static glibTypeName = "GIOStream";
     static objectType = "gobject";
@@ -273,12 +279,26 @@ export class IOStream extends GObject.GObject {
         return result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -1,12 +1,5 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
-/**
- * `GListStore` is a simple implementation of {@link Gio.ListModel} that stores
- * all items in memory.
- *
- * It provides insertions, deletions, and lookups in logarithmic time
- * with a fast path for the common case of iterating the list linearly.
- */
 export declare class ListStore extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -144,6 +137,7 @@ export declare class ListStore extends GObject.GObject {
      * @param added - the number of items added
      */
     itemsChanged(position: number, removed: number, added: number): void;
+    connect(signal: "items-changed", handler: (self: ListStore, position: number, removed: number, added: number) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ListStore, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -10,6 +10,20 @@ import * as GObject from "../gobject/index.js";
  * It provides insertions, deletions, and lookups in logarithmic time
  * with a fast path for the common case of iterating the list linearly.
  */
+const SIGNAL_META = {
+    "items-changed": {
+        params: [
+            { type: "int", size: 32, unsigned: true },
+            { type: "int", size: 32, unsigned: true },
+            { type: "int", size: 32, unsigned: true },
+        ],
+        returnType: { type: "undefined" },
+    },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ListStore extends GObject.GObject {
     static glibTypeName = "GListStore";
     static objectType = "gobject";
@@ -29,7 +43,7 @@ export class ListStore extends GObject.GObject {
                     type: { type: "int", size: 64, unsigned: true },
                     value: itemType,
                 },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -298,12 +312,26 @@ export class ListStore extends GObject.GObject {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gio/loadable-icon.d.ts

@@ -2,7 +2,9 @@ import { Ref } from "@gtkx/native";
 import { NativeObject } from "../../native/base.js";
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
+import { Icon } from "./icon.js";
 import { InputStream } from "./input-stream.js";
+import * as GLib from "../glib/index.js";
 /**
  * `GLoadableIcon` extends the {@link Gio.Icon} interface and adds the ability
  * to load icons from streams.
@@ -24,4 +26,40 @@ export declare class LoadableIcon extends NativeObject {
      * @param type - a location to store the type of the loaded
      */
     loadFinish(res: AsyncResult, type?: Ref<string>): InputStream;
+    /**
+     * Checks if two icons are equal.
+     * @param icon2 - pointer to the second #GIcon.
+     */
+    equal(icon2?: Icon): boolean;
+    /**
+     * Gets a hash for an icon.
+     */
+    hash(): number;
+    /**
+     * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+     * back by calling g_icon_deserialize() on the returned value.
+     * As serialization will avoid using raw icon data when possible, it only
+     * makes sense to transfer the #GVariant between processes on the same machine,
+     * (as opposed to over the network), and within the same file system namespace.
+     */
+    serialize(): GLib.Variant | null;
+    /**
+     * Generates a textual representation of `icon` that can be used for
+     * serialization such as when passing `icon` to a different process or
+     * saving it to persistent storage. Use g_icon_new_for_string() to
+     * get `icon` back from the returned string.
+     *
+     * The encoding of the returned string is proprietary to #GIcon except
+     * in the following two cases
+     *
+     * - If `icon` is a #GFileIcon, the returned string is a native path
+     * (such as `/path/to/my icon.png`) without escaping
+     * if the #GFile for `icon` is a native file.  If the file is not
+     * native, the returned string is the result of g_file_get_uri()
+     * (such as `sftp://path/to/my%20icon.png`).
+     *
+     * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+     * the encoding is simply the name (such as `network-server`).
+     */
+    toString(): string | null;
 }

package/dist/generated/gio/loadable-icon.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { NativeError } from "../../native/error.js";
 import { getNativeObject } from "../../native/object.js";
 import { NativeObject } from "../../native/base.js";
+import * as GLib from "../glib/index.js";
 /**
  * `GLoadableIcon` extends the {@link Gio.Icon} interface and adds the ability
  * to load icons from streams.
@@ -92,4 +93,76 @@ export class LoadableIcon extends NativeObject {
         }
         return getNativeObject(ptr);
     }
+    /**
+     * Checks if two icons are equal.
+     * @param icon2 - pointer to the second #GIcon.
+     */
+    equal(icon2) {
+        return call("libgio-2.0.so.0", "g_icon_equal", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: icon2?.id ?? icon2,
+                optional: true,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets a hash for an icon.
+     */
+    hash() {
+        return call("libgio-2.0.so.0", "g_icon_hash", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: true });
+    }
+    /**
+     * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+     * back by calling g_icon_deserialize() on the returned value.
+     * As serialization will avoid using raw icon data when possible, it only
+     * makes sense to transfer the #GVariant between processes on the same machine,
+     * (as opposed to over the network), and within the same file system namespace.
+     */
+    serialize() {
+        const ptr = call("libgio-2.0.so.0", "g_icon_serialize", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gvariant" });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, GLib.Variant);
+    }
+    /**
+     * Generates a textual representation of `icon` that can be used for
+     * serialization such as when passing `icon` to a different process or
+     * saving it to persistent storage. Use g_icon_new_for_string() to
+     * get `icon` back from the returned string.
+     *
+     * The encoding of the returned string is proprietary to #GIcon except
+     * in the following two cases
+     *
+     * - If `icon` is a #GFileIcon, the returned string is a native path
+     * (such as `/path/to/my icon.png`) without escaping
+     * if the #GFile for `icon` is a native file.  If the file is not
+     * native, the returned string is the result of g_file_get_uri()
+     * (such as `sftp://path/to/my%20icon.png`).
+     *
+     * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+     * the encoding is simply the name (such as `network-server`).
+     */
+    toString() {
+        return call("libgio-2.0.so.0", "g_icon_to_string", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string" });
+    }
 }

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

@@ -3,13 +3,6 @@ import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import { InputStream } from "./input-stream.js";
-/**
- * `GMemoryInputStream` is a class for using arbitrary
- * memory chunks as input for GIO streaming input operations.
- *
- * As of GLib 2.34, `GMemoryInputStream` implements
- * {@link Gio.PollableInputStream}.
- */
 export declare class MemoryInputStream extends InputStream {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -4,6 +4,7 @@ import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { InputStream } from "./input-stream.js";
 /**
  * `GMemoryInputStream` is a class for using arbitrary
@@ -12,6 +13,12 @@ import { InputStream } from "./input-stream.js";
  * As of GLib 2.34, `GMemoryInputStream` implements
  * {@link Gio.PollableInputStream}.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class MemoryInputStream extends InputStream {
     static glibTypeName = "GMemoryInputStream";
     static objectType = "gobject";
@@ -26,7 +33,7 @@ export class MemoryInputStream extends InputStream {
             setInstantiating(false);
             this.id = call("libgio-2.0.so.0", "g_memory_input_stream_new", [], {
                 type: "gobject",
-                borrowed: true,
+                borrowed: false,
             });
         }
         else {
@@ -403,12 +410,26 @@ export class MemoryInputStream extends InputStream {
         return result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -1,4 +1,5 @@
 import { NativeObject } from "../../native/base.js";
+import { Cancellable } from "./cancellable.js";
 /**
  * `GMemoryMonitor` will monitor system memory and suggest to the application
  * when to free memory so as to leave more room for other applications.
@@ -52,4 +53,46 @@ import { NativeObject } from "../../native/base.js";
 export declare class MemoryMonitor extends NativeObject {
     static readonly glibTypeName: string;
     static readonly objectType: "interface";
+    /**
+     * Initializes the object implementing the interface.
+     *
+     * This method is intended for language bindings. If writing in C,
+     * g_initable_new() should typically be used instead.
+     *
+     * The object must be initialized before any real use after initial
+     * construction, either with this function or g_async_initable_init_async().
+     *
+     * Implementations may also support cancellation. If `cancellable` is not %NULL,
+     * then initialization 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 `cancellable` is not %NULL and
+     * the object doesn't support cancellable initialization the error
+     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+     *
+     * If the object is not initialized, or initialization returns with an
+     * error, then all operations on the object except g_object_ref() and
+     * g_object_unref() are considered to be invalid, and have undefined
+     * behaviour. See the [description]{@link Gio.Initable#description} for more details.
+     *
+     * Callers should not assume that a class which implements #GInitable can be
+     * initialized multiple times, unless the class explicitly documents itself as
+     * supporting this. Generally, a class’ implementation of init() can assume
+     * (and assert) that it will only be called once. Previously, this documentation
+     * recommended all #GInitable implementations should be idempotent; that
+     * recommendation was relaxed in GLib 2.54.
+     *
+     * If a class explicitly supports being initialized multiple times, it is
+     * recommended that the method is idempotent: multiple calls with the same
+     * arguments should return the same results. Only the first call initializes
+     * the object; further calls return the result of the first call.
+     *
+     * One reason why a class might need to support idempotent initialization is if
+     * it is designed to be used via the singleton pattern, with a
+     * #GObjectClass.constructor that sometimes returns an existing instance.
+     * In this pattern, a caller would expect to be able to call g_initable_init()
+     * on the result of g_object_new(), regardless of whether it is in fact a new
+     * instance.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
+    init(cancellable?: Cancellable): boolean;
 }

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

@@ -1,3 +1,5 @@
+import { call } from "../../batch.js";
+import { NativeError } from "../../native/error.js";
 import { NativeObject } from "../../native/base.js";
 /**
  * `GMemoryMonitor` will monitor system memory and suggest to the application
@@ -52,4 +54,74 @@ import { NativeObject } from "../../native/base.js";
 export class MemoryMonitor extends NativeObject {
     static glibTypeName = "GMemoryMonitor";
     static objectType = "interface";
+    /**
+     * Initializes the object implementing the interface.
+     *
+     * This method is intended for language bindings. If writing in C,
+     * g_initable_new() should typically be used instead.
+     *
+     * The object must be initialized before any real use after initial
+     * construction, either with this function or g_async_initable_init_async().
+     *
+     * Implementations may also support cancellation. If `cancellable` is not %NULL,
+     * then initialization 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 `cancellable` is not %NULL and
+     * the object doesn't support cancellable initialization the error
+     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+     *
+     * If the object is not initialized, or initialization returns with an
+     * error, then all operations on the object except g_object_ref() and
+     * g_object_unref() are considered to be invalid, and have undefined
+     * behaviour. See the [description]{@link Gio.Initable#description} for more details.
+     *
+     * Callers should not assume that a class which implements #GInitable can be
+     * initialized multiple times, unless the class explicitly documents itself as
+     * supporting this. Generally, a class’ implementation of init() can assume
+     * (and assert) that it will only be called once. Previously, this documentation
+     * recommended all #GInitable implementations should be idempotent; that
+     * recommendation was relaxed in GLib 2.54.
+     *
+     * If a class explicitly supports being initialized multiple times, it is
+     * recommended that the method is idempotent: multiple calls with the same
+     * arguments should return the same results. Only the first call initializes
+     * the object; further calls return the result of the first call.
+     *
+     * One reason why a class might need to support idempotent initialization is if
+     * it is designed to be used via the singleton pattern, with a
+     * #GObjectClass.constructor that sometimes returns an existing instance.
+     * In this pattern, a caller would expect to be able to call g_initable_init()
+     * on the result of g_object_new(), regardless of whether it is in fact a new
+     * instance.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
+    init(cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_initable_init", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: cancellable?.id ?? cancellable,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], { type: "boolean" });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
+        return result;
+    }
 }

package/dist/generated/gio/memory-output-stream.d.ts

@@ -4,13 +4,6 @@ import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import { OutputStream } from "./output-stream.js";
-/**
- * `GMemoryOutputStream` is a class for using arbitrary
- * memory chunks as output for GIO streaming output operations.
- *
- * As of GLib 2.34, `GMemoryOutputStream` trivially implements
- * {@link Gio.PollableOutputStream}: it always polls as ready.
- */
 export declare class MemoryOutputStream extends OutputStream {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -25,7 +18,7 @@ export declare class MemoryOutputStream extends OutputStream {
      * Note that the returned pointer may become invalid on the next
      * write or truncate operation on the stream.
      */
-    getDataMemoryOutputStream(): number | null;
+    memoryOutputStreamGetData(): number | null;
     /**
      * Returns the number of bytes from the start up to including the last
      * byte written in the stream that has not been truncated away.
@@ -62,7 +55,7 @@ export declare class MemoryOutputStream extends OutputStream {
      *
      * `ostream` must be closed before calling this function.
      */
-    stealDataMemoryOutputStream(): number | null;
+    memoryOutputStreamStealData(): number | null;
     /**
      * Checks if `stream` is actually pollable. Some classes may implement
      * #GPollableOutputStream but have only certain instances of that