@gtkx/ffi 0.1.45 → 0.1.47

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

@@ -4,23 +4,177 @@ import { Cancellable } from "./cancellable.js";
 import { InputStream } from "./input-stream.js";
 import * as GLib from "../glib/index.js";
 import { FilterInputStream } from "./filter-input-stream.js";
+/**
+ * Buffered input stream implements [class@Gio.FilterInputStream] and provides
+ * for buffered reads.
+ *
+ * By default, `GBufferedInputStream`'s buffer size is set at 4 kilobytes.
+ *
+ * To create a buffered input stream, use [ctor@Gio.BufferedInputStream.new],
+ * or [ctor@Gio.BufferedInputStream.new_sized] to specify the buffer's size at
+ * construction.
+ *
+ * To get the size of a buffer within a buffered input stream, use
+ * [method@Gio.BufferedInputStream.get_buffer_size]. To change the size of a
+ * buffered input stream's buffer, use [method@Gio.BufferedInputStream.set_buffer_size].
+ * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
+ */
 export declare class BufferedInputStream extends FilterInputStream {
+    /**
+     * Creates a new [class@Gio.InputStream] from the given @base_stream, with
+     * a buffer set to the default size (4 kilobytes).
+     * @param baseStream - a [class@Gio.InputStream]
+     */
     constructor(baseStream: InputStream);
     constructor(...args: unknown[]);
+    /**
+     * Creates a new [class@Gio.BufferedInputStream] from the given @base_stream,
+     * with a buffer set to @size.
+     * @param baseStream - a [class@Gio.InputStream]
+     * @param size - a #gsize
+     */
     static inputStreamNewSized(baseStream: InputStream, size: number): BufferedInputStream;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Tries to read `count` bytes from the stream into the buffer.
+     * Will block during this read.
+     *
+     * If `count` is zero, returns zero and does nothing. A value of `count` larger than `G_MAXSSIZE` will cause a
+     * [error@Gio.IOErrorEnum.INVALID_ARGUMENT] error.
+     *
+     * On success, the number of bytes read into the buffer is returned.
+     * It is not an error if this is not the same as the requested size, as it
+     * can happen e.g. near the end of a file. Zero is returned on end of file
+     * (or if `count` is zero),  but never otherwise.
+     *
+     * If `count` is -1 then the attempted read size is equal to the number of
+     * bytes that are required to fill the buffer.
+     *
+     * 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 [error@Gio.IOErrorEnum.CANCELLED] will be returned.
+     * If an operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     *
+     * On error `-1` is returned and `error` is set accordingly.
+     *
+     * For the asynchronous, non-blocking, version of this function, see
+     * [method@Gio.BufferedInputStream.fill_async].
+     * @param count - the number of bytes that will be read from the stream
+     * @param cancellable - optional [class@Gio.Cancellable] object, `NULL` to ignore
+     */
     fill(count: number, cancellable?: Cancellable | null): number;
+    /**
+     * Reads data into @stream's buffer asynchronously, up to `count` size.
+     * `io_priority` can be used to prioritize reads. For the synchronous
+     * version of this function, see [method@Gio.BufferedInputStream.fill].
+     *
+     * If `count` is `-1` then the attempted read size is equal to the number
+     * of bytes that are required to fill the buffer.
+     * @param count - the number of bytes that will be read from the stream
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional [class@Gio.Cancellable] object
+     * @param callback - a [callback@Gio.AsyncReadyCallback]
+     * @param userData - a #gpointer
+     */
     fillAsync(count: number, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous read.
+     * @param result - a [iface@Gio.AsyncResult]
+     */
     fillFinish(result: AsyncResult): number;
+    /**
+     * Gets the size of the available data within the stream.
+     */
     getAvailable(): number;
+    /**
+     * Gets the size of the input buffer.
+     */
     getBufferSize(): number;
+    /**
+     * Peeks in the buffer, copying data of size `count` into @buffer,
+     * offset `offset` bytes.
+     * @param buffer - a pointer to
+     * @param offset - a #gsize
+     * @param count - a #gsize
+     */
     peek(buffer: number[], offset: number, count: number): number;
+    /**
+     * Returns the buffer with the currently available bytes. The returned
+     * buffer must not be modified and will become invalid when reading from
+     * the stream or filling the buffer.
+     * @param count - a #gsize to get the number of bytes available in the buffer
+     */
     peekBuffer(count: Ref<number>): number[];
+    /**
+     * Tries to read a single byte from the stream or the buffer. Will block
+     * during this read.
+     *
+     * On success, the byte read from the stream is returned. On end of stream
+     * `-1` is returned but it's not an exceptional error and `error` is not set.
+     *
+     * 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 [error@Gio.IOErrorEnum.CANCELLED] will be returned.
+     * If an operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     *
+     * On error `-1` is returned and `error` is set accordingly.
+     * @param cancellable - optional [class@Gio.Cancellable] object, `NULL` to ignore
+     */
     readByte(cancellable?: Cancellable | null): number;
+    /**
+     * Sets the size of the internal buffer of `stream` to @size, or to the
+     * size of the contents of the buffer. The buffer can never be resized
+     * smaller than its current contents.
+     * @param size - a #gsize
+     */
     setBufferSize(size: number): void;
+    /**
+     * 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/buffered-input-stream.js

@@ -1,10 +1,31 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { FilterInputStream } from "./filter-input-stream.js";
+/**
+ * Buffered input stream implements [class@Gio.FilterInputStream] and provides
+ * for buffered reads.
+ *
+ * By default, `GBufferedInputStream`'s buffer size is set at 4 kilobytes.
+ *
+ * To create a buffered input stream, use [ctor@Gio.BufferedInputStream.new],
+ * or [ctor@Gio.BufferedInputStream.new_sized] to specify the buffer's size at
+ * construction.
+ *
+ * To get the size of a buffer within a buffered input stream, use
+ * [method@Gio.BufferedInputStream.get_buffer_size]. To change the size of a
+ * buffered input stream's buffer, use [method@Gio.BufferedInputStream.set_buffer_size].
+ * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
+ */
 export class BufferedInputStream extends FilterInputStream {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new [class@Gio.BufferedInputStream] from the given @base_stream,
+     * with a buffer set to @size.
+     * @param baseStream - a [class@Gio.InputStream]
+     * @param size - a #gsize
+     */
     static inputStreamNewSized(baseStream, size) {
         const ptr = call("libgio-2.0.so.0", "g_buffered_input_stream_new_sized", [
             {
@@ -27,6 +48,34 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Tries to read `count` bytes from the stream into the buffer.
+     * Will block during this read.
+     *
+     * If `count` is zero, returns zero and does nothing. A value of `count` larger than `G_MAXSSIZE` will cause a
+     * [error@Gio.IOErrorEnum.INVALID_ARGUMENT] error.
+     *
+     * On success, the number of bytes read into the buffer is returned.
+     * It is not an error if this is not the same as the requested size, as it
+     * can happen e.g. near the end of a file. Zero is returned on end of file
+     * (or if `count` is zero),  but never otherwise.
+     *
+     * If `count` is -1 then the attempted read size is equal to the number of
+     * bytes that are required to fill the buffer.
+     *
+     * 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 [error@Gio.IOErrorEnum.CANCELLED] will be returned.
+     * If an operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     *
+     * On error `-1` is returned and `error` is set accordingly.
+     *
+     * For the asynchronous, non-blocking, version of this function, see
+     * [method@Gio.BufferedInputStream.fill_async].
+     * @param count - the number of bytes that will be read from the stream
+     * @param cancellable - optional [class@Gio.Cancellable] object, `NULL` to ignore
+     */
     fill(count, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_buffered_input_stream_fill", [
@@ -60,6 +109,19 @@ export class BufferedInputStream extends FilterInputStream {
         }
         return result;
     }
+    /**
+     * Reads data into @stream's buffer asynchronously, up to `count` size.
+     * `io_priority` can be used to prioritize reads. For the synchronous
+     * version of this function, see [method@Gio.BufferedInputStream.fill].
+     *
+     * If `count` is `-1` then the attempted read size is equal to the number
+     * of bytes that are required to fill the buffer.
+     * @param count - the number of bytes that will be read from the stream
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional [class@Gio.Cancellable] object
+     * @param callback - a [callback@Gio.AsyncReadyCallback]
+     * @param userData - a #gpointer
+     */
     fillAsync(count, ioPriority, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_buffered_input_stream_fill_async", [
             {
@@ -91,6 +153,10 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an asynchronous read.
+     * @param result - a [iface@Gio.AsyncResult]
+     */
     fillFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_buffered_input_stream_fill_finish", [
@@ -119,6 +185,9 @@ export class BufferedInputStream extends FilterInputStream {
         }
         return _result;
     }
+    /**
+     * Gets the size of the available data within the stream.
+     */
     getAvailable() {
         return call("libgio-2.0.so.0", "g_buffered_input_stream_get_available", [
             {
@@ -127,6 +196,9 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the size of the input buffer.
+     */
     getBufferSize() {
         return call("libgio-2.0.so.0", "g_buffered_input_stream_get_buffer_size", [
             {
@@ -135,6 +207,13 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Peeks in the buffer, copying data of size `count` into @buffer,
+     * offset `offset` bytes.
+     * @param buffer - a pointer to
+     * @param offset - a #gsize
+     * @param count - a #gsize
+     */
     peek(buffer, offset, count) {
         return call("libgio-2.0.so.0", "g_buffered_input_stream_peek", [
             {
@@ -158,6 +237,12 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns the buffer with the currently available bytes. The returned
+     * buffer must not be modified and will become invalid when reading from
+     * the stream or filling the buffer.
+     * @param count - a #gsize to get the number of bytes available in the buffer
+     */
     peekBuffer(count) {
         return call("libgio-2.0.so.0", "g_buffered_input_stream_peek_buffer", [
             {
@@ -173,6 +258,22 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
     }
+    /**
+     * Tries to read a single byte from the stream or the buffer. Will block
+     * during this read.
+     *
+     * On success, the byte read from the stream is returned. On end of stream
+     * `-1` is returned but it's not an exceptional error and `error` is not set.
+     *
+     * 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 [error@Gio.IOErrorEnum.CANCELLED] will be returned.
+     * If an operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     *
+     * On error `-1` is returned and `error` is set accordingly.
+     * @param cancellable - optional [class@Gio.Cancellable] object, `NULL` to ignore
+     */
     readByte(cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_buffered_input_stream_read_byte", [
@@ -202,6 +303,12 @@ export class BufferedInputStream extends FilterInputStream {
         }
         return result;
     }
+    /**
+     * Sets the size of the internal buffer of `stream` to @size, or to the
+     * size of the contents of the buffer. The buffer can never be resized
+     * smaller than its current contents.
+     * @param size - a #gsize
+     */
     setBufferSize(size) {
         call("libgio-2.0.so.0", "g_buffered_input_stream_set_buffer_size", [
             {
@@ -214,6 +321,9 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -222,6 +332,10 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { 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", [
             {
@@ -230,6 +344,25 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { 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", [
@@ -267,6 +400,9 @@ export class BufferedInputStream extends FilterInputStream {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -275,6 +411,19 @@ export class BufferedInputStream extends FilterInputStream {
             },
         ], { 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/buffered-output-stream.d.ts

@@ -2,18 +2,101 @@ import { Cancellable } from "./cancellable.js";
 import { OutputStream } from "./output-stream.js";
 import * as GLib from "../glib/index.js";
 import { FilterOutputStream } from "./filter-output-stream.js";
+/**
+ * Buffered output stream implements [class@Gio.FilterOutputStream] and provides
+ * for buffered writes.
+ *
+ * By default, `GBufferedOutputStream`'s buffer size is set at 4 kilobytes.
+ *
+ * To create a buffered output stream, use [ctor@Gio.BufferedOutputStream.new],
+ * or [ctor@Gio.BufferedOutputStream.new_sized] to specify the buffer's size
+ * at construction.
+ *
+ * To get the size of a buffer within a buffered input stream, use
+ * [method@Gio.BufferedOutputStream.get_buffer_size]. To change the size of a
+ * buffered output stream's buffer, use [method@Gio.BufferedOutputStream.set_buffer_size].
+ * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
+ */
 export declare class BufferedOutputStream extends FilterOutputStream {
+    /**
+     * Creates a new buffered output stream for a base stream.
+     * @param baseStream - a [class@Gio.OutputStream].
+     */
     constructor(baseStream: OutputStream);
     constructor(...args: unknown[]);
+    /**
+     * Creates a new buffered output stream with a given buffer size.
+     * @param baseStream - a [class@Gio.OutputStream].
+     * @param size - a #gsize.
+     */
     static outputStreamNewSized(baseStream: OutputStream, size: number): BufferedOutputStream;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Checks if the buffer automatically grows as data is added.
+     */
     getAutoGrow(): boolean;
+    /**
+     * Gets the size of the buffer in the @stream.
+     */
     getBufferSize(): number;
+    /**
+     * Sets whether or not the @stream's buffer should automatically grow.
+     * If `auto_grow` is true, then each write will just make the buffer
+     * larger, and you must manually flush the buffer to actually write out
+     * the data to the underlying stream.
+     * @param autoGrow - a #gboolean.
+     */
     setAutoGrow(autoGrow: boolean): void;
+    /**
+     * Sets the size of the internal buffer to @size.
+     * @param size - a #gsize.
+     */
     setBufferSize(size: number): void;
+    /**
+     * 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/buffered-output-stream.js

@@ -1,10 +1,30 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { FilterOutputStream } from "./filter-output-stream.js";
+/**
+ * Buffered output stream implements [class@Gio.FilterOutputStream] and provides
+ * for buffered writes.
+ *
+ * By default, `GBufferedOutputStream`'s buffer size is set at 4 kilobytes.
+ *
+ * To create a buffered output stream, use [ctor@Gio.BufferedOutputStream.new],
+ * or [ctor@Gio.BufferedOutputStream.new_sized] to specify the buffer's size
+ * at construction.
+ *
+ * To get the size of a buffer within a buffered input stream, use
+ * [method@Gio.BufferedOutputStream.get_buffer_size]. To change the size of a
+ * buffered output stream's buffer, use [method@Gio.BufferedOutputStream.set_buffer_size].
+ * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
+ */
 export class BufferedOutputStream extends FilterOutputStream {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new buffered output stream with a given buffer size.
+     * @param baseStream - a [class@Gio.OutputStream].
+     * @param size - a #gsize.
+     */
     static outputStreamNewSized(baseStream, size) {
         const ptr = call("libgio-2.0.so.0", "g_buffered_output_stream_new_sized", [
             {
@@ -27,6 +47,9 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Checks if the buffer automatically grows as data is added.
+     */
     getAutoGrow() {
         return call("libgio-2.0.so.0", "g_buffered_output_stream_get_auto_grow", [
             {
@@ -35,6 +58,9 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the size of the buffer in the @stream.
+     */
     getBufferSize() {
         return call("libgio-2.0.so.0", "g_buffered_output_stream_get_buffer_size", [
             {
@@ -43,6 +69,13 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Sets whether or not the @stream's buffer should automatically grow.
+     * If `auto_grow` is true, then each write will just make the buffer
+     * larger, and you must manually flush the buffer to actually write out
+     * the data to the underlying stream.
+     * @param autoGrow - a #gboolean.
+     */
     setAutoGrow(autoGrow) {
         call("libgio-2.0.so.0", "g_buffered_output_stream_set_auto_grow", [
             {
@@ -55,6 +88,10 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the size of the internal buffer to @size.
+     * @param size - a #gsize.
+     */
     setBufferSize(size) {
         call("libgio-2.0.so.0", "g_buffered_output_stream_set_buffer_size", [
             {
@@ -67,6 +104,9 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -75,6 +115,10 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { 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", [
             {
@@ -83,6 +127,25 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { 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", [
@@ -120,6 +183,9 @@ export class BufferedOutputStream extends FilterOutputStream {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -128,6 +194,19 @@ export class BufferedOutputStream extends FilterOutputStream {
             },
         ], { 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", [