@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/simple-async-result.js

@@ -1,10 +1,185 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * As of GLib 2.46, `GSimpleAsyncResult` is deprecated in favor of
+ * [class@Gio.Task], which provides a simpler API.
+ *
+ * `GSimpleAsyncResult` implements [iface@Gio.AsyncResult].
+ *
+ * `GSimpleAsyncResult` handles [type@Gio.AsyncReadyCallback]s, error
+ * reporting, operation cancellation and the final state of an operation,
+ * completely transparent to the application. Results can be returned
+ * as a pointer e.g. for functions that return data that is collected
+ * asynchronously, a boolean value for checking the success or failure
+ * of an operation, or a `gssize` for operations which return the number
+ * of bytes modified by the operation; all of the simple return cases
+ * are covered.
+ *
+ * Most of the time, an application will not need to know of the details
+ * of this API; it is handled transparently, and any necessary operations
+ * are handled by [iface@Gio.AsyncResult]’s interface. However, if implementing
+ * a new GIO module, for writing language bindings, or for complex
+ * applications that need better control of how asynchronous operations
+ * are completed, it is important to understand this functionality.
+ *
+ * `GSimpleAsyncResult`s are tagged with the calling function to ensure
+ * that asynchronous functions and their finishing functions are used
+ * together correctly.
+ *
+ * To create a new `GSimpleAsyncResult`, call [ctor@Gio.SimpleAsyncResult.new].
+ * If the result needs to be created for a `GError`, use
+ * [ctor@Gio.SimpleAsyncResult.new_from_error] or
+ * [ctor@Gio.SimpleAsyncResult.new_take_error]. If a `GError` is not available
+ * (e.g. the asynchronous operation doesn’t take a `GError` argument),
+ * but the result still needs to be created for an error condition, use
+ * [ctor@Gio.SimpleAsyncResult.new_error] (or
+ * [method@Gio.SimpleAsyncResult.set_error_va] if your application or binding
+ * requires passing a variable argument list directly), and the error can then
+ * be propagated through the use of
+ * [method@Gio.SimpleAsyncResult.propagate_error].
+ *
+ * An asynchronous operation can be made to ignore a cancellation event by
+ * calling [method@Gio.SimpleAsyncResult.set_handle_cancellation] with a
+ * `GSimpleAsyncResult` for the operation and `FALSE`. This is useful for
+ * operations that are dangerous to cancel, such as close (which would
+ * cause a leak if cancelled before being run).
+ *
+ * `GSimpleAsyncResult` can integrate into GLib’s event loop,
+ * [type@GLib.MainLoop], or it can use [type@GLib.Thread]s.
+ * [method@Gio.SimpleAsyncResult.complete] will finish an I/O task directly
+ * from the point where it is called.
+ * [method@Gio.SimpleAsyncResult.complete_in_idle] will finish it from an idle
+ * handler in the  thread-default main context (see
+ * [method@GLib.MainContext.push_thread_default]) where the `GSimpleAsyncResult`
+ * was created. [method@Gio.SimpleAsyncResult.run_in_thread] will run the job in
+ * a separate thread and then use
+ * [method@Gio.SimpleAsyncResult.complete_in_idle] to deliver the result.
+ *
+ * To set the results of an asynchronous function,
+ * [method@Gio.SimpleAsyncResult.set_op_res_gpointer],
+ * [method@Gio.SimpleAsyncResult.set_op_res_gboolean], and
+ * [method@Gio.SimpleAsyncResult.set_op_res_gssize]
+ * are provided, setting the operation's result to a `gpointer`, `gboolean`, or
+ * `gssize`, respectively.
+ *
+ * Likewise, to get the result of an asynchronous function,
+ * [method@Gio.SimpleAsyncResult.get_op_res_gpointer],
+ * [method@Gio.SimpleAsyncResult.get_op_res_gboolean], and
+ * [method@Gio.SimpleAsyncResult.get_op_res_gssize] are
+ * provided, getting the operation’s result as a `gpointer`, `gboolean`, and
+ * `gssize`, respectively.
+ *
+ * For the details of the requirements implementations must respect, see
+ * [iface@Gio.AsyncResult].  A typical implementation of an asynchronous
+ * operation using `GSimpleAsyncResult` looks something like this:
+ *
+ * ```c
+ * static void
+ * baked_cb (Cake    *cake,
+ * gpointer user_data)
+ * {
+ * // In this example, this callback is not given a reference to the cake,
+ * // so the GSimpleAsyncResult has to take a reference to it.
+ * GSimpleAsyncResult *result = user_data;
+ *
+ * if (cake == NULL)
+ * g_simple_async_result_set_error (result,
+ * BAKER_ERRORS,
+ * BAKER_ERROR_NO_FLOUR,
+ * "Go to the supermarket");
+ * else
+ * g_simple_async_result_set_op_res_gpointer (result,
+ * g_object_ref (cake),
+ * g_object_unref);
+ *
+ *
+ * // In this example, we assume that baked_cb is called as a callback from
+ * // the mainloop, so it's safe to complete the operation synchronously here.
+ * // If, however, _baker_prepare_cake () might call its callback without
+ * // first returning to the mainloop — inadvisable, but some APIs do so —
+ * // we would need to use g_simple_async_result_complete_in_idle().
+ * g_simple_async_result_complete (result);
+ * g_object_unref (result);
+ * }
+ *
+ * void
+ * baker_bake_cake_async (Baker              *self,
+ * guint               radius,
+ * GAsyncReadyCallback callback,
+ * gpointer            user_data)
+ * {
+ * GSimpleAsyncResult *simple;
+ * Cake               *cake;
+ *
+ * if (radius < 3)
+ * {
+ * g_simple_async_report_error_in_idle (G_OBJECT (self),
+ * callback,
+ * user_data,
+ * BAKER_ERRORS,
+ * BAKER_ERROR_TOO_SMALL,
+ * "%ucm radius cakes are silly",
+ * radius);
+ * return;
+ * }
+ *
+ * simple = g_simple_async_result_new (G_OBJECT (self),
+ * callback,
+ * user_data,
+ * baker_bake_cake_async);
+ * cake = _baker_get_cached_cake (self, radius);
+ *
+ * if (cake != NULL)
+ * {
+ * g_simple_async_result_set_op_res_gpointer (simple,
+ * g_object_ref (cake),
+ * g_object_unref);
+ * g_simple_async_result_complete_in_idle (simple);
+ * g_object_unref (simple);
+ * // Drop the reference returned by _baker_get_cached_cake();
+ * // the GSimpleAsyncResult has taken its own reference.
+ * g_object_unref (cake);
+ * return;
+ * }
+ *
+ * _baker_prepare_cake (self, radius, baked_cb, simple);
+ * }
+ *
+ * Cake *
+ * baker_bake_cake_finish (Baker        *self,
+ * GAsyncResult *result,
+ * GError      **error)
+ * {
+ * GSimpleAsyncResult *simple;
+ * Cake               *cake;
+ *
+ * g_return_val_if_fail (g_simple_async_result_is_valid (result,
+ * G_OBJECT (self),
+ * baker_bake_cake_async),
+ * NULL);
+ *
+ * simple = (GSimpleAsyncResult *) result;
+ *
+ * if (g_simple_async_result_propagate_error (simple, error))
+ * return NULL;
+ *
+ * cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple));
+ * return g_object_ref (cake);
+ * }
+ * ```
+ */
 export class SimpleAsyncResult extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a #GSimpleAsyncResult from an error condition.
+     * @param sourceObject - a #GObject, or %NULL.
+     * @param callback - a #GAsyncReadyCallback.
+     * @param userData - user data passed to @callback.
+     * @param error - a #GError
+     */
     static asyncResultNewFromError(error, sourceObject, callback, userData) {
         const ptr = call("libgio-2.0.so.0", "g_simple_async_result_new_from_error", [
             {
@@ -59,6 +234,23 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Ensures that the data passed to the _finish function of an async
+     * operation is consistent.  Three checks are performed.
+     *
+     * First, `result` is checked to ensure that it is really a
+     * #GSimpleAsyncResult.  Second, `source` is checked to ensure that it
+     * matches the source object of @result.  Third, `source_tag` is
+     * checked to ensure that it is equal to the `source_tag` argument given
+     * to g_simple_async_result_new() (which, by convention, is a pointer
+     * to the _async function corresponding to the _finish function from
+     * which this function is called).  (Alternatively, if either
+     * `source_tag` or @result's source tag is %NULL, then the source tag
+     * check is skipped.)
+     * @param result - the #GAsyncResult passed to the _finish function.
+     * @param source - the #GObject passed to the _finish function.
+     * @param sourceTag - the asynchronous function.
+     */
     static isValid(result, source, sourceTag) {
         return call("libgio-2.0.so.0", "g_simple_async_result_is_valid", [
             {
@@ -77,6 +269,15 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Completes an asynchronous I/O job immediately. Must be called in
+     * the thread where the asynchronous result was to be delivered, as it
+     * invokes the callback directly. If you are in a different thread use
+     * g_simple_async_result_complete_in_idle().
+     *
+     * Calling this function takes a reference to `simple` for as long as
+     * is needed to complete the call.
+     */
     complete() {
         call("libgio-2.0.so.0", "g_simple_async_result_complete", [
             {
@@ -85,6 +286,15 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Completes an asynchronous function in an idle handler in the
+     * thread-default main context (see [method@GLib.MainContext.push_thread_default])
+     * of the thread that `simple` was initially created in
+     * (and re-pushes that context around the invocation of the callback).
+     *
+     * Calling this function takes a reference to `simple` for as long as
+     * is needed to complete the call.
+     */
     completeInIdle() {
         call("libgio-2.0.so.0", "g_simple_async_result_complete_in_idle", [
             {
@@ -93,6 +303,9 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the operation result boolean from within the asynchronous result.
+     */
     getOpResGboolean() {
         return call("libgio-2.0.so.0", "g_simple_async_result_get_op_res_gboolean", [
             {
@@ -101,6 +314,9 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets a gssize from the asynchronous result.
+     */
     getOpResGssize() {
         return call("libgio-2.0.so.0", "g_simple_async_result_get_op_res_gssize", [
             {
@@ -109,6 +325,14 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "int", size: 64, unsigned: false });
     }
+    /**
+     * Propagates an error from within the simple asynchronous result to
+     * a given destination.
+     *
+     * If the #GCancellable given to a prior call to
+     * g_simple_async_result_set_check_cancellable() is cancelled then this
+     * function will return %TRUE with `dest` set appropriately.
+     */
     propagateError() {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_simple_async_result_propagate_error", [
@@ -133,6 +357,24 @@ export class SimpleAsyncResult extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Sets a #GCancellable to check before dispatching results.
+     *
+     * This function has one very specific purpose: the provided cancellable
+     * is checked at the time of g_simple_async_result_propagate_error() If
+     * it is cancelled, these functions will return an "Operation was
+     * cancelled" error (%G_IO_ERROR_CANCELLED).
+     *
+     * Implementors of cancellable asynchronous functions should use this in
+     * order to provide a guarantee to their callers that cancelling an
+     * async operation will reliably result in an error being returned for
+     * that operation (even if a positive result for the operation has
+     * already been sent as an idle to the main context to be dispatched).
+     *
+     * The checking described above is done regardless of any call to the
+     * unrelated g_simple_async_result_set_handle_cancellation() function.
+     * @param checkCancellable - a #GCancellable to check, or %NULL to unset
+     */
     setCheckCancellable(checkCancellable) {
         call("libgio-2.0.so.0", "g_simple_async_result_set_check_cancellable", [
             {
@@ -146,6 +388,10 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the result from a #GError.
+     * @param error - #GError.
+     */
     setFromError(error) {
         call("libgio-2.0.so.0", "g_simple_async_result_set_from_error", [
             {
@@ -163,6 +409,14 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to handle cancellation within the asynchronous operation.
+     *
+     * This function has nothing to do with
+     * g_simple_async_result_set_check_cancellable().  It only refers to the
+     * #GCancellable passed to g_simple_async_result_run_in_thread().
+     * @param handleCancellation - a #gboolean.
+     */
     setHandleCancellation(handleCancellation) {
         call("libgio-2.0.so.0", "g_simple_async_result_set_handle_cancellation", [
             {
@@ -175,6 +429,10 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the operation result to a boolean within the asynchronous result.
+     * @param opRes - a #gboolean.
+     */
     setOpResGboolean(opRes) {
         call("libgio-2.0.so.0", "g_simple_async_result_set_op_res_gboolean", [
             {
@@ -187,6 +445,11 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the operation result within the asynchronous result to
+     * the given @op_res.
+     * @param opRes - a #gssize.
+     */
     setOpResGssize(opRes) {
         call("libgio-2.0.so.0", "g_simple_async_result_set_op_res_gssize", [
             {
@@ -199,6 +462,9 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the source object from a [iface@Gio.AsyncResult].
+     */
     getSourceObject() {
         const ptr = call("libgio-2.0.so.0", "g_async_result_get_source_object", [
             {
@@ -210,6 +476,9 @@ export class SimpleAsyncResult extends GObject.GObject {
             return null;
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Gets the user data from a [iface@Gio.AsyncResult].
+     */
     getUserData() {
         return call("libgio-2.0.so.0", "g_async_result_get_user_data", [
             {
@@ -218,6 +487,11 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Checks if `res` has the given `source_tag` (generally a function
+     * pointer indicating the function `res` was created by).
+     * @param sourceTag - an application-defined tag
+     */
     isTagged(sourceTag) {
         return call("libgio-2.0.so.0", "g_async_result_is_tagged", [
             {
@@ -231,6 +505,18 @@ export class SimpleAsyncResult extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * If `res` is a [class@Gio.SimpleAsyncResult], this is equivalent to
+     * [method@Gio.SimpleAsyncResult.propagate_error]. Otherwise it returns
+     * `FALSE`.
+     *
+     * This can be used for legacy error handling in async `*_finish()`
+     * wrapper functions that traditionally handled [class@Gio.SimpleAsyncResult]
+     * error returns themselves rather than calling into the virtual method.
+     * This should not be used in new code; [iface@Gio.AsyncResult] errors that are
+     * set by virtual methods should also be extracted by virtual methods,
+     * to enable subclasses to chain up correctly.
+     */
     legacyPropagateError() {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_async_result_legacy_propagate_error", [

package/dist/generated/gio/simple-iostream.d.ts

@@ -1,7 +1,25 @@
 import { InputStream } from "./input-stream.js";
 import { OutputStream } from "./output-stream.js";
 import { IOStream } from "./iostream.js";
+/**
+ * `GSimpleIOStream` creates a [class@Gio.IOStream] from an arbitrary
+ * [class@Gio.InputStream] and [class@Gio.OutputStream]. This allows any pair of
+ * input and output streams to be used with [class@Gio.IOStream] methods.
+ *
+ * This is useful when you obtained a [class@Gio.InputStream] and a
+ * [class@Gio.OutputStream] by other means, for instance creating them with
+ * platform specific methods as
+ * `g_unix_input_stream_new()`
+ * (from `gio-unix-2.0.pc` / `GioUnix-2.0`), and you want to
+ * take advantage of the methods provided by [class@Gio.IOStream].
+ */
 export declare class SimpleIOStream extends IOStream {
+    /**
+     * Creates a new #GSimpleIOStream wrapping `input_stream` and @output_stream.
+     * See also #GIOStream.
+     * @param inputStream - a #GInputStream.
+     * @param outputStream - a #GOutputStream.
+     */
     constructor(inputStream: InputStream, outputStream: OutputStream);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gio/simple-iostream.js

@@ -1,5 +1,17 @@
 import { call } from "@gtkx/native";
 import { IOStream } from "./iostream.js";
+/**
+ * `GSimpleIOStream` creates a [class@Gio.IOStream] from an arbitrary
+ * [class@Gio.InputStream] and [class@Gio.OutputStream]. This allows any pair of
+ * input and output streams to be used with [class@Gio.IOStream] methods.
+ *
+ * This is useful when you obtained a [class@Gio.InputStream] and a
+ * [class@Gio.OutputStream] by other means, for instance creating them with
+ * platform specific methods as
+ * `g_unix_input_stream_new()`
+ * (from `gio-unix-2.0.pc` / `GioUnix-2.0`), and you want to
+ * take advantage of the methods provided by [class@Gio.IOStream].
+ */
 export class SimpleIOStream extends IOStream {
     constructor(...args) {
         super(...args);

package/dist/generated/gio/simple-permission.d.ts

@@ -1,5 +1,18 @@
 import { Permission } from "./permission.js";
+/**
+ * `GSimplePermission` is a trivial implementation of [class@Gio.Permission]
+ * that represents a permission that is either always or never allowed.  The
+ * value is given at construction and doesn’t change.
+ *
+ * Calling [method@Gio.Permission.acquire] or [method@Gio.Permission.release]
+ * on a `GSimplePermission` will result in errors.
+ */
 export declare class SimplePermission extends Permission {
+    /**
+     * Creates a new #GPermission instance that represents an action that is
+     * either always or never allowed.
+     * @param allowed - %TRUE if the action is allowed
+     */
     constructor(allowed: boolean);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gio/simple-permission.js

@@ -1,5 +1,13 @@
 import { call } from "@gtkx/native";
 import { Permission } from "./permission.js";
+/**
+ * `GSimplePermission` is a trivial implementation of [class@Gio.Permission]
+ * that represents a permission that is either always or never allowed.  The
+ * value is given at construction and doesn’t change.
+ *
+ * Calling [method@Gio.Permission.acquire] or [method@Gio.Permission.release]
+ * on a `GSimplePermission` will result in errors.
+ */
 export class SimplePermission extends Permission {
     constructor(...args) {
         super(...args);

package/dist/generated/gio/simple-proxy-resolver.d.ts

@@ -2,16 +2,101 @@ import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { ProxyResolver } from "./proxy-resolver.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GSimpleProxyResolver` is a simple [iface@Gio.ProxyResolver] implementation
+ * that handles a single default proxy, multiple URI-scheme-specific
+ * proxies, and a list of hosts that proxies should not be used for.
+ *
+ * `GSimpleProxyResolver` is never the default proxy resolver, but it
+ * can be used as the base class for another proxy resolver
+ * implementation, or it can be created and used manually, such as
+ * with [method@Gio.SocketClient.set_proxy_resolver].
+ */
 export declare class SimpleProxyResolver extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Creates a new #GSimpleProxyResolver. See
+     * #GSimpleProxyResolver:default-proxy and
+     * #GSimpleProxyResolver:ignore-hosts for more details on how the
+     * arguments are interpreted.
+     * @param defaultProxy - the default proxy to use, eg
+     * @param ignoreHosts - an optional list of hosts/IP addresses
+     */
     static _new(defaultProxy?: string | null, ignoreHosts?: string[] | null): ProxyResolver;
+    /**
+     * Sets the default proxy on @resolver, to be used for any URIs that
+     * don't match #GSimpleProxyResolver:ignore-hosts or a proxy set
+     * via g_simple_proxy_resolver_set_uri_proxy().
+     *
+     * If `default_proxy` starts with "socks://",
+     * #GSimpleProxyResolver will treat it as referring to all three of
+     * the socks5, socks4a, and socks4 proxy types.
+     * @param defaultProxy - the default proxy to use
+     */
     setDefaultProxy(defaultProxy?: string | null): void;
+    /**
+     * Sets the list of ignored hosts.
+     *
+     * See #GSimpleProxyResolver:ignore-hosts for more details on how the
+     * `ignore_hosts` argument is interpreted.
+     * @param ignoreHosts - %NULL-terminated list of hosts/IP addresses
+     */
     setIgnoreHosts(ignoreHosts: string[]): void;
+    /**
+     * Adds a URI-scheme-specific proxy to @resolver; URIs whose scheme
+     * matches `uri_scheme` (and which don't match
+     * #GSimpleProxyResolver:ignore-hosts) will be proxied via @proxy.
+     *
+     * As with #GSimpleProxyResolver:default-proxy, if `proxy` starts with
+     * "socks://", #GSimpleProxyResolver will treat it
+     * as referring to all three of the socks5, socks4a, and socks4 proxy
+     * types.
+     * @param uriScheme - the URI scheme to add a proxy for
+     * @param proxy - the proxy to use for @uri_scheme
+     */
     setUriProxy(uriScheme: string, proxy: string): void;
+    /**
+     * Checks if `resolver` can be used on this system. (This is used
+     * internally; g_proxy_resolver_get_default() will only return a proxy
+     * resolver that returns %TRUE for this method.)
+     */
     isSupported(): boolean;
+    /**
+     * Looks into the system proxy configuration to determine what proxy,
+     * if any, to use to connect to @uri. The returned proxy URIs are of
+     * the form `<protocol>://[user[:password]@]host[:port]` or
+     * `direct://`, where `<protocol>` could be http, rtsp, socks
+     * or other proxying protocol.
+     *
+     * If you don't know what network protocol is being used on the
+     * socket, you should use `none` as the URI protocol.
+     * In this case, the resolver might still return a generic proxy type
+     * (such as SOCKS), but would not return protocol-specific proxy types
+     * (such as http).
+     *
+     * `direct://` is used when no proxy is needed.
+     * Direct connection should not be attempted unless it is part of the
+     * returned array of proxies.
+     * @param uri - a URI representing the destination to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookup(uri: string, cancellable?: Cancellable | null): string[];
+    /**
+     * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+     * details.
+     * @param uri - a URI representing the destination to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupAsync(uri: string, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Call this function to obtain the array of proxy URIs when
+     * g_proxy_resolver_lookup_async() is complete. See
+     * g_proxy_resolver_lookup() for more details.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupFinish(result: AsyncResult): string[];
     connect(signal: "notify", handler: (self: SimpleProxyResolver, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;