@gtkx/ffi 0.1.44 → 0.1.46

package/dist/generated/gio/converter.js

@@ -1,6 +1,17 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 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 class Converter {
     ptr;
     constructor(ptr) {
@@ -9,6 +20,97 @@ export class Converter {
     static fromPtr(ptr) {
         return new Converter(ptr);
     }
+    /**
+     * 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, inbufSize, outbuf, outbufSize, flags, bytesRead, bytesWritten) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_converter_convert", [
@@ -73,6 +175,10 @@ export class Converter {
         }
         return result;
     }
+    /**
+     * Applies `converter` to the data in @bytes.
+     * @param bytes - the data to convert
+     */
     convertBytes(bytes) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_converter_convert_bytes", [
@@ -111,6 +217,11 @@ export class Converter {
         }
         return getObject(ptr, 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() {
         call("libgio-2.0.so.0", "g_converter_reset", [
             {

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

@@ -1,13 +1,100 @@
 import { CredentialsType } from "./enums.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * The `GCredentials` type is a reference-counted wrapper for native
+ * credentials.
+ *
+ * The information in `GCredentials` is typically used for identifying,
+ * authenticating and authorizing other processes.
+ *
+ * Some operating systems supports looking up the credentials of the remote
+ * peer of a communication endpoint - see e.g. [method@Gio.Socket.get_credentials].
+ *
+ * Some operating systems supports securely sending and receiving
+ * credentials over a Unix Domain Socket, see [class@Gio.UnixCredentialsMessage],
+ * [method@Gio.UnixConnection.send_credentials] and
+ * [method@Gio.UnixConnection.receive_credentials] for details.
+ *
+ * On Linux, the native credential type is a `struct ucred` - see the
+ * [`unix(7)` man page](man:unix(7)) for details. This corresponds to
+ * `G_CREDENTIALS_TYPE_LINUX_UCRED`.
+ *
+ * On Apple operating systems (including iOS, tvOS, and macOS), the native credential
+ * type is a `struct xucred`. This corresponds to `G_CREDENTIALS_TYPE_APPLE_XUCRED`.
+ *
+ * On FreeBSD, Debian GNU/kFreeBSD, and GNU/Hurd, the native credential type is a
+ * `struct cmsgcred`. This corresponds to `G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED`.
+ *
+ * On NetBSD, the native credential type is a `struct unpcbid`.
+ * This corresponds to `G_CREDENTIALS_TYPE_NETBSD_UNPCBID`.
+ *
+ * On OpenBSD, the native credential type is a `struct sockpeercred`.
+ * This corresponds to `G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED`.
+ *
+ * On Solaris (including OpenSolaris and its derivatives), the native credential type
+ * is a `ucred_t`. This corresponds to `G_CREDENTIALS_TYPE_SOLARIS_UCRED`.
+ *
+ * Since GLib 2.72, on Windows, the native credentials may contain the PID of a
+ * process. This corresponds to `G_CREDENTIALS_TYPE_WIN32_PID`.
+ */
 export declare class Credentials extends GObject.GObject {
+    /**
+     * Creates a new #GCredentials object with credentials matching the
+     * the current process.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Tries to get the UNIX process identifier from @credentials. This
+     * method is only available on UNIX platforms.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * OS or if the native credentials type does not contain information
+     * about the UNIX process ID.
+     */
     getUnixPid(): number;
+    /**
+     * Tries to get the UNIX user identifier from @credentials. This
+     * method is only available on UNIX platforms.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * OS or if the native credentials type does not contain information
+     * about the UNIX user.
+     */
     getUnixUser(): number;
+    /**
+     * Checks if `credentials` and `other_credentials` is the same user.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * the OS.
+     * @param otherCredentials - A #GCredentials.
+     */
     isSameUser(otherCredentials: Credentials): boolean;
+    /**
+     * Copies the native credentials of type `native_type` from `native` into @credentials.
+     *
+     * It is a programming error (which will cause a warning to be
+     * logged) to use this method if there is no #GCredentials support for
+     * the OS or if `native_type` isn't supported by the OS.
+     * @param nativeType - The type of native credentials to set.
+     * @param native - A pointer to native credentials.
+     */
     setNative(nativeType: CredentialsType, native: number): void;
+    /**
+     * Tries to set the UNIX user identifier on @credentials. This method
+     * is only available on UNIX platforms.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * OS or if the native credentials type does not contain information
+     * about the UNIX user. It can also fail if the OS does not allow the
+     * use of "spoofed" credentials.
+     * @param uid - The UNIX user identifier to set.
+     */
     setUnixUser(uid: number): boolean;
+    /**
+     * Creates a human-readable textual representation of `credentials` that can be used in logging and debug messages. The format of the
+     * returned string may change in future GLib release.
+     */
     toString(): string;
     connect(signal: "notify", handler: (self: Credentials, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/credentials.js

@@ -1,7 +1,48 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * The `GCredentials` type is a reference-counted wrapper for native
+ * credentials.
+ *
+ * The information in `GCredentials` is typically used for identifying,
+ * authenticating and authorizing other processes.
+ *
+ * Some operating systems supports looking up the credentials of the remote
+ * peer of a communication endpoint - see e.g. [method@Gio.Socket.get_credentials].
+ *
+ * Some operating systems supports securely sending and receiving
+ * credentials over a Unix Domain Socket, see [class@Gio.UnixCredentialsMessage],
+ * [method@Gio.UnixConnection.send_credentials] and
+ * [method@Gio.UnixConnection.receive_credentials] for details.
+ *
+ * On Linux, the native credential type is a `struct ucred` - see the
+ * [`unix(7)` man page](man:unix(7)) for details. This corresponds to
+ * `G_CREDENTIALS_TYPE_LINUX_UCRED`.
+ *
+ * On Apple operating systems (including iOS, tvOS, and macOS), the native credential
+ * type is a `struct xucred`. This corresponds to `G_CREDENTIALS_TYPE_APPLE_XUCRED`.
+ *
+ * On FreeBSD, Debian GNU/kFreeBSD, and GNU/Hurd, the native credential type is a
+ * `struct cmsgcred`. This corresponds to `G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED`.
+ *
+ * On NetBSD, the native credential type is a `struct unpcbid`.
+ * This corresponds to `G_CREDENTIALS_TYPE_NETBSD_UNPCBID`.
+ *
+ * On OpenBSD, the native credential type is a `struct sockpeercred`.
+ * This corresponds to `G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED`.
+ *
+ * On Solaris (including OpenSolaris and its derivatives), the native credential type
+ * is a `ucred_t`. This corresponds to `G_CREDENTIALS_TYPE_SOLARIS_UCRED`.
+ *
+ * Since GLib 2.72, on Windows, the native credentials may contain the PID of a
+ * process. This corresponds to `G_CREDENTIALS_TYPE_WIN32_PID`.
+ */
 export class Credentials extends GObject.GObject {
+    /**
+     * Creates a new #GCredentials object with credentials matching the
+     * the current process.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -11,6 +52,14 @@ export class Credentials extends GObject.GObject {
             borrowed: false,
         });
     }
+    /**
+     * Tries to get the UNIX process identifier from @credentials. This
+     * method is only available on UNIX platforms.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * OS or if the native credentials type does not contain information
+     * about the UNIX process ID.
+     */
     getUnixPid() {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_credentials_get_unix_pid", [
@@ -35,6 +84,14 @@ export class Credentials extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Tries to get the UNIX user identifier from @credentials. This
+     * method is only available on UNIX platforms.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * OS or if the native credentials type does not contain information
+     * about the UNIX user.
+     */
     getUnixUser() {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_credentials_get_unix_user", [
@@ -59,6 +116,13 @@ export class Credentials extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Checks if `credentials` and `other_credentials` is the same user.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * the OS.
+     * @param otherCredentials - A #GCredentials.
+     */
     isSameUser(otherCredentials) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_credentials_is_same_user", [
@@ -87,6 +151,15 @@ export class Credentials extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Copies the native credentials of type `native_type` from `native` into @credentials.
+     *
+     * It is a programming error (which will cause a warning to be
+     * logged) to use this method if there is no #GCredentials support for
+     * the OS or if `native_type` isn't supported by the OS.
+     * @param nativeType - The type of native credentials to set.
+     * @param native - A pointer to native credentials.
+     */
     setNative(nativeType, native) {
         call("libgio-2.0.so.0", "g_credentials_set_native", [
             {
@@ -103,6 +176,16 @@ export class Credentials extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Tries to set the UNIX user identifier on @credentials. This method
+     * is only available on UNIX platforms.
+     *
+     * This operation can fail if #GCredentials is not supported on the
+     * OS or if the native credentials type does not contain information
+     * about the UNIX user. It can also fail if the OS does not allow the
+     * use of "spoofed" credentials.
+     * @param uid - The UNIX user identifier to set.
+     */
     setUnixUser(uid) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_credentials_set_unix_user", [
@@ -131,6 +214,10 @@ export class Credentials extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Creates a human-readable textual representation of `credentials` that can be used in logging and debug messages. The format of the
+     * returned string may change in future GLib release.
+     */
     toString() {
         return call("libgio-2.0.so.0", "g_credentials_to_string", [
             {

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

@@ -4,29 +4,256 @@ import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { InputStream } from "./input-stream.js";
 import { BufferedInputStream } from "./buffered-input-stream.js";
+/**
+ * Data input stream implements [class@Gio.InputStream] and includes functions
+ * for reading structured data directly from a binary input stream.
+ */
 export declare class DataInputStream extends BufferedInputStream {
+    /**
+     * Creates a new data input stream for the @base_stream.
+     * @param baseStream - a #GInputStream.
+     */
     constructor(baseStream: InputStream);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the byte order for the data input stream.
+     */
     getByteOrder(): DataStreamByteOrder;
+    /**
+     * Gets the current newline type for the @stream.
+     */
     getNewlineType(): DataStreamNewlineType;
+    /**
+     * Reads a 16-bit/2-byte value from @stream.
+     *
+     * In order to get the correct byte order for this read operation,
+     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readInt16(cancellable?: Cancellable | null): number;
+    /**
+     * Reads a signed 32-bit/4-byte value from @stream.
+     *
+     * In order to get the correct byte order for this read operation,
+     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+     *
+     * 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 cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readInt32(cancellable?: Cancellable | null): number;
+    /**
+     * Reads a 64-bit/8-byte value from @stream.
+     *
+     * In order to get the correct byte order for this read operation,
+     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+     *
+     * 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 cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readInt64(cancellable?: Cancellable | null): number;
+    /**
+     * Reads a line from the data input stream.  Note that no encoding
+     * checks or conversion is performed; the input is not guaranteed to
+     * be UTF-8, and may in fact have embedded NUL characters.
+     *
+     * 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 length - a #gsize to get the length of the data read in.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readLine(length?: Ref<number> | null, cancellable?: Cancellable | null): number[] | null;
+    /**
+     * The asynchronous version of g_data_input_stream_read_line().  It is
+     * an error to have two outstanding calls to this function.
+     *
+     * When the operation is finished, `callback` will be called. You
+     * can then call g_data_input_stream_read_line_finish() to get
+     * the result of the operation.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - callback to call when the request is satisfied.
+     * @param userData - the data to pass to callback function.
+     */
     readLineAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finish an asynchronous call started by
+     * g_data_input_stream_read_line_async().  Note the warning about
+     * string encoding in g_data_input_stream_read_line() applies here as
+     * well.
+     * @param result - the #GAsyncResult that was provided to the callback.
+     * @param length - a #gsize to get the length of the data read in.
+     */
     readLineFinish(result: AsyncResult, length?: Ref<number> | null): number[] | null;
+    /**
+     * Finish an asynchronous call started by
+     * g_data_input_stream_read_line_async().
+     * @param result - the #GAsyncResult that was provided to the callback.
+     * @param length - a #gsize to get the length of the data read in.
+     */
     readLineFinishUtf8(result: AsyncResult, length?: Ref<number> | null): string | null;
+    /**
+     * Reads a UTF-8 encoded line from the data input stream.
+     *
+     * 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 length - a #gsize to get the length of the data read in.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readLineUtf8(length?: Ref<number> | null, cancellable?: Cancellable | null): string | null;
+    /**
+     * Reads an unsigned 16-bit/2-byte value from @stream.
+     *
+     * In order to get the correct byte order for this read operation,
+     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readUint16(cancellable?: Cancellable | null): number;
+    /**
+     * Reads an unsigned 32-bit/4-byte value from @stream.
+     *
+     * In order to get the correct byte order for this read operation,
+     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+     *
+     * 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 cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readUint32(cancellable?: Cancellable | null): number;
+    /**
+     * Reads an unsigned 64-bit/8-byte value from @stream.
+     *
+     * In order to get the correct byte order for this read operation,
+     * see g_data_input_stream_get_byte_order().
+     *
+     * 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 cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readUint64(cancellable?: Cancellable | null): number;
+    /**
+     * Reads a string from the data input stream, up to the first
+     * occurrence of any of the stop characters.
+     *
+     * Note that, in contrast to g_data_input_stream_read_until_async(),
+     * this function consumes the stop character that it finds.
+     *
+     * Don't use this function in new code.  Its functionality is
+     * inconsistent with g_data_input_stream_read_until_async().  Both
+     * functions will be marked as deprecated in a future release.  Use
+     * g_data_input_stream_read_upto() instead, but note that that function
+     * does not consume the stop character.
+     * @param stopChars - characters to terminate the read.
+     * @param length - a #gsize to get the length of the data read in.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     readUntil(stopChars: string, length?: Ref<number> | null, cancellable?: Cancellable | null): string;
+    /**
+     * The asynchronous version of g_data_input_stream_read_until().
+     * It is an error to have two outstanding calls to this function.
+     *
+     * Note that, in contrast to g_data_input_stream_read_until(),
+     * this function does not consume the stop character that it finds.  You
+     * must read it for yourself.
+     *
+     * When the operation is finished, `callback` will be called. You
+     * can then call g_data_input_stream_read_until_finish() to get
+     * the result of the operation.
+     *
+     * Don't use this function in new code.  Its functionality is
+     * inconsistent with g_data_input_stream_read_until().  Both functions
+     * will be marked as deprecated in a future release.  Use
+     * g_data_input_stream_read_upto_async() instead.
+     * @param stopChars - characters to terminate the read.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - callback to call when the request is satisfied.
+     * @param userData - the data to pass to callback function.
+     */
     readUntilAsync(stopChars: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finish an asynchronous call started by
+     * g_data_input_stream_read_until_async().
+     * @param result - the #GAsyncResult that was provided to the callback.
+     * @param length - a #gsize to get the length of the data read in.
+     */
     readUntilFinish(result: AsyncResult, length?: Ref<number> | null): string;
+    /**
+     * Reads a string from the data input stream, up to the first
+     * occurrence of any of the stop characters.
+     *
+     * In contrast to g_data_input_stream_read_until(), this function
+     * does not consume the stop character. You have to use
+     * g_data_input_stream_read_byte() to get it before calling
+     * g_data_input_stream_read_upto() again.
+     *
+     * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
+     * specified.
+     *
+     * The returned string will always be nul-terminated on success.
+     * @param stopChars - characters to terminate the read
+     * @param stopCharsLen - length of @stop_chars. May be -1 if `stop_chars` is
+     * @param length - a #gsize to get the length of the data read in
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     */
     readUpto(stopChars: string, stopCharsLen: number, length?: Ref<number> | null, cancellable?: Cancellable | null): string;
+    /**
+     * The asynchronous version of g_data_input_stream_read_upto().
+     * It is an error to have two outstanding calls to this function.
+     *
+     * In contrast to g_data_input_stream_read_until(), this function
+     * does not consume the stop character. You have to use
+     * g_data_input_stream_read_byte() to get it before calling
+     * g_data_input_stream_read_upto() again.
+     *
+     * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
+     * specified.
+     *
+     * When the operation is finished, `callback` will be called. You
+     * can then call g_data_input_stream_read_upto_finish() to get
+     * the result of the operation.
+     * @param stopChars - characters to terminate the read
+     * @param stopCharsLen - length of @stop_chars. May be -1 if `stop_chars` is
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - callback to call when the request is satisfied
+     * @param userData - the data to pass to callback function
+     */
     readUptoAsync(stopChars: string, stopCharsLen: number, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finish an asynchronous call started by
+     * g_data_input_stream_read_upto_async().
+     *
+     * Note that this function does not consume the stop character. You
+     * have to use g_data_input_stream_read_byte() to get it before calling
+     * g_data_input_stream_read_upto_async() again.
+     *
+     * The returned string will always be nul-terminated on success.
+     * @param result - the #GAsyncResult that was provided to the callback
+     * @param length - a #gsize to get the length of the data read in
+     */
     readUptoFinish(result: AsyncResult, length?: Ref<number> | null): string;
+    /**
+     * This function sets the byte order for the given @stream. All subsequent
+     * reads from the `stream` will be read in the given @order.
+     * @param order - a #GDataStreamByteOrder to set.
+     */
     setByteOrder(order: DataStreamByteOrder): void;
+    /**
+     * Sets the newline type for the @stream.
+     *
+     * Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
+     * chunk ends in "CR" we must read an additional byte to know if this is "CR" or
+     * "CR LF", and this might block if there is no more data available.
+     * @param type - the type of new line return as #GDataStreamNewlineType.
+     */
     setNewlineType(type: DataStreamNewlineType): void;
 }