@gtkx/ffi 0.7.0 → 0.9.0

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

@@ -1,4 +1,7 @@
-import { call, NativeError, getObject, registerType } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject } from "../../native.js";
+import { registerType } from "../../registry.js";
 import * as GObject from "../gobject/index.js";
 /**
  * `GOutputStream` is a base class for implementing streaming output.
@@ -96,49 +99,6 @@ export class OutputStream 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_output_stream_close_finish() to get
-     * the result of the operation.
-     *
-     * For behaviour details see g_output_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_output_stream_close_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Closes an output stream.
      * @param result - a #GAsyncResult.
@@ -212,46 +172,6 @@ export class OutputStream extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Forces an asynchronous write of all user-space buffered data for
-     * the given @stream.
-     * For behaviour details see g_output_stream_flush().
-     *
-     * When the operation is finished `callback` will be
-     * called. You can then call g_output_stream_flush_finish() to get the
-     * result of the operation.
-     * @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
-     */
-    flushAsync(ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_flush_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes flushing an output stream.
      * @param result - a GAsyncResult.
@@ -392,56 +312,6 @@ export class OutputStream extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Splices a stream asynchronously.
-     * When the operation is finished `callback` will be called.
-     * You can then call g_output_stream_splice_finish() to get the
-     * result of the operation.
-     *
-     * For the synchronous, blocking version of this function, see
-     * g_output_stream_splice().
-     * @param source - a #GInputStream.
-     * @param flags - a set of #GOutputStreamSpliceFlags.
-     * @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(source, flags, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_splice_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: source?.id ?? source,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous stream splice operation.
      * @param result - a #GAsyncResult.
@@ -609,67 +479,6 @@ export class OutputStream extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Request an asynchronous write of `count` bytes from `buffer` into
-     * the stream. When the operation is finished `callback` will be called.
-     * You can then call g_output_stream_write_all_finish() to get the result of the
-     * operation.
-     *
-     * This is the asynchronous version of g_output_stream_write_all().
-     *
-     * Call g_output_stream_write_all_finish() to collect the result.
-     *
-     * Any outstanding I/O request with higher priority (lower numerical
-     * value) will be executed before an outstanding request with lower
-     * priority. Default priority is %G_PRIORITY_DEFAULT.
-     *
-     * Note that no copy of `buffer` will be made, so it must stay valid
-     * until `callback` is called.
-     * @param buffer - the buffer containing the data to write
-     * @param count - the number of bytes to write
-     * @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
-     */
-    writeAllAsync(buffer, count, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_write_all_async", [
-            {
-                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: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous stream write operation started with
      * g_output_stream_write_all_async().
@@ -720,87 +529,6 @@ export class OutputStream extends GObject.GObject {
         }
         return _result;
     }
-    /**
-     * Request an asynchronous write of `count` bytes from `buffer` into
-     * the stream. When the operation is finished `callback` will be called.
-     * You can then call g_output_stream_write_finish() to get the result of the
-     * operation.
-     *
-     * During an async request no other sync and async calls are allowed,
-     * and will result in %G_IO_ERROR_PENDING errors.
-     *
-     * A value of `count` larger than %G_MAXSSIZE will cause a
-     * %G_IO_ERROR_INVALID_ARGUMENT error.
-     *
-     * On success, the number of bytes written will be passed to the
-     * @callback. It is not an error if this is not the same as the
-     * requested size, as it can happen e.g. on a partial I/O error,
-     * but generally we try to write as many bytes as requested.
-     *
-     * You are guaranteed that this method will never fail with
-     * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
-     * method will just wait until this changes.
-     *
-     * Any outstanding I/O request with higher priority (lower numerical
-     * value) will be executed before an outstanding request with lower
-     * priority. Default priority is %G_PRIORITY_DEFAULT.
-     *
-     * 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.
-     *
-     * For the synchronous, blocking version of this function, see
-     * g_output_stream_write().
-     *
-     * Note that no copy of `buffer` will be made, so it must stay valid
-     * until `callback` is called. See g_output_stream_write_bytes_async()
-     * for a #GBytes version that will automatically hold a reference to
-     * the contents (without copying) for the duration of the call.
-     * @param buffer - the buffer containing the data to write.
-     * @param count - the number of bytes to write
-     * @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
-     */
-    writeAsync(buffer, count, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_write_async", [
-            {
-                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: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * A wrapper function for g_output_stream_write() which takes a
      * #GBytes as input.  This can be more convenient for use by language
@@ -854,62 +582,6 @@ export class OutputStream extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * This function is similar to g_output_stream_write_async(), but
-     * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
-     * this allows the stream to avoid taking a copy of the data.
-     *
-     * However, note that this function may still perform partial writes,
-     * just like g_output_stream_write_async(). If that occurs, to continue
-     * writing, you will need to create a new #GBytes containing just the
-     * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
-     * #GBytes instance multiple times potentially can result in duplicated
-     * data in the output stream.
-     *
-     * For the synchronous, blocking version of this function, see
-     * g_output_stream_write_bytes().
-     * @param bytes - The bytes to write
-     * @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
-     */
-    writeBytesAsync(bytes, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_write_bytes_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GBytes",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: bytes?.id ?? bytes,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a stream write-from-#GBytes operation.
      * @param result - a #GAsyncResult.
@@ -1126,68 +798,6 @@ export class OutputStream extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
-     * the stream. When the operation is finished `callback` will be called.
-     * You can then call g_output_stream_writev_all_finish() to get the result of the
-     * operation.
-     *
-     * This is the asynchronous version of g_output_stream_writev_all().
-     *
-     * Call g_output_stream_writev_all_finish() to collect the result.
-     *
-     * Any outstanding I/O request with higher priority (lower numerical
-     * value) will be executed before an outstanding request with lower
-     * priority. Default priority is %G_PRIORITY_DEFAULT.
-     *
-     * Note that no copy of `vectors` will be made, so it must stay valid
-     * until `callback` is called. The content of the individual elements
-     * of `vectors` might be changed by this function.
-     * @param vectors - the buffer containing the #GOutputVectors to write.
-     * @param nVectors - the number of vectors to write
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    writevAllAsync(vectors, nVectors, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_writev_all_async", [
-            {
-                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: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous stream write operation started with
      * g_output_stream_writev_all_async().
@@ -1238,82 +848,6 @@ export class OutputStream extends GObject.GObject {
         }
         return _result;
     }
-    /**
-     * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
-     * the stream. When the operation is finished `callback` will be called.
-     * You can then call g_output_stream_writev_finish() to get the result of the
-     * operation.
-     *
-     * During an async request no other sync and async calls are allowed,
-     * and will result in %G_IO_ERROR_PENDING errors.
-     *
-     * On success, the number of bytes written will be passed to the
-     * @callback. It is not an error if this is not the same as the
-     * requested size, as it can happen e.g. on a partial I/O error,
-     * but generally we try to write as many bytes as requested.
-     *
-     * You are guaranteed that this method will never fail with
-     * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
-     * method will just wait until this changes.
-     *
-     * Any outstanding I/O request with higher priority (lower numerical
-     * value) will be executed before an outstanding request with lower
-     * priority. Default priority is %G_PRIORITY_DEFAULT.
-     *
-     * 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.
-     *
-     * For the synchronous, blocking version of this function, see
-     * g_output_stream_writev().
-     *
-     * Note that no copy of `vectors` will be made, so it must stay valid
-     * until `callback` is called.
-     * @param vectors - the buffer containing the #GOutputVectors to write.
-     * @param nVectors - the number of vectors to write
-     * @param ioPriority - the I/O priority of the request.
-     * @param cancellable - optional #GCancellable object, %NULL to ignore.
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    writevAsync(vectors, nVectors, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_output_stream_writev_async", [
-            {
-                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: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a stream writev operation.
      * @param result - a #GAsyncResult.

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

@@ -40,16 +40,6 @@ export declare class Permission extends GObject.GObject {
      * @param cancellable - a #GCancellable, or %NULL
      */
     acquire(cancellable?: Cancellable | null): boolean;
-    /**
-     * Attempts to acquire the permission represented by @permission.
-     *
-     * This is the first half of the asynchronous version of
-     * g_permission_acquire().
-     * @param cancellable - a #GCancellable, or %NULL
-     * @param callback - the #GAsyncReadyCallback to call when done
-     * @param userData - the user data to pass to @callback
-     */
-    acquireAsync(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Collects the result of attempting to acquire the permission
      * represented by @permission.
@@ -107,16 +97,6 @@ export declare class Permission extends GObject.GObject {
      * @param cancellable - a #GCancellable, or %NULL
      */
     release(cancellable?: Cancellable | null): boolean;
-    /**
-     * Attempts to release the permission represented by @permission.
-     *
-     * This is the first half of the asynchronous version of
-     * g_permission_release().
-     * @param cancellable - a #GCancellable, or %NULL
-     * @param callback - the #GAsyncReadyCallback to call when done
-     * @param userData - the user data to pass to @callback
-     */
-    releaseAsync(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Collects the result of attempting to release the permission
      * represented by @permission.

package/dist/generated/gio/permission.js

@@ -1,4 +1,7 @@
-import { call, NativeError, getObject, registerType } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject } from "../../native.js";
+import { registerType } from "../../registry.js";
 import * as GObject from "../gobject/index.js";
 /**
  * A `GPermission` represents the status of the caller’s permission to
@@ -69,38 +72,6 @@ export class Permission extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Attempts to acquire the permission represented by @permission.
-     *
-     * This is the first half of the asynchronous version of
-     * g_permission_acquire().
-     * @param cancellable - a #GCancellable, or %NULL
-     * @param callback - the #GAsyncReadyCallback to call when done
-     * @param userData - the user data to pass to @callback
-     */
-    acquireAsync(cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_permission_acquire_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Collects the result of attempting to acquire the permission
      * represented by @permission.
@@ -253,38 +224,6 @@ export class Permission extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Attempts to release the permission represented by @permission.
-     *
-     * This is the first half of the asynchronous version of
-     * g_permission_release().
-     * @param cancellable - a #GCancellable, or %NULL
-     * @param callback - the #GAsyncReadyCallback to call when done
-     * @param userData - the user data to pass to @callback
-     */
-    releaseAsync(cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_permission_release_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Collects the result of attempting to release the permission
      * represented by @permission.

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

@@ -1,4 +1,7 @@
-import { call, NativeError, getBoxed } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getBoxed } from "../../native.js";
+import * as GLib from "../glib/index.js";
 /**
  * `GPollableInputStream` is implemented by [class@Gio.InputStream]s that
  * can be polled for readiness to read. This can be used when
@@ -67,7 +70,7 @@ export class PollableInputStream {
             innerType: "GSource",
             lib: "libgio-2.0.so.0",
         });
-        return getBoxed(ptr, "GSource");
+        return getBoxed(ptr, GLib.Source);
     }
     /**
      * Checks if `stream` can be read.

package/dist/generated/gio/pollable-output-stream.js

@@ -1,4 +1,7 @@
-import { call, NativeError, getBoxed } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getBoxed } from "../../native.js";
+import * as GLib from "../glib/index.js";
 /**
  * `GPollableOutputStream` is implemented by [class@Gio.OutputStream]s that
  * can be polled for readiness to write. This can be used when
@@ -67,7 +70,7 @@ export class PollableOutputStream {
             innerType: "GSource",
             lib: "libgio-2.0.so.0",
         });
-        return getBoxed(ptr, "GSource");
+        return getBoxed(ptr, GLib.Source);
     }
     /**
      * Checks if `stream` can be written.

package/dist/generated/gio/power-profile-monitor.js

@@ -1,4 +1,4 @@
-import { call } from "@gtkx/ffi";
+import { call } from "../../batch.js";
 /**
  * `GPowerProfileMonitor` makes it possible for applications as well as OS
  * components to monitor system power profiles and act upon them. It currently