@gtkx/ffi 0.1.44 → 0.1.46

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

@@ -2,20 +2,147 @@ import { Ref } from "@gtkx/native";
 import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/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
+ * [iface@Gio.PollableInputStream].
+ */
 export declare class MemoryInputStream extends InputStream {
+    /**
+     * Creates a new empty #GMemoryInputStream.
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a new #GMemoryInputStream with data from the given @bytes.
+     * @param bytes - a #GBytes
+     */
     static inputStreamNewFromBytes(bytes: GLib.Bytes): MemoryInputStream;
+    /**
+     * Creates a new #GMemoryInputStream with data in memory of a given size.
+     * @param data - input data
+     * @param len - length of the data, may be -1 if `data` is a nul-terminated string
+     * @param destroy - function that is called to free @data, or %NULL
+     */
     static inputStreamNewFromData(data: number[], len: number, destroy?: () => void | null): MemoryInputStream;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Appends `bytes` to data that can be read from the input stream.
+     * @param bytes - input data
+     */
     addBytes(bytes: GLib.Bytes): void;
+    /**
+     * Appends `data` to data that can be read from the input stream
+     * @param data - input data
+     * @param len - length of the data, may be -1 if `data` is a nul-terminated string
+     * @param destroy - function that is called to free @data, or %NULL
+     */
     addData(data: number[], len: number, destroy?: () => void | null): 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?: 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;
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek(): boolean;
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate(): boolean;
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+    /**
+     * Tells the current position within the stream.
+     */
     tell(): number;
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
 }

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

@@ -2,10 +2,24 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/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
+ * [iface@Gio.PollableInputStream].
+ */
 export class MemoryInputStream extends InputStream {
+    /**
+     * Creates a new empty #GMemoryInputStream.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new #GMemoryInputStream with data from the given @bytes.
+     * @param bytes - a #GBytes
+     */
     static inputStreamNewFromBytes(bytes) {
         const ptr = call("libgio-2.0.so.0", "g_memory_input_stream_new_from_bytes", [
             {
@@ -20,6 +34,12 @@ export class MemoryInputStream extends InputStream {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, MemoryInputStream);
     }
+    /**
+     * Creates a new #GMemoryInputStream with data in memory of a given size.
+     * @param data - input data
+     * @param len - length of the data, may be -1 if `data` is a nul-terminated string
+     * @param destroy - function that is called to free @data, or %NULL
+     */
     static inputStreamNewFromData(data, len, destroy) {
         const ptr = call("libgio-2.0.so.0", "g_memory_input_stream_new_from_data", [
             {
@@ -47,6 +67,10 @@ export class MemoryInputStream extends InputStream {
             borrowed: false,
         });
     }
+    /**
+     * Appends `bytes` to data that can be read from the input stream.
+     * @param bytes - input data
+     */
     addBytes(bytes) {
         call("libgio-2.0.so.0", "g_memory_input_stream_add_bytes", [
             {
@@ -64,6 +88,12 @@ export class MemoryInputStream extends InputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Appends `data` to data that can be read from the input stream
+     * @param data - input data
+     * @param len - length of the data, may be -1 if `data` is a nul-terminated string
+     * @param destroy - function that is called to free @data, or %NULL
+     */
     addData(data, len, destroy) {
         call("libgio-2.0.so.0", "g_memory_input_stream_add_data", [
             {
@@ -88,6 +118,15 @@ export class MemoryInputStream extends 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", [
             {
@@ -96,6 +135,20 @@ export class MemoryInputStream extends InputStream {
             },
         ], { 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", [
             {
@@ -115,6 +168,19 @@ export class MemoryInputStream extends InputStream {
         });
         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", [
             {
@@ -123,6 +189,25 @@ export class MemoryInputStream extends InputStream {
             },
         ], { 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", [
@@ -166,6 +251,9 @@ export class MemoryInputStream extends InputStream {
         }
         return result;
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -174,6 +262,10 @@ export class MemoryInputStream extends InputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate() {
         return call("libgio-2.0.so.0", "g_seekable_can_truncate", [
             {
@@ -182,6 +274,25 @@ export class MemoryInputStream extends InputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset, type, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_seek", [
@@ -219,6 +330,9 @@ export class MemoryInputStream extends InputStream {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -227,6 +341,19 @@ export class MemoryInputStream extends InputStream {
             },
         ], { type: "int", size: 64, unsigned: false });
     }
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_truncate", [

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

@@ -1,3 +1,53 @@
+/**
+ * `GMemoryMonitor` will monitor system memory and suggest to the application
+ * when to free memory so as to leave more room for other applications.
+ * It is implemented on Linux using the
+ * [Low Memory Monitor](https://gitlab.freedesktop.org/hadess/low-memory-monitor/)
+ * ([API documentation](https://hadess.pages.freedesktop.org/low-memory-monitor/)).
+ *
+ * There is also an implementation for use inside Flatpak sandboxes.
+ *
+ * Possible actions to take when the signal is received are:
+ *
+ * - Free caches
+ * - Save files that haven’t been looked at in a while to disk, ready to be reopened when needed
+ * - Run a garbage collection cycle
+ * - Try and compress fragmented allocations
+ * - Exit on idle if the process has no reason to stay around
+ * - Call [`malloc_trim(3)`](man:malloc_trim(3)) to return cached heap pages to
+ * the kernel (if supported by your libc)
+ *
+ * Note that some actions may not always improve system performance, and so
+ * should be profiled for your application. `malloc_trim()`, for example, may
+ * make future heap allocations slower (due to releasing cached heap pages back
+ * to the kernel).
+ *
+ * See [type@Gio.MemoryMonitorWarningLevel] for details on the various warning
+ * levels.
+ *
+ * ```c
+ * static void
+ * warning_cb (GMemoryMonitor *m, GMemoryMonitorWarningLevel level)
+ * {
+ * g_debug ("Warning level: %d", level);
+ * if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
+ * drop_caches ();
+ * }
+ *
+ * static GMemoryMonitor *
+ * monitor_low_memory (void)
+ * {
+ * GMemoryMonitor *m;
+ * m = g_memory_monitor_dup_default ();
+ * g_signal_connect (G_OBJECT (m), "low-memory-warning",
+ * G_CALLBACK (warning_cb), NULL);
+ * return m;
+ * }
+ * ```
+ *
+ * Don’t forget to disconnect the [signal@Gio.MemoryMonitor::low-memory-warning]
+ * signal, and unref the `GMemoryMonitor` itself when exiting.
+ */
 export declare class MemoryMonitor {
     ptr: unknown;
     protected constructor(ptr: unknown);

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

@@ -1,3 +1,53 @@
+/**
+ * `GMemoryMonitor` will monitor system memory and suggest to the application
+ * when to free memory so as to leave more room for other applications.
+ * It is implemented on Linux using the
+ * [Low Memory Monitor](https://gitlab.freedesktop.org/hadess/low-memory-monitor/)
+ * ([API documentation](https://hadess.pages.freedesktop.org/low-memory-monitor/)).
+ *
+ * There is also an implementation for use inside Flatpak sandboxes.
+ *
+ * Possible actions to take when the signal is received are:
+ *
+ * - Free caches
+ * - Save files that haven’t been looked at in a while to disk, ready to be reopened when needed
+ * - Run a garbage collection cycle
+ * - Try and compress fragmented allocations
+ * - Exit on idle if the process has no reason to stay around
+ * - Call [`malloc_trim(3)`](man:malloc_trim(3)) to return cached heap pages to
+ * the kernel (if supported by your libc)
+ *
+ * Note that some actions may not always improve system performance, and so
+ * should be profiled for your application. `malloc_trim()`, for example, may
+ * make future heap allocations slower (due to releasing cached heap pages back
+ * to the kernel).
+ *
+ * See [type@Gio.MemoryMonitorWarningLevel] for details on the various warning
+ * levels.
+ *
+ * ```c
+ * static void
+ * warning_cb (GMemoryMonitor *m, GMemoryMonitorWarningLevel level)
+ * {
+ * g_debug ("Warning level: %d", level);
+ * if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
+ * drop_caches ();
+ * }
+ *
+ * static GMemoryMonitor *
+ * monitor_low_memory (void)
+ * {
+ * GMemoryMonitor *m;
+ * m = g_memory_monitor_dup_default ();
+ * g_signal_connect (G_OBJECT (m), "low-memory-warning",
+ * G_CALLBACK (warning_cb), NULL);
+ * return m;
+ * }
+ * ```
+ *
+ * Don’t forget to disconnect the [signal@Gio.MemoryMonitor::low-memory-warning]
+ * signal, and unref the `GMemoryMonitor` itself when exiting.
+ */
 export class MemoryMonitor {
     ptr;
     constructor(ptr) {

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

@@ -3,22 +3,198 @@ import { PollableReturn } from "./enums.js";
 import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/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
+ * [iface@Gio.PollableOutputStream]: it always polls as ready.
+ */
 export declare class MemoryOutputStream extends OutputStream {
+    /**
+     * Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
+     * for memory allocation.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets any loaded data from the @ostream.
+     *
+     * Note that the returned pointer may become invalid on the next
+     * write or truncate operation on the stream.
+     */
     getData(): 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.
+     */
     getDataSize(): number;
+    /**
+     * Gets the size of the currently allocated data area (available from
+     * g_memory_output_stream_get_data()).
+     *
+     * You probably don't want to use this function on resizable streams.
+     * See g_memory_output_stream_get_data_size() instead.  For resizable
+     * streams the size returned by this function is an implementation
+     * detail and may be change at any time in response to operations on the
+     * stream.
+     *
+     * If the stream is fixed-sized (ie: no realloc was passed to
+     * g_memory_output_stream_new()) then this is the maximum size of the
+     * stream and further writes will return %G_IO_ERROR_NO_SPACE.
+     *
+     * In any case, if you want the number of bytes currently written to the
+     * stream, use g_memory_output_stream_get_data_size().
+     */
     getSize(): number;
+    /**
+     * Returns data from the `ostream` as a #GBytes. `ostream` must be
+     * closed before calling this function.
+     */
     stealAsBytes(): GLib.Bytes;
+    /**
+     * Gets any loaded data from the @ostream. Ownership of the data
+     * is transferred to the caller; when no longer needed it must be
+     * freed using the free function set in @ostream's
+     * #GMemoryOutputStream:destroy-function property.
+     *
+     * `ostream` must be closed before calling this function.
+     */
     stealData(): number | null;
+    /**
+     * 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;
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek(): boolean;
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate(): boolean;
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+    /**
+     * Tells the current position within the stream.
+     */
     tell(): number;
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
 }