@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,6 +1,17 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
+/**
+ * `GPollableOutputStream` is implemented by [class@Gio.OutputStream]s that
+ * can be polled for readiness to write. This can be used when
+ * interfacing with a non-GIO API that expects
+ * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
+ *
+ * Some classes may implement `GPollableOutputStream` but have only certain
+ * instances of that class be pollable. If [method@Gio.PollableOutputStream.can_poll]
+ * returns false, then the behavior of other `GPollableOutputStream` methods is
+ * undefined.
+ */
 export class PollableOutputStream {
     ptr;
     constructor(ptr) {
@@ -9,6 +20,15 @@ export class PollableOutputStream {
     static fromPtr(ptr) {
         return new PollableOutputStream(ptr);
     }
+    /**
+     * 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", [
             {
@@ -17,6 +37,20 @@ export class PollableOutputStream {
             },
         ], { 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", [
             {
@@ -36,6 +70,19 @@ export class PollableOutputStream {
         });
         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", [
             {
@@ -44,6 +91,29 @@ export class PollableOutputStream {
             },
         ], { 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", [
@@ -84,6 +154,31 @@ export class PollableOutputStream {
         }
         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/power-profile-monitor.d.ts

@@ -1,6 +1,39 @@
+/**
+ * `GPowerProfileMonitor` makes it possible for applications as well as OS
+ * components to monitor system power profiles and act upon them. It currently
+ * only exports whether the system is in “Power Saver” mode (known as
+ * “Low Power” mode on some systems).
+ *
+ * When in “Low Power” mode, it is recommended that applications:
+ *
+ * - disable automatic downloads;
+ * - reduce the rate of refresh from online sources such as calendar or
+ * email synchronisation;
+ * - reduce the use of expensive visual effects.
+ *
+ * It is also likely that OS components providing services to applications will
+ * lower their own background activity, for the sake of the system.
+ *
+ * There are a variety of tools that exist for power consumption analysis, but those
+ * usually depend on the OS and hardware used. On Linux, one could use `upower` to
+ * monitor the battery discharge rate, `powertop` to check on the background activity
+ * or activity at all), `sysprof` to inspect CPU usage, and `intel_gpu_time` to
+ * profile GPU usage.
+ *
+ * Don’t forget to disconnect the [signal@GObject.Object::notify] signal for
+ * [property@Gio.PowerProfileMonitor:power-saver-enabled], and unref the
+ * `GPowerProfileMonitor` itself when exiting.
+ */
 export declare class PowerProfileMonitor {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): PowerProfileMonitor;
+    /**
+     * Gets whether the system is in “Power Saver” mode.
+     *
+     * You are expected to listen to the
+     * #GPowerProfileMonitor::notify::power-saver-enabled signal to know when the profile has
+     * changed.
+     */
     getPowerSaverEnabled(): boolean;
 }

package/dist/generated/gio/power-profile-monitor.js

@@ -1,4 +1,30 @@
 import { call } from "@gtkx/native";
+/**
+ * `GPowerProfileMonitor` makes it possible for applications as well as OS
+ * components to monitor system power profiles and act upon them. It currently
+ * only exports whether the system is in “Power Saver” mode (known as
+ * “Low Power” mode on some systems).
+ *
+ * When in “Low Power” mode, it is recommended that applications:
+ *
+ * - disable automatic downloads;
+ * - reduce the rate of refresh from online sources such as calendar or
+ * email synchronisation;
+ * - reduce the use of expensive visual effects.
+ *
+ * It is also likely that OS components providing services to applications will
+ * lower their own background activity, for the sake of the system.
+ *
+ * There are a variety of tools that exist for power consumption analysis, but those
+ * usually depend on the OS and hardware used. On Linux, one could use `upower` to
+ * monitor the battery discharge rate, `powertop` to check on the background activity
+ * or activity at all), `sysprof` to inspect CPU usage, and `intel_gpu_time` to
+ * profile GPU usage.
+ *
+ * Don’t forget to disconnect the [signal@GObject.Object::notify] signal for
+ * [property@Gio.PowerProfileMonitor:power-saver-enabled], and unref the
+ * `GPowerProfileMonitor` itself when exiting.
+ */
 export class PowerProfileMonitor {
     ptr;
     constructor(ptr) {
@@ -7,6 +33,13 @@ export class PowerProfileMonitor {
     static fromPtr(ptr) {
         return new PowerProfileMonitor(ptr);
     }
+    /**
+     * Gets whether the system is in “Power Saver” mode.
+     *
+     * You are expected to listen to the
+     * #GPowerProfileMonitor::notify::power-saver-enabled signal to know when the profile has
+     * changed.
+     */
     getPowerSaverEnabled() {
         return call("libgio-2.0.so.0", "g_power_profile_monitor_get_power_saver_enabled", [
             {

package/dist/generated/gio/property-action.d.ts

@@ -1,16 +1,170 @@
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A `GPropertyAction` is a way to get a [iface@Gio.Action] with a state value
+ * reflecting and controlling the value of a [class@GObject.Object] property.
+ *
+ * The state of the action will correspond to the value of the property.
+ * Changing it will change the property (assuming the requested value
+ * matches the requirements as specified in the [type@GObject.ParamSpec]).
+ *
+ * Only the most common types are presently supported.  Booleans are
+ * mapped to booleans, strings to strings, signed/unsigned integers to
+ * int32/uint32 and floats and doubles to doubles.
+ *
+ * If the property is an enum then the state will be string-typed and
+ * conversion will automatically be performed between the enum value and
+ * ‘nick’ string as per the [type@GObject.EnumValue] table.
+ *
+ * Flags types are not currently supported.
+ *
+ * Properties of object types, boxed types and pointer types are not
+ * supported and probably never will be.
+ *
+ * Properties of [type@GLib.Variant] types are not currently supported.
+ *
+ * If the property is boolean-valued then the action will have a `NULL`
+ * parameter type, and activating the action (with no parameter) will
+ * toggle the value of the property.
+ *
+ * In all other cases, the parameter type will correspond to the type of
+ * the property.
+ *
+ * The general idea here is to reduce the number of locations where a
+ * particular piece of state is kept (and therefore has to be synchronised
+ * between). `GPropertyAction` does not have a separate state that is kept
+ * in sync with the property value — its state is the property value.
+ *
+ * For example, it might be useful to create a [iface@Gio.Action] corresponding
+ * to the `visible-child-name` property of a `GtkStack`
+ * so that the current page can be switched from a menu.  The active radio
+ * indication in the menu is then directly determined from the active page of
+ * the `GtkStack`.
+ *
+ * An anti-example would be binding the `active-id` property on a
+ * `GtkComboBox`. This is
+ * because the state of the combo box itself is probably uninteresting and is
+ * actually being used to control something else.
+ *
+ * Another anti-example would be to bind to the `visible-child-name`
+ * property of a `GtkStack` if
+ * this value is actually stored in [class@Gio.Settings].  In that case, the
+ * real source of the value is* [class@Gio.Settings].  If you want
+ * a [iface@Gio.Action] to control a setting stored in [class@Gio.Settings],
+ * see [method@Gio.Settings.create_action] instead, and possibly combine its
+ * use with [method@Gio.Settings.bind].
+ */
 export declare class PropertyAction extends GObject.GObject {
+    /**
+     * Creates a #GAction corresponding to the value of property
+     * `property_name` on @object.
+     *
+     * The property must be existent and readable and writable (and not
+     * construct-only).
+     *
+     * This function takes a reference on `object` and doesn't release it
+     * until the action is destroyed.
+     * @param name - the name of the action to create
+     * @param object - the object that has the property
+     * @param propertyName - the name of the property
+     */
     constructor(name: string, object: GObject.GObject, propertyName: string);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Activates the action.
+     *
+     * `parameter` must be the correct type of parameter for the action (ie:
+     * the parameter type given at construction time).  If the parameter
+     * type was `NULL` then `parameter` must also be `NULL`.
+     *
+     * If the `parameter` [type@GLib.Variant] is floating, it is consumed.
+     * @param parameter - the parameter to the activation
+     */
     activate(parameter?: GLib.Variant | null): void;
+    /**
+     * Request for the state of `action` to be changed to @value.
+     *
+     * The action must be stateful and `value` must be of the correct type.
+     * See [method@Gio.Action.get_state_type].
+     *
+     * This call merely requests a change.  The action may refuse to change
+     * its state or may change its state to something other than @value.
+     * See [method@Gio.Action.get_state_hint].
+     *
+     * If the `value` [type@GLib.Variant] is floating, it is consumed.
+     * @param value - the new state
+     */
     changeState(value: GLib.Variant): void;
+    /**
+     * Checks if `action` is currently enabled.
+     *
+     * An action must be enabled in order to be activated or in order to
+     * have its state changed from outside callers.
+     */
     getEnabled(): boolean;
+    /**
+     * Queries the name of @action.
+     */
     getName(): string;
+    /**
+     * Queries the type of the parameter that must be given when activating
+     * @action.
+     *
+     * When activating the action using [method@Gio.Action.activate], the
+     * [type@GLib.Variant] given to that function must be of the type returned by
+     * this function.
+     *
+     * In the case that this function returns `NULL`, you must not give any
+     * [type@GLib.Variant], but `NULL` instead.
+     */
     getParameterType(): GLib.VariantType | null;
+    /**
+     * Queries the current state of @action.
+     *
+     * If the action is not stateful then `NULL` will be returned.  If the
+     * action is stateful then the type of the return value is the type
+     * given by [method@Gio.Action.get_state_type].
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * [method@GLib.Variant.unref] when it is no longer required.
+     */
     getState(): GLib.Variant | null;
+    /**
+     * Requests a hint about the valid range of values for the state of
+     * @action.
+     *
+     * If `NULL` is returned it either means that the action is not stateful
+     * or that there is no hint about the valid range of values for the
+     * state of the action.
+     *
+     * If a [type@GLib.Variant] array is returned then each item in the array is a
+     * possible value for the state.  If a [type@GLib.Variant] pair (ie: two-tuple) is
+     * returned then the tuple specifies the inclusive lower and upper bound
+     * of valid values for the state.
+     *
+     * In any case, the information is merely a hint.  It may be possible to
+     * have a state value outside of the hinted range and setting a value
+     * within the range may fail.
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * [method@GLib.Variant.unref] when it is no longer required.
+     */
     getStateHint(): GLib.Variant | null;
+    /**
+     * Queries the type of the state of @action.
+     *
+     * If the action is stateful (e.g. created with
+     * [ctor@Gio.SimpleAction.new_stateful]) then this function returns the
+     * [type@GLib.VariantType] of the state.  This is the type of the initial value
+     * given as the state. All calls to [method@Gio.Action.change_state] must give a
+     * [type@GLib.Variant] of this type and [method@Gio.Action.get_state] will return a
+     * [type@GLib.Variant] of the same type.
+     *
+     * If the action is not stateful (e.g. created with [ctor@Gio.SimpleAction.new])
+     * then this function will return `NULL`. In that case, [method@Gio.Action.get_state]
+     * will return `NULL` and you must not call [method@Gio.Action.change_state].
+     */
     getStateType(): GLib.VariantType | null;
     connect(signal: "notify", handler: (self: PropertyAction, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/property-action.js

@@ -2,6 +2,60 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A `GPropertyAction` is a way to get a [iface@Gio.Action] with a state value
+ * reflecting and controlling the value of a [class@GObject.Object] property.
+ *
+ * The state of the action will correspond to the value of the property.
+ * Changing it will change the property (assuming the requested value
+ * matches the requirements as specified in the [type@GObject.ParamSpec]).
+ *
+ * Only the most common types are presently supported.  Booleans are
+ * mapped to booleans, strings to strings, signed/unsigned integers to
+ * int32/uint32 and floats and doubles to doubles.
+ *
+ * If the property is an enum then the state will be string-typed and
+ * conversion will automatically be performed between the enum value and
+ * ‘nick’ string as per the [type@GObject.EnumValue] table.
+ *
+ * Flags types are not currently supported.
+ *
+ * Properties of object types, boxed types and pointer types are not
+ * supported and probably never will be.
+ *
+ * Properties of [type@GLib.Variant] types are not currently supported.
+ *
+ * If the property is boolean-valued then the action will have a `NULL`
+ * parameter type, and activating the action (with no parameter) will
+ * toggle the value of the property.
+ *
+ * In all other cases, the parameter type will correspond to the type of
+ * the property.
+ *
+ * The general idea here is to reduce the number of locations where a
+ * particular piece of state is kept (and therefore has to be synchronised
+ * between). `GPropertyAction` does not have a separate state that is kept
+ * in sync with the property value — its state is the property value.
+ *
+ * For example, it might be useful to create a [iface@Gio.Action] corresponding
+ * to the `visible-child-name` property of a `GtkStack`
+ * so that the current page can be switched from a menu.  The active radio
+ * indication in the menu is then directly determined from the active page of
+ * the `GtkStack`.
+ *
+ * An anti-example would be binding the `active-id` property on a
+ * `GtkComboBox`. This is
+ * because the state of the combo box itself is probably uninteresting and is
+ * actually being used to control something else.
+ *
+ * Another anti-example would be to bind to the `visible-child-name`
+ * property of a `GtkStack` if
+ * this value is actually stored in [class@Gio.Settings].  In that case, the
+ * real source of the value is* [class@Gio.Settings].  If you want
+ * a [iface@Gio.Action] to control a setting stored in [class@Gio.Settings],
+ * see [method@Gio.Settings.create_action] instead, and possibly combine its
+ * use with [method@Gio.Settings.bind].
+ */
 export class PropertyAction extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -23,6 +77,16 @@ export class PropertyAction extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Activates the action.
+     *
+     * `parameter` must be the correct type of parameter for the action (ie:
+     * the parameter type given at construction time).  If the parameter
+     * type was `NULL` then `parameter` must also be `NULL`.
+     *
+     * If the `parameter` [type@GLib.Variant] is floating, it is consumed.
+     * @param parameter - the parameter to the activation
+     */
     activate(parameter) {
         call("libgio-2.0.so.0", "g_action_activate", [
             {
@@ -41,6 +105,19 @@ export class PropertyAction extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Request for the state of `action` to be changed to @value.
+     *
+     * The action must be stateful and `value` must be of the correct type.
+     * See [method@Gio.Action.get_state_type].
+     *
+     * This call merely requests a change.  The action may refuse to change
+     * its state or may change its state to something other than @value.
+     * See [method@Gio.Action.get_state_hint].
+     *
+     * If the `value` [type@GLib.Variant] is floating, it is consumed.
+     * @param value - the new state
+     */
     changeState(value) {
         call("libgio-2.0.so.0", "g_action_change_state", [
             {
@@ -58,6 +135,12 @@ export class PropertyAction extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if `action` is currently enabled.
+     *
+     * An action must be enabled in order to be activated or in order to
+     * have its state changed from outside callers.
+     */
     getEnabled() {
         return call("libgio-2.0.so.0", "g_action_get_enabled", [
             {
@@ -66,6 +149,9 @@ export class PropertyAction extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Queries the name of @action.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_action_get_name", [
             {
@@ -74,6 +160,17 @@ export class PropertyAction extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Queries the type of the parameter that must be given when activating
+     * @action.
+     *
+     * When activating the action using [method@Gio.Action.activate], the
+     * [type@GLib.Variant] given to that function must be of the type returned by
+     * this function.
+     *
+     * In the case that this function returns `NULL`, you must not give any
+     * [type@GLib.Variant], but `NULL` instead.
+     */
     getParameterType() {
         const ptr = call("libgio-2.0.so.0", "g_action_get_parameter_type", [
             {
@@ -90,6 +187,16 @@ export class PropertyAction extends GObject.GObject {
             return null;
         return getObject(ptr, GLib.VariantType);
     }
+    /**
+     * Queries the current state of @action.
+     *
+     * If the action is not stateful then `NULL` will be returned.  If the
+     * action is stateful then the type of the return value is the type
+     * given by [method@Gio.Action.get_state_type].
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * [method@GLib.Variant.unref] when it is no longer required.
+     */
     getState() {
         const ptr = call("libgio-2.0.so.0", "g_action_get_state", [
             {
@@ -106,6 +213,26 @@ export class PropertyAction extends GObject.GObject {
             return null;
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Requests a hint about the valid range of values for the state of
+     * @action.
+     *
+     * If `NULL` is returned it either means that the action is not stateful
+     * or that there is no hint about the valid range of values for the
+     * state of the action.
+     *
+     * If a [type@GLib.Variant] array is returned then each item in the array is a
+     * possible value for the state.  If a [type@GLib.Variant] pair (ie: two-tuple) is
+     * returned then the tuple specifies the inclusive lower and upper bound
+     * of valid values for the state.
+     *
+     * In any case, the information is merely a hint.  It may be possible to
+     * have a state value outside of the hinted range and setting a value
+     * within the range may fail.
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * [method@GLib.Variant.unref] when it is no longer required.
+     */
     getStateHint() {
         const ptr = call("libgio-2.0.so.0", "g_action_get_state_hint", [
             {
@@ -122,6 +249,20 @@ export class PropertyAction extends GObject.GObject {
             return null;
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Queries the type of the state of @action.
+     *
+     * If the action is stateful (e.g. created with
+     * [ctor@Gio.SimpleAction.new_stateful]) then this function returns the
+     * [type@GLib.VariantType] of the state.  This is the type of the initial value
+     * given as the state. All calls to [method@Gio.Action.change_state] must give a
+     * [type@GLib.Variant] of this type and [method@Gio.Action.get_state] will return a
+     * [type@GLib.Variant] of the same type.
+     *
+     * If the action is not stateful (e.g. created with [ctor@Gio.SimpleAction.new])
+     * then this function will return `NULL`. In that case, [method@Gio.Action.get_state]
+     * will return `NULL` and you must not call [method@Gio.Action.change_state].
+     */
     getStateType() {
         const ptr = call("libgio-2.0.so.0", "g_action_get_state_type", [
             {

package/dist/generated/gio/proxy-address-enumerator.d.ts

@@ -1,4 +1,16 @@
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
+/**
+ * `GProxyAddressEnumerator` is a wrapper around
+ * [class@Gio.SocketAddressEnumerator] which takes the [class@Gio.SocketAddress]
+ * instances returned by the [class@Gio.SocketAddressEnumerator]
+ * and wraps them in [class@Gio.ProxyAddress] instances, using the given
+ * [property@Gio.ProxyAddressEnumerator:proxy-resolver].
+ *
+ * This enumerator will be returned (for example, by
+ * [method@Gio.SocketConnectable.enumerate]) as appropriate when a proxy is
+ * configured; there should be no need to manually wrap a
+ * [class@Gio.SocketAddressEnumerator] instance with one.
+ */
 export declare class ProxyAddressEnumerator extends SocketAddressEnumerator {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;

package/dist/generated/gio/proxy-address-enumerator.js

@@ -1,5 +1,17 @@
 import { call } from "@gtkx/native";
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
+/**
+ * `GProxyAddressEnumerator` is a wrapper around
+ * [class@Gio.SocketAddressEnumerator] which takes the [class@Gio.SocketAddress]
+ * instances returned by the [class@Gio.SocketAddressEnumerator]
+ * and wraps them in [class@Gio.ProxyAddress] instances, using the given
+ * [property@Gio.ProxyAddressEnumerator:proxy-resolver].
+ *
+ * This enumerator will be returned (for example, by
+ * [method@Gio.SocketConnectable.enumerate]) as appropriate when a proxy is
+ * configured; there should be no need to manually wrap a
+ * [class@Gio.SocketAddressEnumerator] instance with one.
+ */
 export class ProxyAddressEnumerator extends SocketAddressEnumerator {
     constructor(...args) {
         super(...args);

package/dist/generated/gio/proxy-address.d.ts

@@ -1,14 +1,56 @@
 import { InetAddress } from "./inet-address.js";
 import { InetSocketAddress } from "./inet-socket-address.js";
+/** A [class@Gio.InetSocketAddress] representing a connection via a proxy server. */
 export declare class ProxyAddress extends InetSocketAddress {
+    /**
+     * Creates a new #GProxyAddress for `inetaddr` with `protocol` that should
+     * tunnel through `dest_hostname` and @dest_port.
+     *
+     * (Note that this method doesn't set the #GProxyAddress:uri or
+     * #GProxyAddress:destination-protocol fields; use g_object_new()
+     * directly if you want to set those.)
+     * @param inetaddr - The proxy server #GInetAddress.
+     * @param port - The proxy server port.
+     * @param protocol - The proxy protocol to support, in lower case (e.g. socks, http).
+     * @param destHostname - The destination hostname the proxy should tunnel to.
+     * @param destPort - The destination port to tunnel to.
+     * @param username - The username to authenticate to the proxy server
+     * @param password - The password to authenticate to the proxy server
+     */
     constructor(inetaddr: InetAddress, port: number, protocol: string, destHostname: string, destPort: number, username?: string | null, password?: string | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets @proxy's destination hostname; that is, the name of the host
+     * that will be connected to via the proxy, not the name of the proxy
+     * itself.
+     */
     getDestinationHostname(): string;
+    /**
+     * Gets @proxy's destination port; that is, the port on the
+     * destination host that will be connected to via the proxy, not the
+     * port number of the proxy itself.
+     */
     getDestinationPort(): number;
+    /**
+     * Gets the protocol that is being spoken to the destination
+     * server; eg, "http" or "ftp".
+     */
     getDestinationProtocol(): string;
+    /**
+     * Gets @proxy's password.
+     */
     getPassword(): string | null;
+    /**
+     * Gets @proxy's protocol. eg, "socks" or "http"
+     */
     getProtocol(): string;
+    /**
+     * Gets the proxy URI that `proxy` was constructed from.
+     */
     getUri(): string | null;
+    /**
+     * Gets @proxy's username.
+     */
     getUsername(): string | null;
 }