@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -8,24 +8,238 @@ import * as GObject from "../gobject/index.js";
 export declare class Resolver extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the default #GResolver. You should unref it when you are done
+     * with it. #GResolver may use its reference count as a hint about how
+     * many threads it should allocate for concurrent DNS resolutions.
+     */
     static getDefault(): Resolver;
+    /**
+     * Get the timeout applied to all resolver lookups. See #GResolver:timeout.
+     */
     getTimeout(): number;
+    /**
+     * Synchronously reverse-resolves `address` to determine its
+     * associated hostname.
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     * @param address - the address to reverse-resolve
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupByAddress(address: InetAddress, cancellable?: Cancellable | null): string;
+    /**
+     * Begins asynchronously reverse-resolving `address` to determine its
+     * associated hostname, and eventually calls @callback, which must
+     * call g_resolver_lookup_by_address_finish() to get the final result.
+     * @param address - the address to reverse-resolve
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupByAddressAsync(address: InetAddress, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Retrieves the result of a previous call to
+     * g_resolver_lookup_by_address_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupByAddressFinish(result: AsyncResult): string;
+    /**
+     * Synchronously resolves `hostname` to determine its associated IP
+     * address(es). `hostname` may be an ASCII-only or UTF-8 hostname, or
+     * the textual form of an IP address (in which case this just becomes
+     * a wrapper around g_inet_address_new_from_string()).
+     *
+     * On success, g_resolver_lookup_by_name() will return a non-empty #GList of
+     * #GInetAddress, sorted in order of preference and guaranteed to not
+     * contain duplicates. That is, if using the result to connect to
+     * @hostname, you should attempt to connect to the first address
+     * first, then the second if the first fails, etc. If you are using
+     * the result to listen on a socket, it is appropriate to add each
+     * result using e.g. g_socket_listener_add_address().
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to a
+     * value from #GResolverError and %NULL will be returned.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     *
+     * If you are planning to connect to a socket on the resolved IP
+     * address, it may be easier to create a #GNetworkAddress and use its
+     * #GSocketConnectable interface.
+     * @param hostname - the hostname to look up
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupByName(hostname: string, cancellable?: Cancellable | null): InetAddress[];
+    /**
+     * Begins asynchronously resolving `hostname` to determine its
+     * associated IP address(es), and eventually calls @callback, which
+     * must call g_resolver_lookup_by_name_finish() to get the result.
+     * See g_resolver_lookup_by_name() for more details.
+     * @param hostname - the hostname to look up the address of
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupByNameAsync(hostname: string, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Retrieves the result of a call to
+     * g_resolver_lookup_by_name_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupByNameFinish(result: AsyncResult): InetAddress[];
+    /**
+     * This differs from g_resolver_lookup_by_name() in that you can modify
+     * the lookup behavior with @flags. For example this can be used to limit
+     * results with %G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY.
+     * @param hostname - the hostname to look up
+     * @param flags - extra #GResolverNameLookupFlags for the lookup
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupByNameWithFlags(hostname: string, flags: ResolverNameLookupFlags, cancellable?: Cancellable | null): InetAddress[];
+    /**
+     * Begins asynchronously resolving `hostname` to determine its
+     * associated IP address(es), and eventually calls @callback, which
+     * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
+     * See g_resolver_lookup_by_name() for more details.
+     * @param hostname - the hostname to look up the address of
+     * @param flags - extra #GResolverNameLookupFlags for the lookup
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupByNameWithFlagsAsync(hostname: string, flags: ResolverNameLookupFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Retrieves the result of a call to
+     * g_resolver_lookup_by_name_with_flags_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupByNameWithFlagsFinish(result: AsyncResult): InetAddress[];
+    /**
+     * Synchronously performs a DNS record lookup for the given `rrname` and returns
+     * a list of records as #GVariant tuples. See #GResolverRecordType for
+     * information on what the records contain for each @record_type.
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError and %NULL will be returned.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     * @param rrname - the DNS name to look up the record for
+     * @param recordType - the type of DNS record to look up
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupRecords(rrname: string, recordType: ResolverRecordType, cancellable?: Cancellable | null): GLib.Variant[];
+    /**
+     * Begins asynchronously performing a DNS lookup for the given
+     * @rrname, and eventually calls @callback, which must call
+     * g_resolver_lookup_records_finish() to get the final result. See
+     * g_resolver_lookup_records() for more details.
+     * @param rrname - the DNS name to look up the record for
+     * @param recordType - the type of DNS record to look up
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupRecordsAsync(rrname: string, recordType: ResolverRecordType, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Retrieves the result of a previous call to
+     * g_resolver_lookup_records_async(). Returns a non-empty list of records as
+     * #GVariant tuples. See #GResolverRecordType for information on what the
+     * records contain.
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupRecordsFinish(result: AsyncResult): GLib.Variant[];
+    /**
+     * Synchronously performs a DNS SRV lookup for the given `service` and
+     * `protocol` in the given `domain` and returns an array of #GSrvTarget.
+     * `domain` may be an ASCII-only or UTF-8 hostname. Note also that the
+     * `service` and `protocol` arguments do not include the leading underscore
+     * that appears in the actual DNS entry.
+     *
+     * On success, g_resolver_lookup_service() will return a non-empty #GList of
+     * #GSrvTarget, sorted in order of preference. (That is, you should
+     * attempt to connect to the first target first, then the second if
+     * the first fails, etc.)
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError and %NULL will be returned.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     *
+     * If you are planning to connect to the service, it is usually easier
+     * to create a #GNetworkService and use its #GSocketConnectable
+     * interface.
+     * @param service - the service type to look up (eg, "ldap")
+     * @param protocol - the networking protocol to use for `service` (eg, "tcp")
+     * @param domain - the DNS domain to look up the service in
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupService(service: string, protocol: string, domain: string, cancellable?: Cancellable | null): SrvTarget[];
+    /**
+     * Begins asynchronously performing a DNS SRV lookup for the given
+     * `service` and `protocol` in the given @domain, and eventually calls
+     * @callback, which must call g_resolver_lookup_service_finish() to
+     * get the final result. See g_resolver_lookup_service() for more
+     * details.
+     * @param service - the service type to look up (eg, "ldap")
+     * @param protocol - the networking protocol to use for `service` (eg, "tcp")
+     * @param domain - the DNS domain to look up the service in
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupServiceAsync(service: string, protocol: string, domain: string, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Retrieves the result of a previous call to
+     * g_resolver_lookup_service_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupServiceFinish(result: AsyncResult): SrvTarget[];
+    /**
+     * Sets `resolver` to be the application's default resolver (reffing
+     * @resolver, and unreffing the previous default resolver, if any).
+     * Future calls to g_resolver_get_default() will return this resolver.
+     *
+     * This can be used if an application wants to perform any sort of DNS
+     * caching or "pinning"; it can implement its own #GResolver that
+     * calls the original default resolver for DNS operations, and
+     * implements its own cache policies on top of that, and then set
+     * itself as the default resolver for all later code to use.
+     */
     setDefault(): void;
+    /**
+     * Set the timeout applied to all resolver lookups. See #GResolver:timeout.
+     * @param timeoutMs - timeout in milliseconds, or `0` for no timeouts
+     */
     setTimeout(timeoutMs: number): void;
     connect(signal: "reload", handler: (self: Resolver) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Resolver, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gio/resolver.js

@@ -2,6 +2,27 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { InetAddress } from "./inet-address.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * The object that handles DNS resolution. Use [func@Gio.Resolver.get_default]
+ * to get the default resolver.
+ *
+ * `GResolver` provides cancellable synchronous and asynchronous DNS
+ * resolution, for hostnames ([method@Gio.Resolver.lookup_by_address],
+ * [method@Gio.Resolver.lookup_by_name] and their async variants) and SRV
+ * (service) records ([method@Gio.Resolver.lookup_service]).
+ *
+ * [class@Gio.NetworkAddress] and [class@Gio.NetworkService] provide wrappers
+ * around `GResolver` functionality that also implement
+ * [iface@Gio.SocketConnectable], making it easy to connect to a remote
+ * host/service.
+ *
+ * The default resolver (see [func@Gio.Resolver.get_default]) has a timeout of
+ * 30s set on it since GLib 2.78. Earlier versions of GLib did not support
+ * resolver timeouts.
+ *
+ * This is an abstract type; subclasses of it implement different resolvers for
+ * different platforms and situations.
+ */
 const SIGNAL_META = {
     reload: { params: [], returnType: { type: "undefined" } },
 };
@@ -20,6 +41,11 @@ export class Resolver extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the default #GResolver. You should unref it when you are done
+     * with it. #GResolver may use its reference count as a hint about how
+     * many threads it should allocate for concurrent DNS resolutions.
+     */
     static getDefault() {
         const ptr = call("libgio-2.0.so.0", "g_resolver_get_default", [], {
             type: "gobject",
@@ -27,6 +53,9 @@ export class Resolver extends GObject.GObject {
         });
         return getObject(ptr, Resolver);
     }
+    /**
+     * Get the timeout applied to all resolver lookups. See #GResolver:timeout.
+     */
     getTimeout() {
         return call("libgio-2.0.so.0", "g_resolver_get_timeout", [
             {
@@ -35,6 +64,19 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Synchronously reverse-resolves `address` to determine its
+     * associated hostname.
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     * @param address - the address to reverse-resolve
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupByAddress(address, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_resolver_lookup_by_address", [
@@ -68,6 +110,15 @@ export class Resolver extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Begins asynchronously reverse-resolving `address` to determine its
+     * associated hostname, and eventually calls @callback, which must
+     * call g_resolver_lookup_by_address_finish() to get the final result.
+     * @param address - the address to reverse-resolve
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupByAddressAsync(address, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_resolver_lookup_by_address_async", [
             {
@@ -95,6 +146,15 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the result of a previous call to
+     * g_resolver_lookup_by_address_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupByAddressFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_resolver_lookup_by_address_finish", [
@@ -123,6 +183,33 @@ export class Resolver extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Synchronously resolves `hostname` to determine its associated IP
+     * address(es). `hostname` may be an ASCII-only or UTF-8 hostname, or
+     * the textual form of an IP address (in which case this just becomes
+     * a wrapper around g_inet_address_new_from_string()).
+     *
+     * On success, g_resolver_lookup_by_name() will return a non-empty #GList of
+     * #GInetAddress, sorted in order of preference and guaranteed to not
+     * contain duplicates. That is, if using the result to connect to
+     * @hostname, you should attempt to connect to the first address
+     * first, then the second if the first fails, etc. If you are using
+     * the result to listen on a socket, it is appropriate to add each
+     * result using e.g. g_socket_listener_add_address().
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to a
+     * value from #GResolverError and %NULL will be returned.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     *
+     * If you are planning to connect to a socket on the resolved IP
+     * address, it may be easier to create a #GNetworkAddress and use its
+     * #GSocketConnectable interface.
+     * @param hostname - the hostname to look up
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupByName(hostname, cancellable) {
         const error = { value: null };
         const ptrs = call("libgio-2.0.so.0", "g_resolver_lookup_by_name", [
@@ -161,6 +248,16 @@ export class Resolver extends GObject.GObject {
         }
         return ptrs.map((ptr) => getObject(ptr, InetAddress));
     }
+    /**
+     * Begins asynchronously resolving `hostname` to determine its
+     * associated IP address(es), and eventually calls @callback, which
+     * must call g_resolver_lookup_by_name_finish() to get the result.
+     * See g_resolver_lookup_by_name() for more details.
+     * @param hostname - the hostname to look up the address of
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupByNameAsync(hostname, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_resolver_lookup_by_name_async", [
             {
@@ -188,6 +285,15 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the result of a call to
+     * g_resolver_lookup_by_name_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupByNameFinish(result) {
         const error = { value: null };
         const ptrs = call("libgio-2.0.so.0", "g_resolver_lookup_by_name_finish", [
@@ -221,6 +327,14 @@ export class Resolver extends GObject.GObject {
         }
         return ptrs.map((ptr) => getObject(ptr, InetAddress));
     }
+    /**
+     * This differs from g_resolver_lookup_by_name() in that you can modify
+     * the lookup behavior with @flags. For example this can be used to limit
+     * results with %G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY.
+     * @param hostname - the hostname to look up
+     * @param flags - extra #GResolverNameLookupFlags for the lookup
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupByNameWithFlags(hostname, flags, cancellable) {
         const error = { value: null };
         const ptrs = call("libgio-2.0.so.0", "g_resolver_lookup_by_name_with_flags", [
@@ -263,6 +377,17 @@ export class Resolver extends GObject.GObject {
         }
         return ptrs.map((ptr) => getObject(ptr, InetAddress));
     }
+    /**
+     * Begins asynchronously resolving `hostname` to determine its
+     * associated IP address(es), and eventually calls @callback, which
+     * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
+     * See g_resolver_lookup_by_name() for more details.
+     * @param hostname - the hostname to look up the address of
+     * @param flags - extra #GResolverNameLookupFlags for the lookup
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupByNameWithFlagsAsync(hostname, flags, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_resolver_lookup_by_name_with_flags_async", [
             {
@@ -294,6 +419,15 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the result of a call to
+     * g_resolver_lookup_by_name_with_flags_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupByNameWithFlagsFinish(result) {
         const error = { value: null };
         const ptrs = call("libgio-2.0.so.0", "g_resolver_lookup_by_name_with_flags_finish", [
@@ -327,6 +461,21 @@ export class Resolver extends GObject.GObject {
         }
         return ptrs.map((ptr) => getObject(ptr, InetAddress));
     }
+    /**
+     * Synchronously performs a DNS record lookup for the given `rrname` and returns
+     * a list of records as #GVariant tuples. See #GResolverRecordType for
+     * information on what the records contain for each @record_type.
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError and %NULL will be returned.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     * @param rrname - the DNS name to look up the record for
+     * @param recordType - the type of DNS record to look up
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupRecords(rrname, recordType, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_resolver_lookup_records", [
@@ -373,6 +522,17 @@ export class Resolver extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Begins asynchronously performing a DNS lookup for the given
+     * @rrname, and eventually calls @callback, which must call
+     * g_resolver_lookup_records_finish() to get the final result. See
+     * g_resolver_lookup_records() for more details.
+     * @param rrname - the DNS name to look up the record for
+     * @param recordType - the type of DNS record to look up
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupRecordsAsync(rrname, recordType, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_resolver_lookup_records_async", [
             {
@@ -404,6 +564,17 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the result of a previous call to
+     * g_resolver_lookup_records_async(). Returns a non-empty list of records as
+     * #GVariant tuples. See #GResolverRecordType for information on what the
+     * records contain.
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupRecordsFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_resolver_lookup_records_finish", [
@@ -441,6 +612,33 @@ export class Resolver extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Synchronously performs a DNS SRV lookup for the given `service` and
+     * `protocol` in the given `domain` and returns an array of #GSrvTarget.
+     * `domain` may be an ASCII-only or UTF-8 hostname. Note also that the
+     * `service` and `protocol` arguments do not include the leading underscore
+     * that appears in the actual DNS entry.
+     *
+     * On success, g_resolver_lookup_service() will return a non-empty #GList of
+     * #GSrvTarget, sorted in order of preference. (That is, you should
+     * attempt to connect to the first target first, then the second if
+     * the first fails, etc.)
+     *
+     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError and %NULL will be returned.
+     *
+     * If `cancellable` is non-%NULL, it can be used to cancel the
+     * operation, in which case `error` (if non-%NULL) will be set to
+     * %G_IO_ERROR_CANCELLED.
+     *
+     * If you are planning to connect to the service, it is usually easier
+     * to create a #GNetworkService and use its #GSocketConnectable
+     * interface.
+     * @param service - the service type to look up (eg, "ldap")
+     * @param protocol - the networking protocol to use for `service` (eg, "tcp")
+     * @param domain - the DNS domain to look up the service in
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     lookupService(service, protocol, domain, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_resolver_lookup_service", [
@@ -491,6 +689,19 @@ export class Resolver extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Begins asynchronously performing a DNS SRV lookup for the given
+     * `service` and `protocol` in the given @domain, and eventually calls
+     * @callback, which must call g_resolver_lookup_service_finish() to
+     * get the final result. See g_resolver_lookup_service() for more
+     * details.
+     * @param service - the service type to look up (eg, "ldap")
+     * @param protocol - the networking protocol to use for `service` (eg, "tcp")
+     * @param domain - the DNS domain to look up the service in
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - callback to call after resolution completes
+     * @param userData - data for @callback
+     */
     lookupServiceAsync(service, protocol, domain, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_resolver_lookup_service_async", [
             {
@@ -526,6 +737,15 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the result of a previous call to
+     * g_resolver_lookup_service_async().
+     *
+     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+     * a value from #GResolverError. If the operation was cancelled,
+     * `error` will be set to %G_IO_ERROR_CANCELLED.
+     * @param result - the result passed to your #GAsyncReadyCallback
+     */
     lookupServiceFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_resolver_lookup_service_finish", [
@@ -563,6 +783,17 @@ export class Resolver extends GObject.GObject {
         }
         return _result;
     }
+    /**
+     * Sets `resolver` to be the application's default resolver (reffing
+     * @resolver, and unreffing the previous default resolver, if any).
+     * Future calls to g_resolver_get_default() will return this resolver.
+     *
+     * This can be used if an application wants to perform any sort of DNS
+     * caching or "pinning"; it can implement its own #GResolver that
+     * calls the original default resolver for DNS operations, and
+     * implements its own cache policies on top of that, and then set
+     * itself as the default resolver for all later code to use.
+     */
     setDefault() {
         call("libgio-2.0.so.0", "g_resolver_set_default", [
             {
@@ -571,6 +802,10 @@ export class Resolver extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the timeout applied to all resolver lookups. See #GResolver:timeout.
+     * @param timeoutMs - timeout in milliseconds, or `0` for no timeouts
+     */
     setTimeout(timeoutMs) {
         call("libgio-2.0.so.0", "g_resolver_set_timeout", [
             {