@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/socket-client.js

@@ -5,6 +5,21 @@ import { SocketAddress } from "./socket-address.js";
 import { SocketConnection } from "./socket-connection.js";
 import { IOStream } from "./iostream.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GSocketClient` is a lightweight high-level utility class for connecting to
+ * a network host using a connection oriented socket type.
+ *
+ * You create a `GSocketClient` object, set any options you want, and then
+ * call a sync or async connect operation, which returns a
+ * [class@Gio.SocketConnection] subclass on success.
+ *
+ * The type of the [class@Gio.SocketConnection] object returned depends on the
+ * type of the underlying socket that is in use. For instance, for a TCP/IP
+ * connection it will be a [class@Gio.TcpConnection].
+ *
+ * As `GSocketClient` is a lightweight object, you don't need to cache it. You
+ * can just create a new one any time you need one.
+ */
 const SIGNAL_META = {
     event: {
         params: [
@@ -16,6 +31,9 @@ const SIGNAL_META = {
     },
 };
 export class SocketClient extends GObject.GObject {
+    /**
+     * Creates a new #GSocketClient with the default options.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -25,6 +43,28 @@ export class SocketClient extends GObject.GObject {
             borrowed: false,
         });
     }
+    /**
+     * Enable proxy protocols to be handled by the application. When the
+     * indicated proxy protocol is returned by the #GProxyResolver,
+     * #GSocketClient will consider this protocol as supported but will
+     * not try to find a #GProxy instance to handle handshaking. The
+     * application must check for this case by calling
+     * g_socket_connection_get_remote_address() on the returned
+     * #GSocketConnection, and seeing if it's a #GProxyAddress of the
+     * appropriate type, to determine whether or not it needs to handle
+     * the proxy handshaking itself.
+     *
+     * This should be used for proxy protocols that are dialects of
+     * another protocol such as HTTP proxy. It also allows cohabitation of
+     * proxy protocols that are reused between protocols. A good example
+     * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
+     * be use as generic socket proxy through the HTTP CONNECT method.
+     *
+     * When the proxy is detected as being an application proxy, TLS handshake
+     * will be skipped. This is required to let the application do the proxy
+     * specific handshake.
+     * @param protocol - The proxy protocol
+     */
     addApplicationProxy(protocol) {
         call("libgio-2.0.so.0", "g_socket_client_add_application_proxy", [
             {
@@ -37,6 +77,28 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Tries to resolve the `connectable` and make a network connection to it.
+     *
+     * Upon a successful connection, a new #GSocketConnection is constructed
+     * and returned.  The caller owns this new object and must drop their
+     * reference to it when finished with it.
+     *
+     * The type of the #GSocketConnection object returned depends on the type of
+     * the underlying socket that is used. For instance, for a TCP/IP connection
+     * it will be a #GTcpConnection.
+     *
+     * The socket created will be the same family as the address that the
+     * `connectable` resolves to, unless family is set with g_socket_client_set_family()
+     * or indirectly via g_socket_client_set_local_address(). The socket type
+     * defaults to %G_SOCKET_TYPE_STREAM but can be set with
+     * g_socket_client_set_socket_type().
+     *
+     * If a local address is specified with g_socket_client_set_local_address() the
+     * socket will be bound to this address before connecting.
+     * @param connectable - a #GSocketConnectable specifying the remote address.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     connectTo(connectable, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect", [
@@ -70,6 +132,26 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * This is the asynchronous version of g_socket_client_connect().
+     *
+     * You may wish to prefer the asynchronous version even in synchronous
+     * command line programs because, since 2.60, it implements
+     * [RFC 8305](https://tools.ietf.org/html/rfc8305) "Happy Eyeballs"
+     * recommendations to work around long connection timeouts in networks
+     * where IPv6 is broken by performing an IPv4 connection simultaneously
+     * without waiting for IPv6 to time out, which is not supported by the
+     * synchronous call. (This is not an API guarantee, and may change in
+     * the future.)
+     *
+     * When the operation is finished `callback` will be
+     * called. You can then call g_socket_client_connect_finish() to get
+     * the result of the operation.
+     * @param connectable - a #GSocketConnectable specifying the remote address.
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - user data for the callback
+     */
     connectAsync(connectable, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_socket_client_connect_async", [
             {
@@ -97,6 +179,10 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an async connect operation. See g_socket_client_connect_async()
+     * @param result - a #GAsyncResult.
+     */
     connectFinish(result) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_finish", [
@@ -125,6 +211,41 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * This is a helper function for g_socket_client_connect().
+     *
+     * Attempts to create a TCP connection to the named host.
+     *
+     * `host_and_port` may be in any of a number of recognized formats; an IPv6
+     * address, an IPv4 address, or a domain name (in which case a DNS
+     * lookup is performed).  Quoting with [] is supported for all address
+     * types.  A port override may be specified in the usual way with a
+     * colon.  Ports may be given as decimal numbers or symbolic names (in
+     * which case an /etc/services lookup is performed).
+     *
+     * If no port override is given in `host_and_port` then `default_port` will be
+     * used as the port number to connect to.
+     *
+     * In general, `host_and_port` is expected to be provided by the user (allowing
+     * them to give the hostname, and a port override if necessary) and
+     * `default_port` is expected to be provided by the application.
+     *
+     * In the case that an IP address is given, a single connection
+     * attempt is made.  In the case that a name is given, multiple
+     * connection attempts may be made, in turn and according to the
+     * number of address records in DNS, until a connection succeeds.
+     *
+     * Upon a successful connection, a new #GSocketConnection is constructed
+     * and returned.  The caller owns this new object and must drop their
+     * reference to it when finished with it.
+     *
+     * In the event of any failure (DNS error, service not found, no hosts
+     * connectable) %NULL is returned and `error` (if non-%NULL) is set
+     * accordingly.
+     * @param hostAndPort - the name and optionally port of the host to connect to
+     * @param defaultPort - the default port to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     connectToHost(hostAndPort, defaultPort, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_to_host", [
@@ -162,6 +283,18 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * This is the asynchronous version of g_socket_client_connect_to_host().
+     *
+     * When the operation is finished `callback` will be
+     * called. You can then call g_socket_client_connect_to_host_finish() to get
+     * the result of the operation.
+     * @param hostAndPort - the name and optionally the port of the host to connect to
+     * @param defaultPort - the default port to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - user data for the callback
+     */
     connectToHostAsync(hostAndPort, defaultPort, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_socket_client_connect_to_host_async", [
             {
@@ -193,6 +326,10 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
+     * @param result - a #GAsyncResult.
+     */
     connectToHostFinish(result) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_to_host_finish", [
@@ -221,6 +358,25 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * Attempts to create a TCP connection to a service.
+     *
+     * This call looks up the SRV record for `service` at `domain` for the
+     * "tcp" protocol.  It then attempts to connect, in turn, to each of
+     * the hosts providing the service until either a connection succeeds
+     * or there are no hosts remaining.
+     *
+     * Upon a successful connection, a new #GSocketConnection is constructed
+     * and returned.  The caller owns this new object and must drop their
+     * reference to it when finished with it.
+     *
+     * In the event of any failure (DNS error, service not found, no hosts
+     * connectable) %NULL is returned and `error` (if non-%NULL) is set
+     * accordingly.
+     * @param domain - a domain name
+     * @param service - the name of the service to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     connectToService(domain, service, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_to_service", [
@@ -258,6 +414,15 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * This is the asynchronous version of
+     * g_socket_client_connect_to_service().
+     * @param domain - a domain name
+     * @param service - the name of the service to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - user data for the callback
+     */
     connectToServiceAsync(domain, service, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_socket_client_connect_to_service_async", [
             {
@@ -289,6 +454,10 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
+     * @param result - a #GAsyncResult.
+     */
     connectToServiceFinish(result) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_to_service_finish", [
@@ -317,6 +486,31 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * This is a helper function for g_socket_client_connect().
+     *
+     * Attempts to create a TCP connection with a network URI.
+     *
+     * `uri` may be any valid URI containing an "authority" (hostname/port)
+     * component. If a port is not specified in the URI, `default_port` will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
+     * (#GSocketClient does not know to automatically assume TLS for
+     * certain URI schemes.)
+     *
+     * Using this rather than g_socket_client_connect() or
+     * g_socket_client_connect_to_host() allows #GSocketClient to
+     * determine when to use application-specific proxy protocols.
+     *
+     * Upon a successful connection, a new #GSocketConnection is constructed
+     * and returned.  The caller owns this new object and must drop their
+     * reference to it when finished with it.
+     *
+     * In the event of any failure (DNS error, service not found, no hosts
+     * connectable) %NULL is returned and `error` (if non-%NULL) is set
+     * accordingly.
+     * @param uri - A network URI
+     * @param defaultPort - the default port to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     connectToUri(uri, defaultPort, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_to_uri", [
@@ -354,6 +548,18 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * This is the asynchronous version of g_socket_client_connect_to_uri().
+     *
+     * When the operation is finished `callback` will be
+     * called. You can then call g_socket_client_connect_to_uri_finish() to get
+     * the result of the operation.
+     * @param uri - a network uri
+     * @param defaultPort - the default port to connect to
+     * @param cancellable - a #GCancellable, or %NULL
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - user data for the callback
+     */
     connectToUriAsync(uri, defaultPort, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_socket_client_connect_to_uri_async", [
             {
@@ -385,6 +591,10 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
+     * @param result - a #GAsyncResult.
+     */
     connectToUriFinish(result) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_client_connect_to_uri_finish", [
@@ -413,6 +623,9 @@ export class SocketClient extends GObject.GObject {
         }
         return getObject(ptr, SocketConnection);
     }
+    /**
+     * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
+     */
     getEnableProxy() {
         return call("libgio-2.0.so.0", "g_socket_client_get_enable_proxy", [
             {
@@ -421,6 +634,11 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the socket family of the socket client.
+     *
+     * See g_socket_client_set_family() for details.
+     */
     getFamily() {
         return call("libgio-2.0.so.0", "g_socket_client_get_family", [
             {
@@ -429,6 +647,11 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the local address of the socket client.
+     *
+     * See g_socket_client_set_local_address() for details.
+     */
     getLocalAddress() {
         const ptr = call("libgio-2.0.so.0", "g_socket_client_get_local_address", [
             {
@@ -440,6 +663,11 @@ export class SocketClient extends GObject.GObject {
             return null;
         return getObject(ptr, SocketAddress);
     }
+    /**
+     * Gets the protocol name type of the socket client.
+     *
+     * See g_socket_client_set_protocol() for details.
+     */
     getProtocol() {
         return call("libgio-2.0.so.0", "g_socket_client_get_protocol", [
             {
@@ -448,6 +676,11 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the #GProxyResolver being used by @client. Normally, this will
+     * be the resolver returned by g_proxy_resolver_get_default(), but you
+     * can override it with g_socket_client_set_proxy_resolver().
+     */
     getProxyResolver() {
         const ptr = call("libgio-2.0.so.0", "g_socket_client_get_proxy_resolver", [
             {
@@ -457,6 +690,11 @@ export class SocketClient extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, ProxyResolver);
     }
+    /**
+     * Gets the socket type of the socket client.
+     *
+     * See g_socket_client_set_socket_type() for details.
+     */
     getSocketType() {
         return call("libgio-2.0.so.0", "g_socket_client_get_socket_type", [
             {
@@ -465,6 +703,11 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the I/O timeout time for sockets created by @client.
+     *
+     * See g_socket_client_set_timeout() for details.
+     */
     getTimeout() {
         return call("libgio-2.0.so.0", "g_socket_client_get_timeout", [
             {
@@ -473,6 +716,10 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets whether `client` creates TLS connections. See
+     * g_socket_client_set_tls() for details.
+     */
     getTls() {
         return call("libgio-2.0.so.0", "g_socket_client_get_tls", [
             {
@@ -481,6 +728,14 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the TLS validation flags used creating TLS connections via
+     * @client.
+     *
+     * This function does not work as originally designed and is impossible
+     * to use correctly. See #GSocketClient:tls-validation-flags for more
+     * information.
+     */
     getTlsValidationFlags() {
         return call("libgio-2.0.so.0", "g_socket_client_get_tls_validation_flags", [
             {
@@ -489,6 +744,15 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets whether or not `client` attempts to make connections via a
+     * proxy server. When enabled (the default), #GSocketClient will use a
+     * #GProxyResolver to determine if a proxy protocol such as SOCKS is
+     * needed, and automatically do the necessary proxy negotiation.
+     *
+     * See also g_socket_client_set_proxy_resolver().
+     * @param enable - whether to enable proxies
+     */
     setEnableProxy(enable) {
         call("libgio-2.0.so.0", "g_socket_client_set_enable_proxy", [
             {
@@ -501,6 +765,17 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the socket family of the socket client.
+     * If this is set to something other than %G_SOCKET_FAMILY_INVALID
+     * then the sockets created by this object will be of the specified
+     * family.
+     *
+     * This might be useful for instance if you want to force the local
+     * connection to be an ipv4 socket, even though the address might
+     * be an ipv6 mapped to ipv4 address.
+     * @param family - a #GSocketFamily
+     */
     setFamily(family) {
         call("libgio-2.0.so.0", "g_socket_client_set_family", [
             {
@@ -513,6 +788,16 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the local address of the socket client.
+     * The sockets created by this object will bound to the
+     * specified address (if not %NULL) before connecting.
+     *
+     * This is useful if you want to ensure that the local
+     * side of the connection is on a specific port, or on
+     * a specific interface.
+     * @param address - a #GSocketAddress, or %NULL
+     */
     setLocalAddress(address) {
         call("libgio-2.0.so.0", "g_socket_client_set_local_address", [
             {
@@ -526,6 +811,15 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the protocol of the socket client.
+     * The sockets created by this object will use of the specified
+     * protocol.
+     *
+     * If `protocol` is %G_SOCKET_PROTOCOL_DEFAULT that means to use the default
+     * protocol for the socket family and type.
+     * @param protocol - a #GSocketProtocol
+     */
     setProtocol(protocol) {
         call("libgio-2.0.so.0", "g_socket_client_set_protocol", [
             {
@@ -538,6 +832,16 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Overrides the #GProxyResolver used by @client. You can call this if
+     * you want to use specific proxies, rather than using the system
+     * default proxy settings.
+     *
+     * Note that whether or not the proxy resolver is actually used
+     * depends on the setting of #GSocketClient:enable-proxy, which is not
+     * changed by this function (but which is %TRUE by default)
+     * @param proxyResolver - a #GProxyResolver, or %NULL for the
+     */
     setProxyResolver(proxyResolver) {
         call("libgio-2.0.so.0", "g_socket_client_set_proxy_resolver", [
             {
@@ -551,6 +855,15 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the socket type of the socket client.
+     * The sockets created by this object will be of the specified
+     * type.
+     *
+     * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
+     * as GSocketClient is used for connection oriented services.
+     * @param type - a #GSocketType
+     */
     setSocketType(type) {
         call("libgio-2.0.so.0", "g_socket_client_set_socket_type", [
             {
@@ -563,6 +876,15 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the I/O timeout for sockets created by @client. `timeout` is a
+     * time in seconds, or 0 for no timeout (the default).
+     *
+     * The timeout value affects the initial connection attempt as well,
+     * so setting this may cause calls to g_socket_client_connect(), etc,
+     * to fail with %G_IO_ERROR_TIMED_OUT.
+     * @param timeout - the timeout
+     */
     setTimeout(timeout) {
         call("libgio-2.0.so.0", "g_socket_client_set_timeout", [
             {
@@ -575,6 +897,27 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether `client` creates TLS (aka SSL) connections. If `tls` is
+     * %TRUE, `client` will wrap its connections in a #GTlsClientConnection
+     * and perform a TLS handshake when connecting.
+     *
+     * Note that since #GSocketClient must return a #GSocketConnection,
+     * but #GTlsClientConnection is not a #GSocketConnection, this
+     * actually wraps the resulting #GTlsClientConnection in a
+     * #GTcpWrapperConnection when returning it. You can use
+     * g_tcp_wrapper_connection_get_base_io_stream() on the return value
+     * to extract the #GTlsClientConnection.
+     *
+     * If you need to modify the behavior of the TLS handshake (eg, by
+     * setting a client-side certificate to use, or connecting to the
+     * #GTlsConnection::accept-certificate signal), you can connect to
+     * @client's #GSocketClient::event signal and wait for it to be
+     * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you
+     * a chance to see the #GTlsClientConnection before the handshake
+     * starts.
+     * @param tls - whether to use TLS
+     */
     setTls(tls) {
         call("libgio-2.0.so.0", "g_socket_client_set_tls", [
             {
@@ -587,6 +930,15 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the TLS validation flags used when creating TLS connections
+     * via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
+     *
+     * This function does not work as originally designed and is impossible
+     * to use correctly. See #GSocketClient:tls-validation-flags for more
+     * information.
+     * @param flags - the validation flags
+     */
     setTlsValidationFlags(flags) {
         call("libgio-2.0.so.0", "g_socket_client_set_tls_validation_flags", [
             {

package/dist/generated/gio/socket-connectable.d.ts

@@ -1,9 +1,89 @@
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
+/**
+ * Objects that describe one or more potential socket endpoints
+ * implement `GSocketConnectable`. Callers can then use
+ * [method@Gio.SocketConnectable.enumerate] to get a
+ * [class@Gio.SocketAddressEnumerator] to try out each socket address in turn
+ * until one succeeds, as shown in the sample code below.
+ *
+ * ```c
+ * MyConnectionType *
+ * connect_to_host (const char    *hostname,
+ * guint16        port,
+ * GCancellable  *cancellable,
+ * GError       **error)
+ * {
+ * MyConnection *conn = NULL;
+ * GSocketConnectable *addr;
+ * GSocketAddressEnumerator *enumerator;
+ * GSocketAddress *sockaddr;
+ * GError *conn_error = NULL;
+ *
+ * addr = g_network_address_new (hostname, port);
+ * enumerator = g_socket_connectable_enumerate (addr);
+ * g_object_unref (addr);
+ *
+ * // Try each sockaddr until we succeed. Record the first connection error,
+ * // but not any further ones (since they'll probably be basically the same
+ * // as the first).
+ * while (!conn && (sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, error))
+ * {
+ * conn = connect_to_sockaddr (sockaddr, conn_error ? NULL : &conn_error);
+ * g_object_unref (sockaddr);
+ * }
+ * g_object_unref (enumerator);
+ *
+ * if (conn)
+ * {
+ * if (conn_error)
+ * {
+ * // We couldn't connect to the first address, but we succeeded
+ * // in connecting to a later address.
+ * g_error_free (conn_error);
+ * }
+ * return conn;
+ * }
+ * else if (error)
+ * {
+ * /// Either initial lookup failed, or else the caller cancelled us.
+ * if (conn_error)
+ * g_error_free (conn_error);
+ * return NULL;
+ * }
+ * else
+ * {
+ * g_error_propagate (error, conn_error);
+ * return NULL;
+ * }
+ * }
+ * ```
+ */
 export declare class SocketConnectable {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): SocketConnectable;
+    /**
+     * Creates a #GSocketAddressEnumerator for @connectable.
+     */
     enumerate(): SocketAddressEnumerator;
+    /**
+     * Creates a #GSocketAddressEnumerator for `connectable` that will
+     * return a #GProxyAddress for each of its addresses that you must connect
+     * to via a proxy.
+     *
+     * If `connectable` does not implement
+     * g_socket_connectable_proxy_enumerate(), this will fall back to
+     * calling g_socket_connectable_enumerate().
+     */
     proxyEnumerate(): SocketAddressEnumerator;
+    /**
+     * Format a #GSocketConnectable as a string. This is a human-readable format for
+     * use in debugging output, and is not a stable serialization format. It is not
+     * suitable for use in user interfaces as it exposes too much information for a
+     * user.
+     *
+     * If the #GSocketConnectable implementation does not support string formatting,
+     * the implementation’s type name will be returned as a fallback.
+     */
     toString(): string;
 }