@gtkx/ffi 0.6.1 → 0.8.0

package/dist/generated/giounix/index.js

@@ -8,3 +8,4 @@ export * from "./output-stream.js";
 export * from "./desktop-app-info-lookup.js";
 export * from "./file-descriptor-based.js";
 export * from "./functions.js";
+export * from "./constants.js";

package/dist/generated/giounix/input-stream.d.ts

@@ -1,3 +1,5 @@
+import { Ref } from "@gtkx/native";
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 /**
@@ -37,6 +39,65 @@ export declare class InputStream extends Gio.InputStream {
      * @param closeFd - %TRUE to close the file descriptor when done
      */
     setCloseFd(closeFd: boolean): void;
+    /**
+     * Checks if `stream` is actually pollable. Some classes may implement
+     * #GPollableInputStream but have only certain instances of that class
+     * be pollable. If this method returns %FALSE, then the behavior of
+     * other #GPollableInputStream methods is undefined.
+     *
+     * For any given stream, the value returned by this method is constant;
+     * a stream cannot switch from pollable to non-pollable or vice versa.
+     */
+    canPoll(): boolean;
+    /**
+     * Creates a #GSource that triggers when `stream` can be read, or
+     * `cancellable` is triggered or an error occurs. The callback on the
+     * source is of the #GPollableSourceFunc type.
+     *
+     * As with g_pollable_input_stream_is_readable(), it is possible that
+     * the stream may not actually be readable even after the source
+     * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+     * rather than g_input_stream_read() from the callback.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for @stream.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    createSource(cancellable?: Gio.Cancellable | null): GLib.Source;
+    /**
+     * Checks if `stream` can be read.
+     *
+     * Note that some stream types may not be able to implement this 100%
+     * reliably, and it is possible that a call to g_input_stream_read()
+     * after this returns %TRUE would still block. To guarantee
+     * non-blocking behavior, you should always use
+     * g_pollable_input_stream_read_nonblocking(), which will return a
+     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for @stream.
+     */
+    isReadable(): boolean;
+    /**
+     * Attempts to read up to `count` bytes from `stream` into @buffer, as
+     * with g_input_stream_read(). If `stream` is not currently readable,
+     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+     * use g_pollable_input_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is readable.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for @stream.
+     * @param buffer - a
+     * @param count - the number of bytes you want to read
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    readNonblocking(buffer: Ref<number[]>, count: number, cancellable?: Gio.Cancellable | null): number;
     connect(signal: "notify", handler: (self: InputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,8 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject, getBoxed, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as GLib from "../glib/index.js";
 import * as Gio from "../gio/index.js";
 /**
  * `GUnixInputStream` implements [class@Gio.InputStream] for reading from a UNIX
@@ -83,6 +87,139 @@ export class InputStream extends Gio.InputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if `stream` is actually pollable. Some classes may implement
+     * #GPollableInputStream but have only certain instances of that class
+     * be pollable. If this method returns %FALSE, then the behavior of
+     * other #GPollableInputStream methods is undefined.
+     *
+     * For any given stream, the value returned by this method is constant;
+     * a stream cannot switch from pollable to non-pollable or vice versa.
+     */
+    canPoll() {
+        return call("libgio-2.0.so.0", "g_pollable_input_stream_can_poll", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Creates a #GSource that triggers when `stream` can be read, or
+     * `cancellable` is triggered or an error occurs. The callback on the
+     * source is of the #GPollableSourceFunc type.
+     *
+     * As with g_pollable_input_stream_is_readable(), it is possible that
+     * the stream may not actually be readable even after the source
+     * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+     * rather than g_input_stream_read() from the callback.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for @stream.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    createSource(cancellable) {
+        const ptr = call("libgio-2.0.so.0", "g_pollable_input_stream_create_source", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: cancellable?.id ?? cancellable,
+                optional: true,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GSource",
+            lib: "libgio-2.0.so.0",
+        });
+        return getBoxed(ptr, GLib.Source);
+    }
+    /**
+     * Checks if `stream` can be read.
+     *
+     * Note that some stream types may not be able to implement this 100%
+     * reliably, and it is possible that a call to g_input_stream_read()
+     * after this returns %TRUE would still block. To guarantee
+     * non-blocking behavior, you should always use
+     * g_pollable_input_stream_read_nonblocking(), which will return a
+     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for @stream.
+     */
+    isReadable() {
+        return call("libgio-2.0.so.0", "g_pollable_input_stream_is_readable", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Attempts to read up to `count` bytes from `stream` into @buffer, as
+     * with g_input_stream_read(). If `stream` is not currently readable,
+     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+     * use g_pollable_input_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is readable.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for @stream.
+     * @param buffer - a
+     * @param count - the number of bytes you want to read
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    readNonblocking(buffer, count, cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_pollable_input_stream_read_nonblocking", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: { type: "int", size: 8, unsigned: true },
+                    },
+                },
+                value: buffer,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: count,
+            },
+            {
+                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: "int", size: 64, unsigned: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
+        return result;
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/giounix/mount-entry.d.ts

@@ -9,6 +9,7 @@ export declare class MountEntry {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): MountEntry;
     /**
      * Gets a [struct@GioUnix.MountEntry] for a given mount path.
      *

package/dist/generated/giounix/mount-entry.js

@@ -1,4 +1,7 @@
-import { call, getObject, registerType } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getBoxed, getInterface } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as Gio from "../gio/index.js";
 /**
  * Defines a Unix mount entry (e.g. `/media/cdrom`).
  * This corresponds roughly to a mtab entry.
@@ -12,6 +15,11 @@ export class MountEntry {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(MountEntry.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /**
      * Gets a [struct@GioUnix.MountEntry] for a given mount path.
      *
@@ -131,7 +139,7 @@ export class MountEntry {
             innerType: "GUnixMountEntry",
             lib: "libgio-2.0.so.0",
         });
-        return getObject(ptr);
+        return getBoxed(ptr, MountEntry);
     }
     /**
      * Frees a Unix mount.
@@ -270,7 +278,7 @@ export class MountEntry {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Guesses the name of a Unix mount entry.
@@ -321,7 +329,7 @@ export class MountEntry {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Checks if a Unix mount is mounted read only.

package/dist/generated/giounix/mount-monitor.js

@@ -1,4 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, isInstantiating, setInstantiating } from "../../native.js";
+import { registerType } from "../../registry.js";
 import * as GObject from "../gobject/index.js";
 /**
  * Watches for changes to the set of mount entries and mount points in the

package/dist/generated/giounix/mount-point.d.ts

@@ -9,6 +9,7 @@ export declare class MountPoint {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): MountPoint;
     /**
      * Gets a [struct@GioUnix.MountPoint] for a given mount path.
      *

package/dist/generated/giounix/mount-point.js

@@ -1,4 +1,7 @@
-import { call, getObject, registerType } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getBoxed, getInterface } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as Gio from "../gio/index.js";
 /**
  * Defines a Unix mount point (e.g. `/dev`).
  * This corresponds roughly to a fstab entry.
@@ -12,6 +15,11 @@ export class MountPoint {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(MountPoint.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /**
      * Gets a [struct@GioUnix.MountPoint] for a given mount path.
      *
@@ -92,7 +100,7 @@ export class MountPoint {
             innerType: "GUnixMountPoint",
             lib: "libgio-2.0.so.0",
         });
-        return getObject(ptr);
+        return getBoxed(ptr, MountPoint);
     }
     /**
      * Frees a Unix mount point.
@@ -205,7 +213,7 @@ export class MountPoint {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Guesses the name of a Unix mount point.
@@ -240,7 +248,7 @@ export class MountPoint {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Checks if a Unix mount point is a loopback device.

package/dist/generated/giounix/output-stream.d.ts

@@ -1,3 +1,5 @@
+import { Ref } from "@gtkx/native";
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 /**
@@ -37,6 +39,95 @@ export declare class OutputStream extends Gio.OutputStream {
      * @param closeFd - %TRUE to close the file descriptor when done
      */
     setCloseFd(closeFd: boolean): void;
+    /**
+     * Checks if `stream` is actually pollable. Some classes may implement
+     * #GPollableOutputStream but have only certain instances of that
+     * class be pollable. If this method returns %FALSE, then the behavior
+     * of other #GPollableOutputStream methods is undefined.
+     *
+     * For any given stream, the value returned by this method is constant;
+     * a stream cannot switch from pollable to non-pollable or vice versa.
+     */
+    canPoll(): boolean;
+    /**
+     * Creates a #GSource that triggers when `stream` can be written, or
+     * `cancellable` is triggered or an error occurs. The callback on the
+     * source is of the #GPollableSourceFunc type.
+     *
+     * As with g_pollable_output_stream_is_writable(), it is possible that
+     * the stream may not actually be writable even after the source
+     * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+     * rather than g_output_stream_write() from the callback.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    createSource(cancellable?: Gio.Cancellable | null): GLib.Source;
+    /**
+     * Checks if `stream` can be written.
+     *
+     * Note that some stream types may not be able to implement this 100%
+     * reliably, and it is possible that a call to g_output_stream_write()
+     * after this returns %TRUE would still block. To guarantee
+     * non-blocking behavior, you should always use
+     * g_pollable_output_stream_write_nonblocking(), which will return a
+     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     */
+    isWritable(): boolean;
+    /**
+     * Attempts to write up to `count` bytes from `buffer` to @stream, as
+     * with g_output_stream_write(). If `stream` is not currently writable,
+     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `buffer` and
+     * `count` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param buffer - a buffer to write
+     * @param count - the number of bytes you want to write
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    writeNonblocking(buffer: number[], count: number, cancellable?: Gio.Cancellable | null): number;
+    /**
+     * Attempts to write the bytes contained in the `n_vectors` `vectors` to @stream,
+     * as with g_output_stream_writev(). If `stream` is not currently writable,
+     * this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable. `error` will *not* be
+     * set in that case.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `vectors` and
+     * `n_vectors` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param vectors - the buffer containing the #GOutputVectors to write.
+     * @param nVectors - the number of vectors to write
+     * @param bytesWritten - location to store the number of bytes that were
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    writevNonblocking(vectors: number[], nVectors: number, bytesWritten?: Ref<number> | null, cancellable?: Gio.Cancellable | null): Gio.PollableReturn;
     connect(signal: "notify", handler: (self: OutputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/giounix/output-stream.js

@@ -1,4 +1,8 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject, getBoxed, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as GLib from "../glib/index.js";
 import * as Gio from "../gio/index.js";
 /**
  * `GUnixOutputStream` implements [class@Gio.OutputStream] for writing to a UNIX
@@ -83,6 +87,213 @@ export class OutputStream extends Gio.OutputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if `stream` is actually pollable. Some classes may implement
+     * #GPollableOutputStream but have only certain instances of that
+     * class be pollable. If this method returns %FALSE, then the behavior
+     * of other #GPollableOutputStream methods is undefined.
+     *
+     * For any given stream, the value returned by this method is constant;
+     * a stream cannot switch from pollable to non-pollable or vice versa.
+     */
+    canPoll() {
+        return call("libgio-2.0.so.0", "g_pollable_output_stream_can_poll", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Creates a #GSource that triggers when `stream` can be written, or
+     * `cancellable` is triggered or an error occurs. The callback on the
+     * source is of the #GPollableSourceFunc type.
+     *
+     * As with g_pollable_output_stream_is_writable(), it is possible that
+     * the stream may not actually be writable even after the source
+     * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+     * rather than g_output_stream_write() from the callback.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    createSource(cancellable) {
+        const ptr = call("libgio-2.0.so.0", "g_pollable_output_stream_create_source", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: cancellable?.id ?? cancellable,
+                optional: true,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GSource",
+            lib: "libgio-2.0.so.0",
+        });
+        return getBoxed(ptr, GLib.Source);
+    }
+    /**
+     * Checks if `stream` can be written.
+     *
+     * Note that some stream types may not be able to implement this 100%
+     * reliably, and it is possible that a call to g_output_stream_write()
+     * after this returns %TRUE would still block. To guarantee
+     * non-blocking behavior, you should always use
+     * g_pollable_output_stream_write_nonblocking(), which will return a
+     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     */
+    isWritable() {
+        return call("libgio-2.0.so.0", "g_pollable_output_stream_is_writable", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Attempts to write up to `count` bytes from `buffer` to @stream, as
+     * with g_output_stream_write(). If `stream` is not currently writable,
+     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `buffer` and
+     * `count` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param buffer - a buffer to write
+     * @param count - the number of bytes you want to write
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    writeNonblocking(buffer, count, cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_pollable_output_stream_write_nonblocking", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 8, unsigned: true },
+                },
+                value: buffer,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: count,
+            },
+            {
+                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: "int", size: 64, unsigned: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
+        return result;
+    }
+    /**
+     * Attempts to write the bytes contained in the `n_vectors` `vectors` to @stream,
+     * as with g_output_stream_writev(). If `stream` is not currently writable,
+     * this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable. `error` will *not* be
+     * set in that case.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `vectors` and
+     * `n_vectors` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param vectors - the buffer containing the #GOutputVectors to write.
+     * @param nVectors - the number of vectors to write
+     * @param bytesWritten - location to store the number of bytes that were
+     * @param cancellable - a #GCancellable, or %NULL
+     */
+    writevNonblocking(vectors, nVectors, bytesWritten, cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_pollable_output_stream_writev_nonblocking", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 64, unsigned: true },
+                },
+                value: vectors,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: nVectors,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 64, unsigned: true },
+                },
+                value: bytesWritten,
+                optional: true,
+            },
+            {
+                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: "int", size: 32, unsigned: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
+        return result;
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/glib/array.d.ts

@@ -7,6 +7,7 @@ export declare class Array {
     id: unknown;
     constructor(init?: ArrayInit);
     protected createPtr(init: ArrayInit): unknown;
+    static fromPtr(ptr: unknown): Array;
     /**
      * a pointer to the element data. The data may be moved as
      * elements are added to the `GArray`.