@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/tls-interaction.d.ts

@@ -4,16 +4,185 @@ import { Cancellable } from "./cancellable.js";
 import { TlsConnection } from "./tls-connection.js";
 import { TlsPassword } from "./tls-password.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GTlsInteraction` provides a mechanism for the TLS connection and database
+ * code to interact with the user. It can be used to ask the user for passwords.
+ *
+ * To use a `GTlsInteraction` with a TLS connection use
+ * [method@Gio.TlsConnection.set_interaction].
+ *
+ * Callers should instantiate a derived class that implements the various
+ * interaction methods to show the required dialogs.
+ *
+ * Callers should use the 'invoke' functions like
+ * [method@Gio.TlsInteraction.invoke_ask_password] to run interaction methods.
+ * These functions make sure that the interaction is invoked in the main loop
+ * and not in the current thread, if the current thread is not running the
+ * main loop.
+ *
+ * Derived classes can choose to implement whichever interactions methods they’d
+ * like to support by overriding those virtual methods in their class
+ * initialization function. Any interactions not implemented will return
+ * `G_TLS_INTERACTION_UNHANDLED`. If a derived class implements an async method,
+ * it must also implement the corresponding finish method.
+ */
 export declare class TlsInteraction extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Run synchronous interaction to ask the user for a password. In general,
+     * g_tls_interaction_invoke_ask_password() should be used instead of this
+     * function.
+     *
+     * Derived subclasses usually implement a password prompt, although they may
+     * also choose to provide a password from elsewhere. The `password` value will
+     * be filled in and then `callback` will be called. Alternatively the user may
+     * abort this password request, which will usually abort the TLS connection.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param password - a #GTlsPassword object
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     askPassword(password: TlsPassword, cancellable?: Cancellable | null): TlsInteractionResult;
+    /**
+     * Run asynchronous interaction to ask the user for a password. In general,
+     * g_tls_interaction_invoke_ask_password() should be used instead of this
+     * function.
+     *
+     * Derived subclasses usually implement a password prompt, although they may
+     * also choose to provide a password from elsewhere. The `password` value will
+     * be filled in and then `callback` will be called. Alternatively the user may
+     * abort this password request, which will usually abort the TLS connection.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     *
+     * Certain implementations may not support immediate cancellation.
+     * @param password - a #GTlsPassword object
+     * @param cancellable - an optional #GCancellable cancellation object
+     * @param callback - will be called when the interaction completes
+     * @param userData - data to pass to the @callback
+     */
     askPasswordAsync(password: TlsPassword, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Complete an ask password user interaction request. This should be once
+     * the g_tls_interaction_ask_password_async() completion callback is called.
+     *
+     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed
+     * to g_tls_interaction_ask_password() will have its password filled in.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code.
+     * @param result - the result passed to the callback
+     */
     askPasswordFinish(result: AsyncResult): TlsInteractionResult;
+    /**
+     * Invoke the interaction to ask the user for a password. It invokes this
+     * interaction in the main loop, specifically the #GMainContext returned by
+     * g_main_context_get_thread_default() when the interaction is created. This
+     * is called by called by #GTlsConnection or #GTlsDatabase to ask the user
+     * for a password.
+     *
+     * Derived subclasses usually implement a password prompt, although they may
+     * also choose to provide a password from elsewhere. The `password` value will
+     * be filled in and then `callback` will be called. Alternatively the user may
+     * abort this password request, which will usually abort the TLS connection.
+     *
+     * The implementation can either be a synchronous (eg: modal dialog) or an
+     * asynchronous one (eg: modeless dialog). This function will take care of
+     * calling which ever one correctly.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param password - a #GTlsPassword object
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     invokeAskPassword(password: TlsPassword, cancellable?: Cancellable | null): TlsInteractionResult;
+    /**
+     * Invoke the interaction to ask the user to choose a certificate to
+     * use with the connection. It invokes this interaction in the main
+     * loop, specifically the #GMainContext returned by
+     * g_main_context_get_thread_default() when the interaction is
+     * created. This is called by called by #GTlsConnection when the peer
+     * requests a certificate during the handshake.
+     *
+     * Derived subclasses usually implement a certificate selector,
+     * although they may also choose to provide a certificate from
+     * elsewhere. Alternatively the user may abort this certificate
+     * request, which may or may not abort the TLS connection.
+     *
+     * The implementation can either be a synchronous (eg: modal dialog) or an
+     * asynchronous one (eg: modeless dialog). This function will take care of
+     * calling which ever one correctly.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param connection - a #GTlsConnection object
+     * @param flags - flags providing more information about the request
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     invokeRequestCertificate(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable?: Cancellable | null): TlsInteractionResult;
+    /**
+     * Run synchronous interaction to ask the user to choose a certificate to use
+     * with the connection. In general, g_tls_interaction_invoke_request_certificate()
+     * should be used instead of this function.
+     *
+     * Derived subclasses usually implement a certificate selector, although they may
+     * also choose to provide a certificate from elsewhere. Alternatively the user may
+     * abort this certificate request, which will usually abort the TLS connection.
+     *
+     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+     * passed to g_tls_interaction_request_certificate() will have had its
+     * #GTlsConnection:certificate filled in.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param connection - a #GTlsConnection object
+     * @param flags - flags providing more information about the request
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     requestCertificate(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable?: Cancellable | null): TlsInteractionResult;
+    /**
+     * Run asynchronous interaction to ask the user for a certificate to use with
+     * the connection. In general, g_tls_interaction_invoke_request_certificate() should
+     * be used instead of this function.
+     *
+     * Derived subclasses usually implement a certificate selector, although they may
+     * also choose to provide a certificate from elsewhere. `callback` will be called
+     * when the operation completes. Alternatively the user may abort this certificate
+     * request, which will usually abort the TLS connection.
+     * @param connection - a #GTlsConnection object
+     * @param flags - flags providing more information about the request
+     * @param cancellable - an optional #GCancellable cancellation object
+     * @param callback - will be called when the interaction completes
+     * @param userData - data to pass to the @callback
+     */
     requestCertificateAsync(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Complete a request certificate user interaction request. This should be once
+     * the g_tls_interaction_request_certificate_async() completion callback is called.
+     *
+     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+     * passed to g_tls_interaction_request_certificate_async() will have had its
+     * #GTlsConnection:certificate filled in.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code.
+     * @param result - the result passed to the callback
+     */
     requestCertificateFinish(result: AsyncResult): TlsInteractionResult;
     connect(signal: "notify", handler: (self: TlsInteraction, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/tls-interaction.js

@@ -1,6 +1,28 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GTlsInteraction` provides a mechanism for the TLS connection and database
+ * code to interact with the user. It can be used to ask the user for passwords.
+ *
+ * To use a `GTlsInteraction` with a TLS connection use
+ * [method@Gio.TlsConnection.set_interaction].
+ *
+ * Callers should instantiate a derived class that implements the various
+ * interaction methods to show the required dialogs.
+ *
+ * Callers should use the 'invoke' functions like
+ * [method@Gio.TlsInteraction.invoke_ask_password] to run interaction methods.
+ * These functions make sure that the interaction is invoked in the main loop
+ * and not in the current thread, if the current thread is not running the
+ * main loop.
+ *
+ * Derived classes can choose to implement whichever interactions methods they’d
+ * like to support by overriding those virtual methods in their class
+ * initialization function. Any interactions not implemented will return
+ * `G_TLS_INTERACTION_UNHANDLED`. If a derived class implements an async method,
+ * it must also implement the corresponding finish method.
+ */
 export class TlsInteraction extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -16,6 +38,23 @@ export class TlsInteraction extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Run synchronous interaction to ask the user for a password. In general,
+     * g_tls_interaction_invoke_ask_password() should be used instead of this
+     * function.
+     *
+     * Derived subclasses usually implement a password prompt, although they may
+     * also choose to provide a password from elsewhere. The `password` value will
+     * be filled in and then `callback` will be called. Alternatively the user may
+     * abort this password request, which will usually abort the TLS connection.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param password - a #GTlsPassword object
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     askPassword(password, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_tls_interaction_ask_password", [
@@ -49,6 +88,27 @@ export class TlsInteraction extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Run asynchronous interaction to ask the user for a password. In general,
+     * g_tls_interaction_invoke_ask_password() should be used instead of this
+     * function.
+     *
+     * Derived subclasses usually implement a password prompt, although they may
+     * also choose to provide a password from elsewhere. The `password` value will
+     * be filled in and then `callback` will be called. Alternatively the user may
+     * abort this password request, which will usually abort the TLS connection.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     *
+     * Certain implementations may not support immediate cancellation.
+     * @param password - a #GTlsPassword object
+     * @param cancellable - an optional #GCancellable cancellation object
+     * @param callback - will be called when the interaction completes
+     * @param userData - data to pass to the @callback
+     */
     askPasswordAsync(password, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_tls_interaction_ask_password_async", [
             {
@@ -76,6 +136,18 @@ export class TlsInteraction extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Complete an ask password user interaction request. This should be once
+     * the g_tls_interaction_ask_password_async() completion callback is called.
+     *
+     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed
+     * to g_tls_interaction_ask_password() will have its password filled in.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code.
+     * @param result - the result passed to the callback
+     */
     askPasswordFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_tls_interaction_ask_password_finish", [
@@ -104,6 +176,29 @@ export class TlsInteraction extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Invoke the interaction to ask the user for a password. It invokes this
+     * interaction in the main loop, specifically the #GMainContext returned by
+     * g_main_context_get_thread_default() when the interaction is created. This
+     * is called by called by #GTlsConnection or #GTlsDatabase to ask the user
+     * for a password.
+     *
+     * Derived subclasses usually implement a password prompt, although they may
+     * also choose to provide a password from elsewhere. The `password` value will
+     * be filled in and then `callback` will be called. Alternatively the user may
+     * abort this password request, which will usually abort the TLS connection.
+     *
+     * The implementation can either be a synchronous (eg: modal dialog) or an
+     * asynchronous one (eg: modeless dialog). This function will take care of
+     * calling which ever one correctly.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param password - a #GTlsPassword object
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     invokeAskPassword(password, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_tls_interaction_invoke_ask_password", [
@@ -137,6 +232,31 @@ export class TlsInteraction extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Invoke the interaction to ask the user to choose a certificate to
+     * use with the connection. It invokes this interaction in the main
+     * loop, specifically the #GMainContext returned by
+     * g_main_context_get_thread_default() when the interaction is
+     * created. This is called by called by #GTlsConnection when the peer
+     * requests a certificate during the handshake.
+     *
+     * Derived subclasses usually implement a certificate selector,
+     * although they may also choose to provide a certificate from
+     * elsewhere. Alternatively the user may abort this certificate
+     * request, which may or may not abort the TLS connection.
+     *
+     * The implementation can either be a synchronous (eg: modal dialog) or an
+     * asynchronous one (eg: modeless dialog). This function will take care of
+     * calling which ever one correctly.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param connection - a #GTlsConnection object
+     * @param flags - flags providing more information about the request
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     invokeRequestCertificate(connection, flags, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_tls_interaction_invoke_request_certificate", [
@@ -174,6 +294,27 @@ export class TlsInteraction extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Run synchronous interaction to ask the user to choose a certificate to use
+     * with the connection. In general, g_tls_interaction_invoke_request_certificate()
+     * should be used instead of this function.
+     *
+     * Derived subclasses usually implement a certificate selector, although they may
+     * also choose to provide a certificate from elsewhere. Alternatively the user may
+     * abort this certificate request, which will usually abort the TLS connection.
+     *
+     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+     * passed to g_tls_interaction_request_certificate() will have had its
+     * #GTlsConnection:certificate filled in.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+     * not support immediate cancellation.
+     * @param connection - a #GTlsConnection object
+     * @param flags - flags providing more information about the request
+     * @param cancellable - an optional #GCancellable cancellation object
+     */
     requestCertificate(connection, flags, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_tls_interaction_request_certificate", [
@@ -211,6 +352,21 @@ export class TlsInteraction extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Run asynchronous interaction to ask the user for a certificate to use with
+     * the connection. In general, g_tls_interaction_invoke_request_certificate() should
+     * be used instead of this function.
+     *
+     * Derived subclasses usually implement a certificate selector, although they may
+     * also choose to provide a certificate from elsewhere. `callback` will be called
+     * when the operation completes. Alternatively the user may abort this certificate
+     * request, which will usually abort the TLS connection.
+     * @param connection - a #GTlsConnection object
+     * @param flags - flags providing more information about the request
+     * @param cancellable - an optional #GCancellable cancellation object
+     * @param callback - will be called when the interaction completes
+     * @param userData - data to pass to the @callback
+     */
     requestCertificateAsync(connection, flags, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_tls_interaction_request_certificate_async", [
             {
@@ -242,6 +398,19 @@ export class TlsInteraction extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Complete a request certificate user interaction request. This should be once
+     * the g_tls_interaction_request_certificate_async() completion callback is called.
+     *
+     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+     * passed to g_tls_interaction_request_certificate_async() will have had its
+     * #GTlsConnection:certificate filled in.
+     *
+     * If the interaction is cancelled by the cancellation object, or by the
+     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+     * contains a %G_IO_ERROR_CANCELLED error code.
+     * @param result - the result passed to the callback
+     */
     requestCertificateFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_tls_interaction_request_certificate_finish", [

package/dist/generated/gio/tls-password.d.ts

@@ -1,18 +1,85 @@
 import { Ref } from "@gtkx/native";
 import { TlsPasswordFlags } from "./enums.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * An abstract interface representing a password used in TLS. Often used in
+ * user interaction such as unlocking a key storage token.
+ */
 export declare class TlsPassword extends GObject.GObject {
+    /**
+     * Create a new #GTlsPassword object.
+     * @param flags - the password flags
+     * @param description - description of what the password is for
+     */
     constructor(flags: TlsPasswordFlags, description: string);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Get a description string about what the password will be used for.
+     */
     getDescription(): string;
+    /**
+     * Get flags about the password.
+     */
     getFlags(): TlsPasswordFlags;
+    /**
+     * Get the password value. If `length` is not %NULL then it will be
+     * filled in with the length of the password value. (Note that the
+     * password value is not nul-terminated, so you can only pass %NULL
+     * for `length` in contexts where you know the password will have a
+     * certain fixed length.)
+     * @param length - location to place the length of the password.
+     */
     getValue(length?: Ref<number> | null): number[];
+    /**
+     * Get a user readable translated warning. Usually this warning is a
+     * representation of the password flags returned from
+     * g_tls_password_get_flags().
+     */
     getWarning(): string;
+    /**
+     * Set a description string about what the password will be used for.
+     * @param description - The description of the password
+     */
     setDescription(description: string): void;
+    /**
+     * Set flags about the password.
+     * @param flags - The flags about the password
+     */
     setFlags(flags: TlsPasswordFlags): void;
+    /**
+     * Set the value for this password. The `value` will be copied by the password
+     * object.
+     *
+     * Specify the @length, for a non-nul-terminated password. Pass -1 as
+     * `length` if using a nul-terminated password, and `length` will be
+     * calculated automatically. (Note that the terminating nul is not
+     * considered part of the password in this case.)
+     * @param value - the new password value
+     * @param length - the length of the password, or -1
+     */
     setValue(value: number[], length: number): void;
+    /**
+     * Provide the value for this password.
+     *
+     * The `value` will be owned by the password object, and later freed using
+     * the `destroy` function callback.
+     *
+     * Specify the @length, for a non-nul-terminated password. Pass -1 as
+     * `length` if using a nul-terminated password, and `length` will be
+     * calculated automatically. (Note that the terminating nul is not
+     * considered part of the password in this case.)
+     * @param value - the value for the password
+     * @param length - the length of the password, or -1
+     * @param destroy - a function to use to free the password.
+     */
     setValueFull(value: number[], length: number, destroy?: () => void | null): void;
+    /**
+     * Set a user readable translated warning. Usually this warning is a
+     * representation of the password flags returned from
+     * g_tls_password_get_flags().
+     * @param warning - The user readable warning
+     */
     setWarning(warning: string): void;
     connect(signal: "notify", handler: (self: TlsPassword, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/tls-password.js

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * An abstract interface representing a password used in TLS. Often used in
+ * user interaction such as unlocking a key storage token.
+ */
 export class TlsPassword extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -18,6 +22,9 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Get a description string about what the password will be used for.
+     */
     getDescription() {
         return call("libgio-2.0.so.0", "g_tls_password_get_description", [
             {
@@ -26,6 +33,9 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Get flags about the password.
+     */
     getFlags() {
         return call("libgio-2.0.so.0", "g_tls_password_get_flags", [
             {
@@ -34,6 +44,14 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get the password value. If `length` is not %NULL then it will be
+     * filled in with the length of the password value. (Note that the
+     * password value is not nul-terminated, so you can only pass %NULL
+     * for `length` in contexts where you know the password will have a
+     * certain fixed length.)
+     * @param length - location to place the length of the password.
+     */
     getValue(length) {
         return call("libgio-2.0.so.0", "g_tls_password_get_value", [
             {
@@ -50,6 +68,11 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
     }
+    /**
+     * Get a user readable translated warning. Usually this warning is a
+     * representation of the password flags returned from
+     * g_tls_password_get_flags().
+     */
     getWarning() {
         return call("libgio-2.0.so.0", "g_tls_password_get_warning", [
             {
@@ -58,6 +81,10 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Set a description string about what the password will be used for.
+     * @param description - The description of the password
+     */
     setDescription(description) {
         call("libgio-2.0.so.0", "g_tls_password_set_description", [
             {
@@ -70,6 +97,10 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set flags about the password.
+     * @param flags - The flags about the password
+     */
     setFlags(flags) {
         call("libgio-2.0.so.0", "g_tls_password_set_flags", [
             {
@@ -82,6 +113,17 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the value for this password. The `value` will be copied by the password
+     * object.
+     *
+     * Specify the @length, for a non-nul-terminated password. Pass -1 as
+     * `length` if using a nul-terminated password, and `length` will be
+     * calculated automatically. (Note that the terminating nul is not
+     * considered part of the password in this case.)
+     * @param value - the new password value
+     * @param length - the length of the password, or -1
+     */
     setValue(value, length) {
         call("libgio-2.0.so.0", "g_tls_password_set_value", [
             {
@@ -101,6 +143,20 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Provide the value for this password.
+     *
+     * The `value` will be owned by the password object, and later freed using
+     * the `destroy` function callback.
+     *
+     * Specify the @length, for a non-nul-terminated password. Pass -1 as
+     * `length` if using a nul-terminated password, and `length` will be
+     * calculated automatically. (Note that the terminating nul is not
+     * considered part of the password in this case.)
+     * @param value - the value for the password
+     * @param length - the length of the password, or -1
+     * @param destroy - a function to use to free the password.
+     */
     setValueFull(value, length, destroy) {
         call("libgio-2.0.so.0", "g_tls_password_set_value_full", [
             {
@@ -125,6 +181,12 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set a user readable translated warning. Usually this warning is a
+     * representation of the password flags returned from
+     * g_tls_password_get_flags().
+     * @param warning - The user readable warning
+     */
     setWarning(warning) {
         call("libgio-2.0.so.0", "g_tls_password_set_warning", [
             {

package/dist/generated/gio/tls-server-connection.d.ts

@@ -1,3 +1,7 @@
+/**
+ * `GTlsServerConnection` is the server-side subclass of
+ * [class@Gio.TlsConnection], representing a server-side TLS connection.
+ */
 export declare class TlsServerConnection {
     ptr: unknown;
     protected constructor(ptr: unknown);

package/dist/generated/gio/tls-server-connection.js

@@ -1,3 +1,7 @@
+/**
+ * `GTlsServerConnection` is the server-side subclass of
+ * [class@Gio.TlsConnection], representing a server-side TLS connection.
+ */
 export class TlsServerConnection {
     ptr;
     constructor(ptr) {