@gtkx/ffi 0.1.45 → 0.1.47

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

@@ -1,18 +1,130 @@
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A `GPermission` represents the status of the caller’s permission to
+ * perform a certain action.
+ *
+ * You can query if the action is currently allowed and if it is
+ * possible to acquire the permission so that the action will be allowed
+ * in the future.
+ *
+ * There is also an API to actually acquire the permission and one to
+ * release it.
+ *
+ * As an example, a `GPermission` might represent the ability for the
+ * user to write to a [class@Gio.Settings] object.  This `GPermission` object
+ * could then be used to decide if it is appropriate to show a “Click here to
+ * unlock” button in a dialog and to provide the mechanism to invoke
+ * when that button is clicked.
+ */
 export declare class Permission extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Attempts to acquire the permission represented by @permission.
+     *
+     * The precise method by which this happens depends on the permission
+     * and the underlying authentication mechanism.  A simple example is
+     * that a dialog may appear asking the user to enter their password.
+     *
+     * You should check with g_permission_get_can_acquire() before calling
+     * this function.
+     *
+     * If the permission is acquired then %TRUE is returned.  Otherwise,
+     * %FALSE is returned and `error` is set appropriately.
+     *
+     * This call is blocking, likely for a very long time (in the case that
+     * user interaction is required).  See g_permission_acquire_async() for
+     * the non-blocking version.
+     * @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.
+     *
+     * This is the second half of the asynchronous version of
+     * g_permission_acquire().
+     * @param result - the #GAsyncResult given to the #GAsyncReadyCallback
+     */
     acquireFinish(result: AsyncResult): boolean;
+    /**
+     * Gets the value of the 'allowed' property.  This property is %TRUE if
+     * the caller currently has permission to perform the action that
+     * `permission` represents the permission to perform.
+     */
     getAllowed(): boolean;
+    /**
+     * Gets the value of the 'can-acquire' property.  This property is %TRUE
+     * if it is generally possible to acquire the permission by calling
+     * g_permission_acquire().
+     */
     getCanAcquire(): boolean;
+    /**
+     * Gets the value of the 'can-release' property.  This property is %TRUE
+     * if it is generally possible to release the permission by calling
+     * g_permission_release().
+     */
     getCanRelease(): boolean;
+    /**
+     * This function is called by the #GPermission implementation to update
+     * the properties of the permission.  You should never call this
+     * function except from a #GPermission implementation.
+     *
+     * GObject notify signals are generated, as appropriate.
+     * @param allowed - the new value for the 'allowed' property
+     * @param canAcquire - the new value for the 'can-acquire' property
+     * @param canRelease - the new value for the 'can-release' property
+     */
     implUpdate(allowed: boolean, canAcquire: boolean, canRelease: boolean): void;
+    /**
+     * Attempts to release the permission represented by @permission.
+     *
+     * The precise method by which this happens depends on the permission
+     * and the underlying authentication mechanism.  In most cases the
+     * permission will be dropped immediately without further action.
+     *
+     * You should check with g_permission_get_can_release() before calling
+     * this function.
+     *
+     * If the permission is released then %TRUE is returned.  Otherwise,
+     * %FALSE is returned and `error` is set appropriately.
+     *
+     * This call is blocking, likely for a very long time (in the case that
+     * user interaction is required).  See g_permission_release_async() for
+     * the non-blocking version.
+     * @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.
+     *
+     * This is the second half of the asynchronous version of
+     * g_permission_release().
+     * @param result - the #GAsyncResult given to the #GAsyncReadyCallback
+     */
     releaseFinish(result: AsyncResult): boolean;
     connect(signal: "notify", handler: (self: Permission, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/permission.js

@@ -1,6 +1,23 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * A `GPermission` represents the status of the caller’s permission to
+ * perform a certain action.
+ *
+ * You can query if the action is currently allowed and if it is
+ * possible to acquire the permission so that the action will be allowed
+ * in the future.
+ *
+ * There is also an API to actually acquire the permission and one to
+ * release it.
+ *
+ * As an example, a `GPermission` might represent the ability for the
+ * user to write to a [class@Gio.Settings] object.  This `GPermission` object
+ * could then be used to decide if it is appropriate to show a “Click here to
+ * unlock” button in a dialog and to provide the mechanism to invoke
+ * when that button is clicked.
+ */
 export class Permission extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -16,6 +33,24 @@ export class Permission extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Attempts to acquire the permission represented by @permission.
+     *
+     * The precise method by which this happens depends on the permission
+     * and the underlying authentication mechanism.  A simple example is
+     * that a dialog may appear asking the user to enter their password.
+     *
+     * You should check with g_permission_get_can_acquire() before calling
+     * this function.
+     *
+     * If the permission is acquired then %TRUE is returned.  Otherwise,
+     * %FALSE is returned and `error` is set appropriately.
+     *
+     * This call is blocking, likely for a very long time (in the case that
+     * user interaction is required).  See g_permission_acquire_async() for
+     * the non-blocking version.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     acquire(cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_permission_acquire", [
@@ -45,6 +80,15 @@ 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", [
             {
@@ -68,6 +112,14 @@ export class Permission extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Collects the result of attempting to acquire the permission
+     * represented by @permission.
+     *
+     * This is the second half of the asynchronous version of
+     * g_permission_acquire().
+     * @param result - the #GAsyncResult given to the #GAsyncReadyCallback
+     */
     acquireFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_permission_acquire_finish", [
@@ -96,6 +148,11 @@ export class Permission extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Gets the value of the 'allowed' property.  This property is %TRUE if
+     * the caller currently has permission to perform the action that
+     * `permission` represents the permission to perform.
+     */
     getAllowed() {
         return call("libgio-2.0.so.0", "g_permission_get_allowed", [
             {
@@ -104,6 +161,11 @@ export class Permission extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value of the 'can-acquire' property.  This property is %TRUE
+     * if it is generally possible to acquire the permission by calling
+     * g_permission_acquire().
+     */
     getCanAcquire() {
         return call("libgio-2.0.so.0", "g_permission_get_can_acquire", [
             {
@@ -112,6 +174,11 @@ export class Permission extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value of the 'can-release' property.  This property is %TRUE
+     * if it is generally possible to release the permission by calling
+     * g_permission_release().
+     */
     getCanRelease() {
         return call("libgio-2.0.so.0", "g_permission_get_can_release", [
             {
@@ -120,6 +187,16 @@ export class Permission extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * This function is called by the #GPermission implementation to update
+     * the properties of the permission.  You should never call this
+     * function except from a #GPermission implementation.
+     *
+     * GObject notify signals are generated, as appropriate.
+     * @param allowed - the new value for the 'allowed' property
+     * @param canAcquire - the new value for the 'can-acquire' property
+     * @param canRelease - the new value for the 'can-release' property
+     */
     implUpdate(allowed, canAcquire, canRelease) {
         call("libgio-2.0.so.0", "g_permission_impl_update", [
             {
@@ -140,6 +217,24 @@ export class Permission extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Attempts to release the permission represented by @permission.
+     *
+     * The precise method by which this happens depends on the permission
+     * and the underlying authentication mechanism.  In most cases the
+     * permission will be dropped immediately without further action.
+     *
+     * You should check with g_permission_get_can_release() before calling
+     * this function.
+     *
+     * If the permission is released then %TRUE is returned.  Otherwise,
+     * %FALSE is returned and `error` is set appropriately.
+     *
+     * This call is blocking, likely for a very long time (in the case that
+     * user interaction is required).  See g_permission_release_async() for
+     * the non-blocking version.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     release(cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_permission_release", [
@@ -169,6 +264,15 @@ 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", [
             {
@@ -192,6 +296,14 @@ export class Permission extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Collects the result of attempting to release the permission
+     * represented by @permission.
+     *
+     * This is the second half of the asynchronous version of
+     * g_permission_release().
+     * @param result - the #GAsyncResult given to the #GAsyncReadyCallback
+     */
     releaseFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_permission_release_finish", [

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

@@ -1,12 +1,78 @@
 import { Ref } from "@gtkx/native";
 import { Cancellable } from "./cancellable.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
+ * interfacing with a non-GIO API that expects
+ * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
+ *
+ * Some classes may implement `GPollableInputStream` but have only certain
+ * instances of that class be pollable. If [method@Gio.PollableInputStream.can_poll]
+ * returns false, then the behavior of other `GPollableInputStream` methods is
+ * undefined.
+ */
 export declare class PollableInputStream {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): PollableInputStream;
+    /**
+     * 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?: 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?: Cancellable | null): number;
 }

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

@@ -1,6 +1,17 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 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
+ * interfacing with a non-GIO API that expects
+ * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
+ *
+ * Some classes may implement `GPollableInputStream` but have only certain
+ * instances of that class be pollable. If [method@Gio.PollableInputStream.can_poll]
+ * returns false, then the behavior of other `GPollableInputStream` methods is
+ * undefined.
+ */
 export class PollableInputStream {
     ptr;
     constructor(ptr) {
@@ -9,6 +20,15 @@ export class PollableInputStream {
     static fromPtr(ptr) {
         return new PollableInputStream(ptr);
     }
+    /**
+     * 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", [
             {
@@ -17,6 +37,20 @@ export class PollableInputStream {
             },
         ], { 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", [
             {
@@ -36,6 +70,19 @@ export class PollableInputStream {
         });
         return getObject(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", [
             {
@@ -44,6 +91,25 @@ export class PollableInputStream {
             },
         ], { 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", [

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

@@ -2,13 +2,108 @@ import { Ref } from "@gtkx/native";
 import { PollableReturn } from "./enums.js";
 import { Cancellable } from "./cancellable.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
+ * interfacing with a non-GIO API that expects
+ * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
+ *
+ * Some classes may implement `GPollableOutputStream` but have only certain
+ * instances of that class be pollable. If [method@Gio.PollableOutputStream.can_poll]
+ * returns false, then the behavior of other `GPollableOutputStream` methods is
+ * undefined.
+ */
 export declare class PollableOutputStream {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): PollableOutputStream;
+    /**
+     * 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?: 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?: 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?: Cancellable | null): PollableReturn;
 }