@gtkx/ffi 0.1.44 → 0.1.46

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

@@ -4,13 +4,83 @@ import { Converter } from "./converter.js";
 import { InputStream } from "./input-stream.js";
 import * as GLib from "../glib/index.js";
 import { FilterInputStream } from "./filter-input-stream.js";
+/**
+ * Converter input stream implements [class@Gio.InputStream] and allows
+ * conversion of data of various types during reading.
+ *
+ * As of GLib 2.34, `GConverterInputStream` implements
+ * [iface@Gio.PollableInputStream].
+ */
 export declare class ConverterInputStream extends FilterInputStream {
+    /**
+     * Creates a new converter input stream for the @base_stream.
+     * @param baseStream - a #GInputStream
+     * @param converter - a #GConverter
+     */
     constructor(baseStream: InputStream, converter: Converter);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the #GConverter that is used by @converter_stream.
+     */
     getConverter(): Converter;
+    /**
+     * 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/converter-input-stream.js

@@ -3,6 +3,13 @@ import { NativeError, getObject } from "@gtkx/ffi";
 import { Converter } from "./converter.js";
 import * as GLib from "../glib/index.js";
 import { FilterInputStream } from "./filter-input-stream.js";
+/**
+ * Converter input stream implements [class@Gio.InputStream] and allows
+ * conversion of data of various types during reading.
+ *
+ * As of GLib 2.34, `GConverterInputStream` implements
+ * [iface@Gio.PollableInputStream].
+ */
 export class ConverterInputStream extends FilterInputStream {
     constructor(...args) {
         super(...args);
@@ -20,6 +27,9 @@ export class ConverterInputStream extends FilterInputStream {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the #GConverter that is used by @converter_stream.
+     */
     getConverter() {
         const ptr = call("libgio-2.0.so.0", "g_converter_input_stream_get_converter", [
             {
@@ -29,6 +39,15 @@ export class ConverterInputStream extends FilterInputStream {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Converter);
     }
+    /**
+     * 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", [
             {
@@ -37,6 +56,20 @@ export class ConverterInputStream extends FilterInputStream {
             },
         ], { 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", [
             {
@@ -56,6 +89,19 @@ export class ConverterInputStream extends FilterInputStream {
         });
         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", [
             {
@@ -64,6 +110,25 @@ export class ConverterInputStream extends FilterInputStream {
             },
         ], { 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/converter-output-stream.d.ts

@@ -5,14 +5,113 @@ import { Converter } from "./converter.js";
 import { OutputStream } from "./output-stream.js";
 import * as GLib from "../glib/index.js";
 import { FilterOutputStream } from "./filter-output-stream.js";
+/**
+ * Converter output stream implements [class@Gio.OutputStream] and allows
+ * conversion of data of various types during reading.
+ *
+ * As of GLib 2.34, `GConverterOutputStream` implements
+ * [iface@Gio.PollableOutputStream].
+ */
 export declare class ConverterOutputStream extends FilterOutputStream {
+    /**
+     * Creates a new converter output stream for the @base_stream.
+     * @param baseStream - a #GOutputStream
+     * @param converter - a #GConverter
+     */
     constructor(baseStream: OutputStream, converter: Converter);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the #GConverter that is used by @converter_stream.
+     */
     getConverter(): Converter;
+    /**
+     * 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;
 }

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

@@ -3,6 +3,13 @@ import { NativeError, getObject } from "@gtkx/ffi";
 import { Converter } from "./converter.js";
 import * as GLib from "../glib/index.js";
 import { FilterOutputStream } from "./filter-output-stream.js";
+/**
+ * Converter output stream implements [class@Gio.OutputStream] and allows
+ * conversion of data of various types during reading.
+ *
+ * As of GLib 2.34, `GConverterOutputStream` implements
+ * [iface@Gio.PollableOutputStream].
+ */
 export class ConverterOutputStream extends FilterOutputStream {
     constructor(...args) {
         super(...args);
@@ -20,6 +27,9 @@ export class ConverterOutputStream extends FilterOutputStream {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the #GConverter that is used by @converter_stream.
+     */
     getConverter() {
         const ptr = call("libgio-2.0.so.0", "g_converter_output_stream_get_converter", [
             {
@@ -29,6 +39,15 @@ export class ConverterOutputStream extends FilterOutputStream {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Converter);
     }
+    /**
+     * Checks if `stream` is actually pollable. Some classes may implement
+     * #GPollableOutputStream but have only certain instances of that
+     * class be pollable. If this method returns %FALSE, then the behavior
+     * of other #GPollableOutputStream methods is undefined.
+     *
+     * For any given stream, the value returned by this method is constant;
+     * a stream cannot switch from pollable to non-pollable or vice versa.
+     */
     canPoll() {
         return call("libgio-2.0.so.0", "g_pollable_output_stream_can_poll", [
             {
@@ -37,6 +56,20 @@ export class ConverterOutputStream extends FilterOutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates a #GSource that triggers when `stream` can be written, or
+     * `cancellable` is triggered or an error occurs. The callback on the
+     * source is of the #GPollableSourceFunc type.
+     *
+     * As with g_pollable_output_stream_is_writable(), it is possible that
+     * the stream may not actually be writable even after the source
+     * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+     * rather than g_output_stream_write() from the callback.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     createSource(cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_pollable_output_stream_create_source", [
             {
@@ -56,6 +89,19 @@ export class ConverterOutputStream extends FilterOutputStream {
         });
         return getObject(ptr, GLib.Source);
     }
+    /**
+     * Checks if `stream` can be written.
+     *
+     * Note that some stream types may not be able to implement this 100%
+     * reliably, and it is possible that a call to g_output_stream_write()
+     * after this returns %TRUE would still block. To guarantee
+     * non-blocking behavior, you should always use
+     * g_pollable_output_stream_write_nonblocking(), which will return a
+     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     */
     isWritable() {
         return call("libgio-2.0.so.0", "g_pollable_output_stream_is_writable", [
             {
@@ -64,6 +110,29 @@ export class ConverterOutputStream extends FilterOutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Attempts to write up to `count` bytes from `buffer` to @stream, as
+     * with g_output_stream_write(). If `stream` is not currently writable,
+     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `buffer` and
+     * `count` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param buffer - a buffer to write
+     * @param count - the number of bytes you want to write
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     writeNonblocking(buffer, count, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_pollable_output_stream_write_nonblocking", [
@@ -104,6 +173,31 @@ export class ConverterOutputStream extends FilterOutputStream {
         }
         return result;
     }
+    /**
+     * Attempts to write the bytes contained in the `n_vectors` `vectors` to @stream,
+     * as with g_output_stream_writev(). If `stream` is not currently writable,
+     * this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable. `error` will *not* be
+     * set in that case.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `vectors` and
+     * `n_vectors` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param vectors - the buffer containing the #GOutputVectors to write.
+     * @param nVectors - the number of vectors to write
+     * @param bytesWritten - location to store the number of bytes that were
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     writevNonblocking(vectors, nVectors, bytesWritten, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_pollable_output_stream_writev_nonblocking", [

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

@@ -1,11 +1,122 @@
 import { Ref } from "@gtkx/native";
 import { ConverterFlags, ConverterResult } from "./enums.js";
 import * as GLib from "../glib/index.js";
+/**
+ * `GConverter` is an interface for streaming conversions.
+ *
+ * `GConverter` is implemented by objects that convert
+ * binary data in various ways. The conversion can be
+ * stateful and may fail at any place.
+ *
+ * Some example conversions are: character set conversion,
+ * compression, decompression and regular expression
+ * replace.
+ */
 export declare class Converter {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Converter;
+    /**
+     * This is the main operation used when converting data. It is to be called
+     * multiple times in a loop, and each time it will do some work, i.e.
+     * producing some output (in @outbuf) or consuming some input (from @inbuf) or
+     * both. If its not possible to do any work an error is returned.
+     *
+     * Note that a single call may not consume all input (or any input at all).
+     * Also a call may produce output even if given no input, due to state stored
+     * in the converter producing output.
+     *
+     * If any data was either produced or consumed, and then an error happens, then
+     * only the successful conversion is reported and the error is returned on the
+     * next call.
+     *
+     * A full conversion loop involves calling this method repeatedly, each time
+     * giving it new input and space output space. When there is no more input
+     * data after the data in @inbuf, the flag %G_CONVERTER_INPUT_AT_END must be set.
+     * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+     * each time until all data is consumed and all output is produced, then
+     * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+     * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+     * in a decompression converter where the end of data is detectable from the
+     * data (and there might even be other data after the end of the compressed data).
+     *
+     * When some data has successfully been converted `bytes_read` and is set to
+     * the number of bytes read from @inbuf, and `bytes_written` is set to indicate
+     * how many bytes was written to @outbuf. If there are more data to output
+     * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+     * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+     * then %G_CONVERTER_FINISHED is returned.
+     *
+     * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+     * Some errors need special handling:
+     *
+     * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+     * to write the resulting converted data, the application should
+     * call the function again with a larger `outbuf` to continue.
+     *
+     * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+     * input to fully determine what the conversion should produce,
+     * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+     * example with an incomplete multibyte sequence when converting text,
+     * or when a regexp matches up to the end of the input (and may match
+     * further input). It may also happen when `inbuf_size` is zero and
+     * there is no more data to produce.
+     *
+     * When this happens the application should read more input and then
+     * call the function again. If further input shows that there is no
+     * more data call the function again with the same data but with
+     * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+     * to finish as e.g. in the regexp match case (or, to fail again with
+     * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+     * input is actually partial).
+     *
+     * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+     * converter object is in an invalid state where its not allowed
+     * to call g_converter_convert() anymore. At this time you can only
+     * free the object or call g_converter_reset() to reset it to the
+     * initial state.
+     *
+     * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+     * to try to write out all internal state to the output. The application
+     * has to call the function multiple times with the flag set, and when
+     * the available input has been consumed and all internal state has
+     * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+     * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+     * This is somewhat similar to what happens at the end of the input stream,
+     * but done in the middle of the data.
+     *
+     * This has different meanings for different conversions. For instance
+     * in a compression converter it would mean that we flush all the
+     * compression state into output such that if you uncompress the
+     * compressed data you get back all the input data. Doing this may
+     * make the final file larger due to padding though. Another example
+     * is a regexp conversion, where if you at the end of the flushed data
+     * have a match, but there is also a potential longer match. In the
+     * non-flushed case we would ask for more input, but when flushing we
+     * treat this as the end of input and do the match.
+     *
+     * Flushing is not always possible (like if a charset converter flushes
+     * at a partial multibyte sequence). Converters are supposed to try
+     * to produce as much output as possible and then return an error
+     * (typically %G_IO_ERROR_PARTIAL_INPUT).
+     * @param inbuf - the buffer
+     * @param inbufSize - the number of bytes in @inbuf
+     * @param outbuf - a
+     * @param outbufSize - the number of bytes in @outbuf, must be at least one
+     * @param flags - a #GConverterFlags controlling the conversion details
+     * @param bytesRead - will be set to the number of bytes read
+     * @param bytesWritten - will be set to the number of bytes
+     */
     convert(inbuf: number[], inbufSize: number, outbuf: number[], outbufSize: number, flags: ConverterFlags, bytesRead: Ref<number>, bytesWritten: Ref<number>): ConverterResult;
+    /**
+     * Applies `converter` to the data in @bytes.
+     * @param bytes - the data to convert
+     */
     convertBytes(bytes: GLib.Bytes): GLib.Bytes;
+    /**
+     * Resets all internal state in the converter, making it behave
+     * as if it was just created. If the converter has any internal
+     * state that would produce output then that output is lost.
+     */
     reset(): void;
 }