@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/themed-icon.js

@@ -2,10 +2,26 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GThemedIcon` is an implementation of [iface@Gio.Icon] that supports icon
+ * themes.
+ *
+ * `GThemedIcon` contains a list of all of the icons present in an icon
+ * theme, so that icons can be looked up quickly. `GThemedIcon` does
+ * not provide actual pixmaps for icons, just the icon names.
+ * Ideally something like [method@Gtk.IconTheme.choose_icon] should be used to
+ * resolve the list of names so that fallback icons work nicely with
+ * themes that inherit other themes.
+ */
 export class ThemedIcon extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new themed icon for @iconnames.
+     * @param iconnames - an array of strings containing icon names.
+     * @param len - the length of the `iconnames` array, or -1 if `iconnames` is
+     */
     static iconNewFromNames(iconnames, len) {
         const ptr = call("libgio-2.0.so.0", "g_themed_icon_new_from_names", [
             {
@@ -19,6 +35,24 @@ export class ThemedIcon extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, ThemedIcon);
     }
+    /**
+     * Creates a new themed icon for @iconname, and all the names
+     * that can be created by shortening `iconname` at '-' characters.
+     *
+     * In the following example, `icon1` and `icon2` are equivalent:
+     * |[<!-- language="C" -->
+     * const char *names[] = {
+     * "gnome-dev-cdrom-audio",
+     * "gnome-dev-cdrom",
+     * "gnome-dev",
+     * "gnome"
+     * };
+     *
+     * icon1 = g_themed_icon_new_from_names (names, 4);
+     * icon2 = g_themed_icon_new_with_default_fallbacks ("gnome-dev-cdrom-audio");
+     * ]|
+     * @param iconname - a string containing an icon name
+     */
     static iconNewWithDefaultFallbacks(iconname) {
         const ptr = call("libgio-2.0.so.0", "g_themed_icon_new_with_default_fallbacks", [
             {
@@ -37,6 +71,13 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Append a name to the list of icons from within @icon.
+     *
+     * Note that doing so invalidates the hash computed by prior calls
+     * to g_icon_hash().
+     * @param iconname - name of icon to append to list of icons from within @icon.
+     */
     appendName(iconname) {
         call("libgio-2.0.so.0", "g_themed_icon_append_name", [
             {
@@ -49,6 +90,9 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the names of icons from within @icon.
+     */
     getNames() {
         return call("libgio-2.0.so.0", "g_themed_icon_get_names", [
             {
@@ -57,6 +101,13 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Prepend a name to the list of icons from within @icon.
+     *
+     * Note that doing so invalidates the hash computed by prior calls
+     * to g_icon_hash().
+     * @param iconname - name of icon to prepend to list of icons from within @icon.
+     */
     prependName(iconname) {
         call("libgio-2.0.so.0", "g_themed_icon_prepend_name", [
             {
@@ -69,6 +120,10 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if two icons are equal.
+     * @param icon2 - pointer to the second #GIcon.
+     */
     equal(icon2) {
         return call("libgio-2.0.so.0", "g_icon_equal", [
             {
@@ -82,6 +137,9 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets a hash for an icon.
+     */
     hash() {
         return call("libgio-2.0.so.0", "g_icon_hash", [
             {
@@ -90,6 +148,13 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+     * back by calling g_icon_deserialize() on the returned value.
+     * As serialization will avoid using raw icon data when possible, it only
+     * makes sense to transfer the #GVariant between processes on the same machine,
+     * (as opposed to over the network), and within the same file system namespace.
+     */
     serialize() {
         const ptr = call("libgio-2.0.so.0", "g_icon_serialize", [
             {
@@ -106,6 +171,24 @@ export class ThemedIcon extends GObject.GObject {
             return null;
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Generates a textual representation of `icon` that can be used for
+     * serialization such as when passing `icon` to a different process or
+     * saving it to persistent storage. Use g_icon_new_for_string() to
+     * get `icon` back from the returned string.
+     *
+     * The encoding of the returned string is proprietary to #GIcon except
+     * in the following two cases
+     *
+     * - If `icon` is a #GFileIcon, the returned string is a native path
+     * (such as `/path/to/my icon.png`) without escaping
+     * if the #GFile for `icon` is a native file.  If the file is not
+     * native, the returned string is the result of g_file_get_uri()
+     * (such as `sftp://path/to/my%20icon.png`).
+     *
+     * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+     * the encoding is simply the name (such as `network-server`).
+     */
     toString() {
         return call("libgio-2.0.so.0", "g_icon_to_string", [
             {

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

@@ -1,5 +1,9 @@
 import * as GObject from "../gobject/index.js";
 import { Resolver } from "./resolver.js";
+/**
+ * #GThreadedResolver is an implementation of #GResolver which calls the libc
+ * lookup functions in threads to allow them to run asynchronously.
+ */
 export declare class ThreadedResolver extends Resolver {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;

package/dist/generated/gio/threaded-resolver.js

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Resolver } from "./resolver.js";
+/**
+ * #GThreadedResolver is an implementation of #GResolver which calls the libc
+ * lookup functions in threads to allow them to run asynchronously.
+ */
 export class ThreadedResolver extends Resolver {
     constructor(...args) {
         super(...args);

package/dist/generated/gio/threaded-socket-service.d.ts

@@ -2,6 +2,11 @@ import { SocketConnection } from "./socket-connection.js";
 import * as GObject from "../gobject/index.js";
 import { SocketService } from "./socket-service.js";
 export declare class ThreadedSocketService extends SocketService {
+    /**
+     * Creates a new #GThreadedSocketService with no listeners. Listeners
+     * must be added with one of the #GSocketListener "add" methods.
+     * @param maxThreads - the maximal number of threads to execute concurrently
+     */
     constructor(maxThreads: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gio/threaded-socket-service.js

@@ -3,6 +3,24 @@ import { getObject } from "@gtkx/ffi";
 import { SocketConnection } from "./socket-connection.js";
 import * as GObject from "../gobject/index.js";
 import { SocketService } from "./socket-service.js";
+/**
+ * A `GThreadedSocketService` is a simple subclass of [class@Gio.SocketService]
+ * that handles incoming connections by creating a worker thread and
+ * dispatching the connection to it by emitting the
+ * [signal@Gio.ThreadedSocketService::run signal] in the new thread.
+ *
+ * The signal handler may perform blocking I/O and need not return
+ * until the connection is closed.
+ *
+ * The service is implemented using a thread pool, so there is a
+ * limited amount of threads available to serve incoming requests.
+ * The service automatically stops the [class@Gio.SocketService] from accepting
+ * new connections when all threads are busy.
+ *
+ * As with [class@Gio.SocketService], you may connect to
+ * [signal@Gio.ThreadedSocketService::run], or subclass and override the default
+ * handler.
+ */
 const SIGNAL_META = {
     run: {
         params: [

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

@@ -1,16 +1,61 @@
 import { TlsDatabase } from "./tls-database.js";
+/**
+ * TLS (Transport Layer Security, aka SSL) and DTLS backend. This is an
+ * internal type used to coordinate the different classes implemented
+ * by a TLS backend.
+ */
 export declare class TlsBackend {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): TlsBackend;
+    /**
+     * Gets the #GType of @backend's #GTlsCertificate implementation.
+     */
     getCertificateType(): number;
+    /**
+     * Gets the #GType of @backend's #GTlsClientConnection implementation.
+     */
     getClientConnectionType(): number;
+    /**
+     * Gets the default #GTlsDatabase used to verify TLS connections.
+     */
     getDefaultDatabase(): TlsDatabase;
+    /**
+     * Gets the #GType of @backend’s #GDtlsClientConnection implementation.
+     */
     getDtlsClientConnectionType(): number;
+    /**
+     * Gets the #GType of @backend’s #GDtlsServerConnection implementation.
+     */
     getDtlsServerConnectionType(): number;
+    /**
+     * Gets the #GType of @backend's #GTlsFileDatabase implementation.
+     */
     getFileDatabaseType(): number;
+    /**
+     * Gets the #GType of @backend's #GTlsServerConnection implementation.
+     */
     getServerConnectionType(): number;
+    /**
+     * Set the default #GTlsDatabase used to verify TLS connections
+     *
+     * Any subsequent call to g_tls_backend_get_default_database() will return
+     * the database set in this call.  Existing databases and connections are not
+     * modified.
+     *
+     * Setting a %NULL default database will reset to using the system default
+     * database as if g_tls_backend_set_default_database() had never been called.
+     * @param database - the #GTlsDatabase
+     */
     setDefaultDatabase(database?: TlsDatabase | null): void;
+    /**
+     * Checks if DTLS is supported. DTLS support may not be available even if TLS
+     * support is available, and vice-versa.
+     */
     supportsDtls(): boolean;
+    /**
+     * Checks if TLS is supported; if this returns %FALSE for the default
+     * #GTlsBackend, it means no "real" TLS backend is available.
+     */
     supportsTls(): boolean;
 }

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

@@ -1,6 +1,11 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { TlsDatabase } from "./tls-database.js";
+/**
+ * TLS (Transport Layer Security, aka SSL) and DTLS backend. This is an
+ * internal type used to coordinate the different classes implemented
+ * by a TLS backend.
+ */
 export class TlsBackend {
     ptr;
     constructor(ptr) {
@@ -9,6 +14,9 @@ export class TlsBackend {
     static fromPtr(ptr) {
         return new TlsBackend(ptr);
     }
+    /**
+     * Gets the #GType of @backend's #GTlsCertificate implementation.
+     */
     getCertificateType() {
         return call("libgio-2.0.so.0", "g_tls_backend_get_certificate_type", [
             {
@@ -17,6 +25,9 @@ export class TlsBackend {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the #GType of @backend's #GTlsClientConnection implementation.
+     */
     getClientConnectionType() {
         return call("libgio-2.0.so.0", "g_tls_backend_get_client_connection_type", [
             {
@@ -25,6 +36,9 @@ export class TlsBackend {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the default #GTlsDatabase used to verify TLS connections.
+     */
     getDefaultDatabase() {
         const ptr = call("libgio-2.0.so.0", "g_tls_backend_get_default_database", [
             {
@@ -34,6 +48,9 @@ export class TlsBackend {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, TlsDatabase);
     }
+    /**
+     * Gets the #GType of @backend’s #GDtlsClientConnection implementation.
+     */
     getDtlsClientConnectionType() {
         return call("libgio-2.0.so.0", "g_tls_backend_get_dtls_client_connection_type", [
             {
@@ -42,6 +59,9 @@ export class TlsBackend {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the #GType of @backend’s #GDtlsServerConnection implementation.
+     */
     getDtlsServerConnectionType() {
         return call("libgio-2.0.so.0", "g_tls_backend_get_dtls_server_connection_type", [
             {
@@ -50,6 +70,9 @@ export class TlsBackend {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the #GType of @backend's #GTlsFileDatabase implementation.
+     */
     getFileDatabaseType() {
         return call("libgio-2.0.so.0", "g_tls_backend_get_file_database_type", [
             {
@@ -58,6 +81,9 @@ export class TlsBackend {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the #GType of @backend's #GTlsServerConnection implementation.
+     */
     getServerConnectionType() {
         return call("libgio-2.0.so.0", "g_tls_backend_get_server_connection_type", [
             {
@@ -66,6 +92,17 @@ export class TlsBackend {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Set the default #GTlsDatabase used to verify TLS connections
+     *
+     * Any subsequent call to g_tls_backend_get_default_database() will return
+     * the database set in this call.  Existing databases and connections are not
+     * modified.
+     *
+     * Setting a %NULL default database will reset to using the system default
+     * database as if g_tls_backend_set_default_database() had never been called.
+     * @param database - the #GTlsDatabase
+     */
     setDefaultDatabase(database) {
         call("libgio-2.0.so.0", "g_tls_backend_set_default_database", [
             {
@@ -79,6 +116,10 @@ export class TlsBackend {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if DTLS is supported. DTLS support may not be available even if TLS
+     * support is available, and vice-versa.
+     */
     supportsDtls() {
         return call("libgio-2.0.so.0", "g_tls_backend_supports_dtls", [
             {
@@ -87,6 +128,10 @@ export class TlsBackend {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if TLS is supported; if this returns %FALSE for the default
+     * #GTlsBackend, it means no "real" TLS backend is available.
+     */
     supportsTls() {
         return call("libgio-2.0.so.0", "g_tls_backend_supports_tls", [
             {

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

@@ -2,24 +2,214 @@ import { TlsCertificateFlags } from "./enums.js";
 import { SocketConnectable } from "./socket-connectable.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A certificate used for TLS authentication and encryption.
+ * This can represent either a certificate only (eg, the certificate
+ * received by a client from a server), or the combination of
+ * a certificate and a private key (which is needed when acting as a
+ * [iface@Gio.TlsServerConnection]).
+ */
 export declare class TlsCertificate extends GObject.GObject {
+    /**
+     * Creates a #GTlsCertificate from the data in @file.
+     *
+     * As of 2.72, if the filename ends in `.p12` or `.pfx` the data is loaded by
+     * g_tls_certificate_new_from_pkcs12() otherwise it is loaded by
+     * g_tls_certificate_new_from_pem(). See those functions for
+     * exact details.
+     *
+     * If `file` cannot be read or parsed, the function will return %NULL and
+     * set @error.
+     * @param file - file containing a certificate to import
+     */
     constructor(file: string);
     constructor(...args: unknown[]);
+    /**
+     * Creates a #GTlsCertificate from the data in @file.
+     *
+     * If `file` cannot be read or parsed, the function will return %NULL and
+     * set @error.
+     *
+     * Any unknown file types will error with %G_IO_ERROR_NOT_SUPPORTED.
+     * Currently only `.p12` and `.pfx` files are supported.
+     * See g_tls_certificate_new_from_pkcs12() for more details.
+     * @param file - file containing a certificate to import
+     * @param password - password for PKCS #12 files
+     */
     static certificateNewFromFileWithPassword(file: string, password: string): TlsCertificate;
+    /**
+     * Creates a #GTlsCertificate from the PEM-encoded data in `cert_file` and @key_file. The returned certificate will be the first certificate
+     * found in @cert_file. As of GLib 2.44, if `cert_file` contains more
+     * certificates it will try to load a certificate chain. All
+     * certificates will be verified in the order found (top-level
+     * certificate should be the last one in the file) and the
+     * #GTlsCertificate:issuer property of each certificate will be set
+     * accordingly if the verification succeeds. If any certificate in the
+     * chain cannot be verified, the first certificate in the file will
+     * still be returned.
+     *
+     * If either file cannot be read or parsed, the function will return
+     * %NULL and set @error. Otherwise, this behaves like
+     * g_tls_certificate_new_from_pem().
+     * @param certFile - file containing one or more PEM-encoded
+     * @param keyFile - file containing a PEM-encoded private key
+     */
     static certificateNewFromFiles(certFile: string, keyFile: string): TlsCertificate;
+    /**
+     * Creates a #GTlsCertificate from the PEM-encoded data in @data. If
+     * `data` includes both a certificate and a private key, then the
+     * returned certificate will include the private key data as well. (See
+     * the #GTlsCertificate:private-key-pem property for information about
+     * supported formats.)
+     *
+     * The returned certificate will be the first certificate found in
+     * @data. As of GLib 2.44, if `data` contains more certificates it will
+     * try to load a certificate chain. All certificates will be verified in
+     * the order found (top-level certificate should be the last one in the
+     * file) and the #GTlsCertificate:issuer property of each certificate
+     * will be set accordingly if the verification succeeds. If any
+     * certificate in the chain cannot be verified, the first certificate in
+     * the file will still be returned.
+     * @param data - PEM-encoded certificate data
+     * @param length - the length of @data, or -1 if it's 0-terminated.
+     */
     static certificateNewFromPem(data: string, length: number): TlsCertificate;
+    /**
+     * Creates a #GTlsCertificate from a
+     * PKCS \#11 URI.
+     *
+     * An example `pkcs11_uri` would be `pkcs11:model=Model;manufacturer=Manufacture;serial=1;token=My%20Client%20Certificate;id=%01`
+     *
+     * Where the token’s layout is:
+     *
+     * |[
+     * Object 0:
+     * URL: pkcs11:model=Model;manufacturer=Manufacture;serial=1;token=My%20Client%20Certificate;id=%01;object=private%20key;type=private
+     * Type: Private key (RSA-2048)
+     * ID: 01
+     *
+     * Object 1:
+     * URL: pkcs11:model=Model;manufacturer=Manufacture;serial=1;token=My%20Client%20Certificate;id=%01;object=Certificate%20for%20Authentication;type=cert
+     * Type: X.509 Certificate (RSA-2048)
+     * ID: 01
+     * ]|
+     *
+     * In this case the certificate and private key would both be detected and used as expected.
+     * `pkcs_uri` may also just reference an X.509 certificate object and then optionally
+     * `private_key_pkcs11_uri` allows using a private key exposed under a different URI.
+     *
+     * Note that the private key is not accessed until usage and may fail or require a PIN later.
+     * @param pkcs11Uri - A PKCS \#11 URI
+     * @param privateKeyPkcs11Uri - A PKCS \#11 URI
+     */
     static certificateNewFromPkcs11Uris(pkcs11Uri: string, privateKeyPkcs11Uri?: string | null): TlsCertificate;
+    /**
+     * Creates a #GTlsCertificate from the data in @data. It must contain
+     * a certificate and matching private key.
+     *
+     * If extra certificates are included they will be verified as a chain
+     * and the #GTlsCertificate:issuer property will be set.
+     * All other data will be ignored.
+     *
+     * You can pass as single password for all of the data which will be
+     * used both for the PKCS #12 container as well as encrypted
+     * private keys. If decryption fails it will error with
+     * %G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD.
+     *
+     * This constructor requires support in the current #GTlsBackend.
+     * If support is missing it will error with
+     * %G_IO_ERROR_NOT_SUPPORTED.
+     *
+     * Other parsing failures will error with %G_TLS_ERROR_BAD_CERTIFICATE.
+     * @param data - DER-encoded PKCS #12 format certificate data
+     * @param length - the length of @data
+     * @param password - optional password for encrypted certificate data
+     */
     static certificateNewFromPkcs12(data: number[], length: number, password?: string | null): TlsCertificate;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Creates one or more #GTlsCertificates from the PEM-encoded
+     * data in @file. If `file` cannot be read or parsed, the function will
+     * return %NULL and set @error. If `file` does not contain any
+     * PEM-encoded certificates, this will return an empty list and not
+     * set @error.
+     * @param file - file containing PEM-encoded certificates to import
+     */
     static listNewFromFile(file: string): TlsCertificate[];
+    /**
+     * Gets the value of #GTlsCertificate:dns-names.
+     */
     getDnsNames(): GLib.PtrArray | null;
+    /**
+     * Gets the value of #GTlsCertificate:ip-addresses.
+     */
     getIpAddresses(): GLib.PtrArray | null;
+    /**
+     * Gets the #GTlsCertificate representing @cert's issuer, if known
+     */
     getIssuer(): TlsCertificate | null;
+    /**
+     * Returns the issuer name from the certificate.
+     */
     getIssuerName(): string | null;
+    /**
+     * Returns the time at which the certificate became or will become invalid.
+     */
     getNotValidAfter(): GLib.DateTime | null;
+    /**
+     * Returns the time at which the certificate became or will become valid.
+     */
     getNotValidBefore(): GLib.DateTime | null;
+    /**
+     * Returns the subject name from the certificate.
+     */
     getSubjectName(): string | null;
+    /**
+     * Check if two #GTlsCertificate objects represent the same certificate.
+     * The raw DER byte data of the two certificates are checked for equality.
+     * This has the effect that two certificates may compare equal even if
+     * their #GTlsCertificate:issuer, #GTlsCertificate:private-key, or
+     * #GTlsCertificate:private-key-pem properties differ.
+     * @param certTwo - second certificate to compare
+     */
     isSame(certTwo: TlsCertificate): boolean;
+    /**
+     * This verifies `cert` and returns a set of #GTlsCertificateFlags
+     * indicating any problems found with it. This can be used to verify a
+     * certificate outside the context of making a connection, or to
+     * check a certificate against a CA that is not part of the system
+     * CA database.
+     *
+     * If `cert` is valid, %G_TLS_CERTIFICATE_NO_FLAGS is returned.
+     *
+     * If `identity` is not %NULL, @cert's name(s) will be compared against
+     * it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return
+     * value if it does not match. If `identity` is %NULL, that bit will
+     * never be set in the return value.
+     *
+     * If `trusted_ca` is not %NULL, then `cert` (or one of the certificates
+     * in its chain) must be signed by it, or else
+     * %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If
+     * `trusted_ca` is %NULL, that bit will never be set in the return
+     * value.
+     *
+     * GLib guarantees that if certificate verification fails, at least one
+     * error will be set in the return value, but it does not guarantee
+     * that all possible errors will be set. Accordingly, you may not safely
+     * decide to ignore any particular type of error. For example, it would
+     * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+     * expired certificates, because this could potentially be the only
+     * error flag set even if other problems exist with the certificate.
+     *
+     * Because TLS session context is not used, #GTlsCertificate may not
+     * perform as many checks on the certificates as #GTlsConnection would.
+     * For example, certificate constraints may not be honored, and
+     * revocation checks may not be performed. The best way to verify TLS
+     * certificates used by a TLS connection is to let #GTlsConnection
+     * handle the verification.
+     * @param identity - the expected peer identity
+     * @param trustedCa - the certificate of a trusted authority
+     */
     verify(identity?: SocketConnectable | null, trustedCa?: TlsCertificate | null): TlsCertificateFlags;
     connect(signal: "notify", handler: (self: TlsCertificate, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;