janishutz/dotfiles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity
dotfiles/config/ags/quickactions/@girs/gcr-3.d.ts
Janis Hutz b5ad7e3034 [Notes] Some changes
2025-04-25 06:53:17 +02:00

8010 lines
377 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/// <reference path="./gio-2.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />
/// <reference path="./gck-1.d.ts" />
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://Gcr?version=3' {
// Module dependencies
import type Gio from 'gi://Gio?version=2.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
import type Gck from 'gi://Gck?version=1';
export namespace Gcr {
/**
* Gcr-3
*/
/**
* The status of a built certificate chain. Will be set to
* %GCR_CERTIFICATE_CHAIN_UNKNOWN for certificate chains that have not been
* built.
*/
/**
* The status of a built certificate chain. Will be set to
* %GCR_CERTIFICATE_CHAIN_UNKNOWN for certificate chains that have not been
* built.
*/
export namespace CertificateChainStatus {
export const $gtype: GObject.GType<CertificateChainStatus>;
}
enum CertificateChainStatus {
/**
* The certificate chain's status is unknown.
* When a chain is not yet built it has this status. If a chain is modified after
* being built, it has this status.
*/
UNKNOWN,
/**
* A full chain could not be loaded. The
* chain does not end with a self-signed certificate, a trusted anchor, or a
* pinned certificate.
*/
INCOMPLETE,
/**
* The certificate chain contains a revoked
* or otherwise explicitly distrusted certificate. The entire chain should
* be distrusted.
*/
DISTRUSTED,
/**
* The chain ends with a self-signed
* certificate. No trust anchor was found.
*/
SELFSIGNED,
/**
* The chain represents a pinned certificate. A
* pinned certificate is an exception which trusts a given certificate
* explicitly for a purpose and communication with a certain peer.
*/
PINNED,
/**
* The chain ends with an anchored
* certificate. The anchored certificate is not necessarily self-signed.
*/
ANCHORED,
}
/**
* The format of a certificate request. Currently only PKCS#10 is supported.
*/
/**
* The format of a certificate request. Currently only PKCS#10 is supported.
*/
export namespace CertificateRequestFormat {
export const $gtype: GObject.GType<CertificateRequestFormat>;
}
enum CertificateRequestFormat {
/**
* certificate request is in PKCS#10 format
*/
CERTIFICATE_REQUEST_PKCS10,
}
/**
* Values responding to error codes for parsing and serializing data.
*/
/**
* Values responding to error codes for parsing and serializing data.
*/
export namespace DataError {
export const $gtype: GObject.GType<DataError>;
}
enum DataError {
/**
* Failed to parse or serialize the data
*/
FAILURE,
/**
* The data was unrecognized or unsupported
*/
UNRECOGNIZED,
/**
* The operation was cancelled
*/
CANCELLED,
/**
* The data was encrypted or locked and could not be unlocked.
*/
LOCKED,
}
/**
* The various format identifiers.
*/
/**
* The various format identifiers.
*/
export namespace DataFormat {
export const $gtype: GObject.GType<DataFormat>;
}
enum DataFormat {
/**
* Represents all the formats, when enabling or disabling
*/
ALL,
/**
* Not a valid format
*/
INVALID,
/**
* DER encoded private key
*/
DER_PRIVATE_KEY,
/**
* DER encoded RSA private key
*/
DER_PRIVATE_KEY_RSA,
/**
* DER encoded DSA private key
*/
DER_PRIVATE_KEY_DSA,
/**
* DER encoded EC private key
*/
DER_PRIVATE_KEY_EC,
/**
* DER encoded SubjectPublicKeyInfo
*/
DER_SUBJECT_PUBLIC_KEY,
/**
* DER encoded X.509 certificate
*/
DER_CERTIFICATE_X509,
/**
* DER encoded PKCS#7 container file which can contain certificates
*/
DER_PKCS7,
/**
* DER encoded PKCS#8 file which can contain a key
*/
DER_PKCS8,
/**
* Unencrypted DER encoded PKCS#8 file which can contain a key
*/
DER_PKCS8_PLAIN,
/**
* Encrypted DER encoded PKCS#8 file which can contain a key
*/
DER_PKCS8_ENCRYPTED,
/**
* DER encoded PKCS#10 certificate request file
*/
DER_PKCS10,
/**
* DER encoded SPKAC as generated by HTML5 keygen element
*/
DER_SPKAC,
/**
* OpenSSL style SPKAC data
*/
BASE64_SPKAC,
/**
* DER encoded PKCS#12 file which can contain certificates and/or keys
*/
DER_PKCS12,
/**
* OpenSSH v1 or v2 public key
*/
OPENSSH_PUBLIC,
/**
* OpenPGP key packet(s)
*/
OPENPGP_PACKET,
/**
* OpenPGP public or private key armor encoded data
*/
OPENPGP_ARMOR,
/**
* An OpenSSL style PEM file with unspecified contents
*/
PEM,
/**
* An OpenSSL style PEM file with a private RSA key
*/
PEM_PRIVATE_KEY_RSA,
/**
* An OpenSSL style PEM file with a private DSA key
*/
PEM_PRIVATE_KEY_DSA,
/**
* An OpenSSL style PEM file with an X.509 certificate
*/
PEM_CERTIFICATE_X509,
/**
* An OpenSSL style PEM file containing PKCS#7
*/
PEM_PKCS7,
/**
* Unencrypted OpenSSL style PEM file containing PKCS#8
*/
PEM_PKCS8_PLAIN,
/**
* Encrypted OpenSSL style PEM file containing PKCS#8
*/
PEM_PKCS8_ENCRYPTED,
/**
* An OpenSSL style PEM file containing PKCS#12
*/
PEM_PKCS12,
/**
* An OpenSSL style PEM file with a private key
*/
PEM_PRIVATE_KEY,
/**
* An OpenSSL style PEM file containing PKCS#10
*/
PEM_PKCS10,
/**
* An OpenSSL style PEM file with a private EC key
*/
PEM_PRIVATE_KEY_EC,
/**
* An OpenSSL style PEM file containing a SubjectPublicKeyInfo
*/
PEM_PUBLIC_KEY,
}
/**
* Various replies returned by [method`Prompt`.confirm] and friends.
*/
/**
* Various replies returned by [method`Prompt`.confirm] and friends.
*/
export namespace PromptReply {
export const $gtype: GObject.GType<PromptReply>;
}
enum PromptReply {
/**
* the prompt was cancelled
*/
CANCEL,
/**
* the user replied with 'ok'
*/
CONTINUE,
}
/**
* No error returned by the #GcrSystemPrompt is suitable for display or
* to the user.
*
* If the system prompter can only show one prompt at a time, and there is
* already a prompt being displayed, and the timeout waiting to open the
* prompt expires, then %GCR_SYSTEM_PROMPT_IN_PROGRESS is returned.
*/
/**
* No error returned by the #GcrSystemPrompt is suitable for display or
* to the user.
*
* If the system prompter can only show one prompt at a time, and there is
* already a prompt being displayed, and the timeout waiting to open the
* prompt expires, then %GCR_SYSTEM_PROMPT_IN_PROGRESS is returned.
*/
export namespace SystemPromptError {
export const $gtype: GObject.GType<SystemPromptError>;
}
enum SystemPromptError {
/**
* another prompt is already in progress
*/
SYSTEM_PROMPT_IN_PROGRESS,
}
/**
* The mode for the system prompter. Most system prompters can only show
* one prompt at a time and would use the %GCR_SYSTEM_PROMPTER_SINGLE mode.
*/
/**
* The mode for the system prompter. Most system prompters can only show
* one prompt at a time and would use the %GCR_SYSTEM_PROMPTER_SINGLE mode.
*/
export namespace SystemPrompterMode {
export const $gtype: GObject.GType<SystemPrompterMode>;
}
enum SystemPrompterMode {
/**
* only one prompt shown at a time
*/
SINGLE,
/**
* more than one prompt shown at a time
*/
MULTIPLE,
}
const ICON_CERTIFICATE: string;
const ICON_GNUPG: string;
const ICON_HOME_DIRECTORY: string;
const ICON_KEY: string;
const ICON_KEY_PAIR: string;
const ICON_PASSWORD: string;
const ICON_SMART_CARD: string;
/**
* The major version number of the Gcr library.
*/
const MAJOR_VERSION: number;
/**
* The micro version number of the Gcr library.
*/
const MICRO_VERSION: number;
/**
* The minor version number of the Gcr library.
*/
const MINOR_VERSION: number;
/**
* The purpose used to verify the client certificate in a TLS connection.
*/
const PURPOSE_CLIENT_AUTH: string;
/**
* The purpose used to verify certificate used for the signature on signed code.
*/
const PURPOSE_CODE_SIGNING: string;
/**
* The purpose used to verify certificates that are used in email communication
* such as S/MIME.
*/
const PURPOSE_EMAIL: string;
/**
* The purpose used to verify the server certificate in a TLS connection. This
* is the most common purpose in use.
*/
const PURPOSE_SERVER_AUTH: string;
/**
* The current secret exchange protocol. Key agreement is done using DH with the
* 1536 bit IKE parameter group. Keys are derived using SHA256 with HKDF. The
* transport encryption is done with 128 bit AES.
*/
const SECRET_EXCHANGE_PROTOCOL_1: string;
const UNLOCK_OPTION_ALWAYS: string;
const UNLOCK_OPTION_IDLE: string;
const UNLOCK_OPTION_SESSION: string;
const UNLOCK_OPTION_TIMEOUT: string;
/**
* Compare one certificate against another. If the certificates are equal
* then zero is returned. If one certificate is %NULL or not a certificate,
* then a non-zero value is returned.
*
* The return value is useful in a stable sort, but has no user logical
* meaning.
* @param first the certificate to compare
* @param other the certificate to compare against
* @returns zero if the certificates match, non-zero otherwise.
*/
function certificate_compare(first?: Comparable | null, other?: Comparable | null): number;
function data_error_get_domain(): GLib.Quark;
/**
* Create a key fingerprint for a certificate, public key or private key.
* Note that this is not a fingerprint of certificate data, which you would
* use gcr_certificate_get_fingerprint() for.
* @param attrs attributes for key or certificate
* @param checksum_type the type of fingerprint to create
* @returns the fingerprint or %NULL if the input was invalid.
*/
function fingerprint_from_attributes(
attrs: Gck.Attributes,
checksum_type: GLib.ChecksumType | null,
): Uint8Array | null;
/**
* Create a key fingerprint for a DER encoded subjectPublicKeyInfo. The
* fingerprint is created so that it will be identical for a key and its
* corresponding certificate.
*
* Note that in the case of certificates this is not a fingerprint of the
* actual certificate data, but rather of the public key contained in a
* certificate.
* @param key_info DER encoded subjectPublicKeyInfo structure
* @param checksum_type the type of fingerprint to create
* @returns the fingerprint or %NULL if the input was invalid.
*/
function fingerprint_from_subject_public_key_info(
key_info: Uint8Array | string,
checksum_type: GLib.ChecksumType | null,
): Uint8Array | null;
/**
* Get an appropriate icon for the token
* @param token_info the token info
* @returns the icon
*/
function icon_for_token(token_info: Gck.TokenInfo): Gio.Icon;
/**
* Create a set of importers which can import this parsed item.
* The parsed item is represented by the state of the GcrParser at the
* time of calling this method.
* @param parsed a parser with a parsed item to import
* @returns a list of importers which can import the parsed item, which should be freed with g_object_unref(), or %NULL if no types of importers can be created
*/
function importer_create_for_parsed(parsed: Parsed): Importer[];
/**
* Queues an additional item to be imported in all compattible importers
* in the set. The parsed item is represented by the state of the #GcrParser
* at the time of calling this method.
*
* If the parsed item is incompatible with an importer, then that the item
* will not be queued on that importer.
* @param importers a set of importers
* @param parsed a parsed item
* @returns a new set of importers that queued the item, which should be freed with gck_list_unref_free()
*/
function importer_queue_and_filter_for_parsed(importers: Importer[], parsed: Parsed): Importer[];
/**
* Register an importer to handle parsed items that match the given attributes.
*
* If `attrs` are a floating reference, then it is consumed.
* @param importer_type the GType of the importer being registered
* @param attrs the attributes that this importer is compatible with
*/
function importer_register(importer_type: GObject.GType, attrs: Gck.Attributes): void;
/**
* Register built-in PKCS#11 and GnuPG importers.
*/
function importer_register_well_known(): void;
/**
* Disconnect the mock prompter
*/
function mock_prompter_disconnect(): void;
/**
* Queue an expected response on the mock prompter.
*
* Expects any prompt, and closes the prompt when it gets it.
*/
function mock_prompter_expect_close(): void;
/**
* Queue an expected response on the mock prompter.
*
* Expects a confirmation prompt, and then cancels that prompt.
*/
function mock_prompter_expect_confirm_cancel(): void;
/**
* Queue an expected response on the mock prompter.
*
* Expects a password prompt, and then cancels that prompt.
*/
function mock_prompter_expect_password_cancel(): void;
/**
* Get the delay in milliseconds before the mock prompter completes
* an expected prompt.
* @returns the delay
*/
function mock_prompter_get_delay_msec(): number;
/**
* Check if the mock prompter is expecting a response. This will be %TRUE
* when one of the <literal>gcr_mock_prompter_expect_xxx<!-- -->()</literal>
* functions have been used to queue an expected prompt, but that prompt
* response has not be 'used' yet.
* @returns whether expecting a prompt
*/
function mock_prompter_is_expecting(): boolean;
/**
* Check if the mock prompter is showing any prompts.
* @returns whether prompting
*/
function mock_prompter_is_prompting(): boolean;
/**
* Set the delay in milliseconds before the mock prompter completes
* an expected prompt.
* @param delay_msec prompt response delay in milliseconds
*/
function mock_prompter_set_delay_msec(delay_msec: number): void;
/**
* Start the mock prompter. This is often used from the
* <literal>setup<!-- -->()</literal> function of tests.
*
* Starts the mock prompter in an additional thread. Use the returned DBus bus
* name with gcr_system_prompt_open_for_prompter() to connect to this prompter.
* @returns the bus name that the mock prompter is listening on
*/
function mock_prompter_start(): string;
/**
* Stop the mock prompter. This is often used from the
* <literal>teardown<!-- -->()</literal> function of tests.
*/
function mock_prompter_stop(): void;
/**
* Unreferences a parsed item which was referenced with gcr_parsed_ref()
* @param parsed a parsed item
*/
function parsed_unref(parsed?: any | null): void;
/**
* Add a #GckModule to the list of PKCS#11 modules that are used by the
* GCR library.
*
* It is not normally necessary to call this function. The available
* PKCS#11 modules installed on the system are automatically loaded
* by the GCR library.
* @param module a #GckModule
*/
function pkcs11_add_module(module: Gck.Module): void;
/**
* Initialize a PKCS#11 module and add it to the modules that are
* used by the GCR library. Note that is an error to initialize the same
* PKCS#11 module twice.
*
* It is not normally necessary to call this function. The available
* PKCS#11 modules installed on the system are automatically loaded
* by the GCR library.
* @param module_path the full file path of the PKCS#11 module
* @param unused unused
* @returns whether the module was sucessfully added.
*/
function pkcs11_add_module_from_file(module_path: string, unused?: any | null): boolean;
/**
* List all the PKCS#11 modules that are used by the GCR library.
* Each module is a [class`Gck`.Module] object.
*
* An empty list of modules will be returned if [func`pkcs1`1_set_modules],
* or [func`pkcs1`1_initialize] has not yet run.
*
* When done with the list, free it with gck_list_unref_free().
* @returns a newly allocated list of #GckModule objects
*/
function pkcs11_get_modules(): Gck.Module[];
/**
* List all the PKCS#11 slots that are used by the GCR library for lookup
* of trust assertions. Each slot is a [class`Gck`.Slot] object.
*
* This will return an empty list if the [func`pkcs1`1_initialize] function has
* not yet been called.
* @returns a list of #GckSlot objects to use for lookup of trust, or the empty list if not initialized or no appropriate trust stores could be found.
*/
function pkcs11_get_trust_lookup_slots(): Gck.Slot[];
/**
* Get the PKCS#11 URIs that are used to identify which slots to use for
* lookup trust assertions.
* @returns the uri which identifies trust storage slot
*/
function pkcs11_get_trust_lookup_uris(): string[] | null;
/**
* Selects an appropriate PKCS#11 slot to store trust assertions. The slot
* to use is normally configured automatically by the system.
*
* This will only return a valid result after the [func`pkcs1`1_initialize]
* method has been called.
*
* When done with the #GckSlot, use g_object_unref() to release it.
* @returns the #GckSlot to use for trust assertions, or null if not initialized or no appropriate trust store could be found.
*/
function pkcs11_get_trust_store_slot(): Gck.Slot | null;
/**
* Get the PKCS#11 URI that is used to identify which slot to use for
* storing trust storage.
* @returns the uri which identifies trust storage slot
*/
function pkcs11_get_trust_store_uri(): string | null;
/**
* Asynchronously initialize the registered PKCS#11 modules.
* @param cancellable optional cancellable used to cancel the operation
* @returns whether the operation was successful or not.
*/
function pkcs11_initialize(cancellable?: Gio.Cancellable | null): boolean;
/**
* Asynchronously initialize the registered PKCS#11 modules.
* @param cancellable optional cancellable used to cancel the operation
*/
function pkcs11_initialize_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
/**
* Asynchronously initialize the registered PKCS#11 modules.
* @param cancellable optional cancellable used to cancel the operation
* @param callback callback which will be called when the operation completes
*/
function pkcs11_initialize_async(
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<Gio.Cancellable | null> | null,
): void;
/**
* Asynchronously initialize the registered PKCS#11 modules.
* @param cancellable optional cancellable used to cancel the operation
* @param callback callback which will be called when the operation completes
*/
function pkcs11_initialize_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<Gio.Cancellable | null> | null,
): Promise<boolean> | void;
/**
* Complete the asynchronous operation to initialize the registered PKCS#11
* modules.
* @param result the asynchronous result
* @returns whether the operation was successful or not.
*/
function pkcs11_initialize_finish(result: Gio.AsyncResult): boolean;
/**
* Set the list of PKCS#11 modules that are used by the GCR library.
* Each module in the list is a [class`Gck`.Module] object.
*
* It is not normally necessary to call this function. The available
* PKCS#11 modules installed on the system are automatically loaded
* by the GCR library.
* @param modules a list of PKCS#11 modules
*/
function pkcs11_set_modules(modules: Gck.Module[]): void;
/**
* Set the PKCS#11 URIs that are used to identify which slots to use for
* lookup of trust assertions.
*
* It is not normally necessary to call this function. The relevant
* PKCS#11 slots are automatically configured by the GCR library.
* @param pkcs11_uris the uris which identifies trust lookup slots
*/
function pkcs11_set_trust_lookup_uris(pkcs11_uris?: string | null): void;
/**
* Set the PKCS#11 URI that is used to identify which slot to use for
* storing trust assertions.
*
* It is not normally necessary to call this function. The relevant
* PKCS#11 slot is automatically configured by the GCR library.
* @param pkcs11_uri the uri which identifies trust storage slot
*/
function pkcs11_set_trust_store_uri(pkcs11_uri?: string | null): void;
/**
* Add a pinned `certificate` for connections to `peer` for `purpose`. A pinned
* certificate overrides all other certificate verification and should be
* used with care.
*
* If the same pinned certificate already exists, then this operation
* does not add another, and succeeds without error.
*
* This call may block, see gcr_trust_add_pinned_certificate_async() for the
* non-blocking version.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
* @returns %TRUE if the pinned certificate is recorded successfully
*/
function trust_add_pinned_certificate(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
): boolean;
/**
* Add a pinned certificate for communication with `peer` for `purpose`. A pinned
* certificate overrides all other certificate verification and should be used
* with care.
*
* If the same pinned certificate already exists, then this operation
* does not add another, and succeeds without error.
*
* When the operation is finished, callback will be called. You can then call
* [func`Gcr`.trust_add_pinned_certificate_finish] to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
*/
function trust_add_pinned_certificate_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
): Promise<boolean>;
/**
* Add a pinned certificate for communication with `peer` for `purpose`. A pinned
* certificate overrides all other certificate verification and should be used
* with care.
*
* If the same pinned certificate already exists, then this operation
* does not add another, and succeeds without error.
*
* When the operation is finished, callback will be called. You can then call
* [func`Gcr`.trust_add_pinned_certificate_finish] to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_add_pinned_certificate_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<Certificate> | null,
): void;
/**
* Add a pinned certificate for communication with `peer` for `purpose`. A pinned
* certificate overrides all other certificate verification and should be used
* with care.
*
* If the same pinned certificate already exists, then this operation
* does not add another, and succeeds without error.
*
* When the operation is finished, callback will be called. You can then call
* [func`Gcr`.trust_add_pinned_certificate_finish] to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_add_pinned_certificate_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<Certificate> | null,
): Promise<boolean> | void;
/**
* Finishes an asynchronous operation started by
* gcr_trust_add_pinned_certificate_async().
* @param result the #GAsyncResult passed to the callback
* @returns %TRUE if the pinned certificate is recorded successfully
*/
function trust_add_pinned_certificate_finish(result: Gio.AsyncResult): boolean;
/**
* Check if the `certificate` is a trust anchor for the given `purpose`. A trust
* anchor is used to verify the signatures on other certificates when verifying
* a certificate chain. Also known as a trusted certificate authority.
*
* This call may block, see [func`Gcr`.trust_is_certificate_anchored_async] for
* the non-blocking version.
*
* In the case of an error, %FALSE is also returned. Check `error` to detect
* if an error occurred.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param cancellable a #GCancellable
* @returns %TRUE if the certificate is a trust anchor
*/
function trust_is_certificate_anchored(
certificate: Certificate,
purpose: string,
cancellable?: Gio.Cancellable | null,
): boolean;
/**
* Check if the `certificate` is a trust anchor for the given `purpose`. A trust
* anchor is used to verify the signatures on other certificates when verifying
* a certificate chain. Also known as a trusted certificate authority.
*
* When the operation is finished, callback will be called. You can then call
* gcr_trust_is_certificate_anchored_finish() to get the result of the operation.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param cancellable a #GCancellable
*/
function trust_is_certificate_anchored_async(
certificate: Certificate,
purpose: string,
cancellable?: Gio.Cancellable | null,
): Promise<boolean>;
/**
* Check if the `certificate` is a trust anchor for the given `purpose`. A trust
* anchor is used to verify the signatures on other certificates when verifying
* a certificate chain. Also known as a trusted certificate authority.
*
* When the operation is finished, callback will be called. You can then call
* gcr_trust_is_certificate_anchored_finish() to get the result of the operation.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_is_certificate_anchored_async(
certificate: Certificate,
purpose: string,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<Certificate> | null,
): void;
/**
* Check if the `certificate` is a trust anchor for the given `purpose`. A trust
* anchor is used to verify the signatures on other certificates when verifying
* a certificate chain. Also known as a trusted certificate authority.
*
* When the operation is finished, callback will be called. You can then call
* gcr_trust_is_certificate_anchored_finish() to get the result of the operation.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_is_certificate_anchored_async(
certificate: Certificate,
purpose: string,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<Certificate> | null,
): Promise<boolean> | void;
/**
* Finishes an asynchronous operation started by
* gcr_trust_is_certificate_anchored_async().
*
* In the case of an error, %FALSE is also returned. Check `error` to detect
* if an error occurred.
* @param result the #GAsyncResult passed to the callback
* @returns %TRUE if the certificate is a trust anchor
*/
function trust_is_certificate_anchored_finish(result: Gio.AsyncResult): boolean;
/**
* Check if `certificate` is pinned for `purpose` to communicate with `peer`.
* A pinned certificate overrides all other certificate verification.
*
* This call may block, see gcr_trust_is_certificate_pinned_async() for the
* non-blocking version.
*
* In the case of an error, %FALSE is also returned. Check `error` to detect
* if an error occurred.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param peer the peer for this pinned
* @param cancellable a #GCancellable
* @returns %TRUE if the certificate is pinned for the host and purpose
*/
function trust_is_certificate_pinned(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
): boolean;
/**
* Check if `certificate` is pinned for `purpose` to communicate with `peer`. A
* pinned certificate overrides all other certificate verification.
*
* When the operation is finished, callback will be called. You can then call
* [func`Gcr`.trust_is_certificate_pinned_finish] to get the result of the
* operation.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param peer the peer for this pinned
* @param cancellable a #GCancellable
*/
function trust_is_certificate_pinned_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
): Promise<boolean>;
/**
* Check if `certificate` is pinned for `purpose` to communicate with `peer`. A
* pinned certificate overrides all other certificate verification.
*
* When the operation is finished, callback will be called. You can then call
* [func`Gcr`.trust_is_certificate_pinned_finish] to get the result of the
* operation.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param peer the peer for this pinned
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_is_certificate_pinned_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<Certificate> | null,
): void;
/**
* Check if `certificate` is pinned for `purpose` to communicate with `peer`. A
* pinned certificate overrides all other certificate verification.
*
* When the operation is finished, callback will be called. You can then call
* [func`Gcr`.trust_is_certificate_pinned_finish] to get the result of the
* operation.
* @param certificate a #GcrCertificate to check
* @param purpose the purpose string
* @param peer the peer for this pinned
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_is_certificate_pinned_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<Certificate> | null,
): Promise<boolean> | void;
/**
* Finishes an asynchronous operation started by
* gcr_trust_is_certificate_pinned_async().
*
* In the case of an error, %FALSE is also returned. Check `error` to detect
* if an error occurred.
* @param result the #GAsyncResult passed to the callback
* @returns %TRUE if the certificate is pinned.
*/
function trust_is_certificate_pinned_finish(result: Gio.AsyncResult): boolean;
/**
* Remove a pinned certificate for communication with `peer` for `purpose`.
*
* If the same pinned certificate does not exist, or was already removed,
* then this operation succeeds without error.
*
* This call may block, see gcr_trust_remove_pinned_certificate_async() for the
* non-blocking version.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
* @returns %TRUE if the pinned certificate no longer exists
*/
function trust_remove_pinned_certificate(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
): boolean;
/**
* Remove a pinned certificate for communication with `peer` for `purpose`.
*
* If the same pinned certificate does not exist, or was already removed,
* then this operation succeeds without error.
*
* When the operation is finished, callback will be called. You can then call
* gcr_trust_remove_pinned_certificate_finish() to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
*/
function trust_remove_pinned_certificate_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
): Promise<boolean>;
/**
* Remove a pinned certificate for communication with `peer` for `purpose`.
*
* If the same pinned certificate does not exist, or was already removed,
* then this operation succeeds without error.
*
* When the operation is finished, callback will be called. You can then call
* gcr_trust_remove_pinned_certificate_finish() to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_remove_pinned_certificate_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<Certificate> | null,
): void;
/**
* Remove a pinned certificate for communication with `peer` for `purpose`.
*
* If the same pinned certificate does not exist, or was already removed,
* then this operation succeeds without error.
*
* When the operation is finished, callback will be called. You can then call
* gcr_trust_remove_pinned_certificate_finish() to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param purpose the purpose string
* @param peer the peer for this pinned certificate
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
function trust_remove_pinned_certificate_async(
certificate: Certificate,
purpose: string,
peer: string,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<Certificate> | null,
): Promise<boolean> | void;
/**
* Finishes an asynchronous operation started by
* gcr_trust_remove_pinned_certificate_async().
* @param result the #GAsyncResult passed to the callback
* @returns %TRUE if the pinned certificate no longer exists
*/
function trust_remove_pinned_certificate_finish(result: Gio.AsyncResult): boolean;
interface FilterCollectionFunc<A = GObject.Object> {
(object: A): boolean;
}
/**
* Flags to be used with the gcr_certificate_chain_build() operation.
*/
/**
* Flags to be used with the gcr_certificate_chain_build() operation.
*/
export namespace CertificateChainFlags {
export const $gtype: GObject.GType<CertificateChainFlags>;
}
enum CertificateChainFlags {
/**
* no flags
*/
NONE,
/**
* If this flag is specified then no
* lookups for anchors or pinned certificates are done, and the resulting chain
* will be neither anchored or pinned. Additionally no missing certificate
* authorities are looked up in PKCS#11.
*/
NO_LOOKUPS,
}
export namespace ColumnFlags {
export const $gtype: GObject.GType<ColumnFlags>;
}
enum ColumnFlags {
NONE,
HIDDEN,
SORTABLE,
}
namespace CertificateChain {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
length: number;
}
}
/**
* Represents a chain of certificates, normally used to
* validate the trust in a certificate. An X.509 certificate chain has one
* endpoint certificate (the one for which trust is being verified) and then
* in turn the certificate that issued each previous certificate in the chain.
*
* This functionality is for building of certificate chains not for validating
* them. Use your favorite crypto library to validate trust in a certificate
* chain once its built.
*
* The order of certificates in the chain should be first the endpoint
* certificates and then the signing certificates.
*
* Create a new certificate chain with [ctor`CertificateChain`.new] and then
* add the certificates with [method`CertificateChain`.add].
*
* You can then use [method`CertificateChain`.build] to build the remainder of
* the chain. This will lookup missing certificates in PKCS#11 modules and
* also check that each certificate in the chain is the signer of the previous
* one. If a trust anchor, pinned certificate, or self-signed certificate is
* found, then the chain is considered built. Any extra certificates are
* removed from the chain.
*
* Once the certificate chain has been built, you can access its status
* through [method`CertificateChain`.get_status]. The status signifies whether
* the chain is anchored on a trust root, self-signed, incomplete etc. See
* [enum`CertificateChainStatus]` for information on the various statuses.
*
* It's important to understand that the building of a certificate chain is
* merely the first step towards verifying trust in a certificate.
*/
class CertificateChain extends GObject.Object {
static $gtype: GObject.GType<CertificateChain>;
// Properties
/**
* The length of the certificate chain.
*/
get length(): number;
// Constructors
constructor(properties?: Partial<CertificateChain.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): CertificateChain;
// Methods
/**
* Add `certificate` to the chain. The order of certificates in the chain are
* important. The first certificate should be the endpoint certificate, and
* then come the signers (certificate authorities) each in turn. If a root
* certificate authority is present, it should come last.
*
* Adding a certificate an already built chain (see
* gcr_certificate_chain_build()) resets the type of the certificate chain
* to %GCR_CERTIFICATE_CHAIN_UNKNOWN
* @param certificate a #GcrCertificate to add to the chain
*/
add(certificate: Certificate): void;
/**
* Complete a certificate chain. Once a certificate chain has been built
* its status can be examined.
*
* This operation will lookup missing certificates in PKCS#11
* modules and also that each certificate in the chain is the signer of the
* previous one. If a trust anchor, pinned certificate, or self-signed certificate
* is found, then the chain is considered built. Any extra certificates are
* removed from the chain.
*
* It's important to understand that building of a certificate chain does not
* constitute verifying that chain. This is merely the first step towards
* trust verification.
*
* The `purpose` is a string like %GCR_PURPOSE_CLIENT_AUTH and is the purpose
* for which the certificate chain will be used. Trust anchors are looked up
* for this purpose. This argument is required.
*
* The `peer` is usually the host name of the peer whith which this certificate
* chain is being used. It is used to look up pinned certificates that have
* been stored for this peer. If %NULL then no pinned certificates will
* be considered.
*
* If the %GCR_CERTIFICATE_CHAIN_NO_LOOKUPS flag is specified then no
* lookups for anchors or pinned certificates are done, and the resulting chain
* will be neither anchored or pinned. Additionally no missing certificate
* authorities are looked up in PKCS#11
*
* This call will block, see gcr_certificate_chain_build_async() for the
* asynchronous version.
* @param purpose the purpose the certificate chain will be used for
* @param peer the peer the certificate chain will be used with, or %NULL
* @param flags chain completion flags
* @param cancellable a #GCancellable or %NULL
* @returns whether the operation completed successfully
*/
build(
purpose: string,
peer: string | null,
flags: CertificateChainFlags | null,
cancellable?: Gio.Cancellable | null,
): boolean;
/**
* Complete a certificate chain. Once a certificate chain has been built
* its status can be examined.
*
* This will lookup missing certificates in PKCS#11
* modules and also that each certificate in the chain is the signer of the
* previous one. If a trust anchor, pinned certificate, or self-signed certificate
* is found, then the chain is considered built. Any extra certificates are
* removed from the chain.
*
* It's important to understand that building of a certificate chain does not
* constitute verifying that chain. This is merely the first step towards
* trust verification.
*
* The `purpose` is a string like %GCR_PURPOSE_CLIENT_AUTH and is the purpose
* for which the certificate chain will be used. Trust anchors are looked up
* for this purpose. This argument is required.
*
* The `peer` is usually the host name of the peer whith which this certificate
* chain is being used. It is used to look up pinned certificates that have
* been stored for this peer. If %NULL then no pinned certificates will
* be considered.
*
* If the %GCR_CERTIFICATE_CHAIN_NO_LOOKUPS flag is specified then no
* lookups for anchors or pinned certificates are done, and the resulting chain
* will be neither anchored or pinned. Additionally no missing certificate
* authorities are looked up in PKCS#11
*
* When the operation is finished, `callback` will be called. You can then call
* gcr_certificate_chain_build_finish() to get the result of the operation.
* @param purpose the purpose the certificate chain will be used for
* @param peer the peer the certificate chain will be used with, or %NULL
* @param flags chain completion flags
* @param cancellable a #GCancellable or %NULL
*/
build_async(
purpose: string,
peer: string | null,
flags: CertificateChainFlags | null,
cancellable?: Gio.Cancellable | null,
): Promise<boolean>;
/**
* Complete a certificate chain. Once a certificate chain has been built
* its status can be examined.
*
* This will lookup missing certificates in PKCS#11
* modules and also that each certificate in the chain is the signer of the
* previous one. If a trust anchor, pinned certificate, or self-signed certificate
* is found, then the chain is considered built. Any extra certificates are
* removed from the chain.
*
* It's important to understand that building of a certificate chain does not
* constitute verifying that chain. This is merely the first step towards
* trust verification.
*
* The `purpose` is a string like %GCR_PURPOSE_CLIENT_AUTH and is the purpose
* for which the certificate chain will be used. Trust anchors are looked up
* for this purpose. This argument is required.
*
* The `peer` is usually the host name of the peer whith which this certificate
* chain is being used. It is used to look up pinned certificates that have
* been stored for this peer. If %NULL then no pinned certificates will
* be considered.
*
* If the %GCR_CERTIFICATE_CHAIN_NO_LOOKUPS flag is specified then no
* lookups for anchors or pinned certificates are done, and the resulting chain
* will be neither anchored or pinned. Additionally no missing certificate
* authorities are looked up in PKCS#11
*
* When the operation is finished, `callback` will be called. You can then call
* gcr_certificate_chain_build_finish() to get the result of the operation.
* @param purpose the purpose the certificate chain will be used for
* @param peer the peer the certificate chain will be used with, or %NULL
* @param flags chain completion flags
* @param cancellable a #GCancellable or %NULL
* @param callback this will be called when the operation completes.
*/
build_async(
purpose: string,
peer: string | null,
flags: CertificateChainFlags | null,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete a certificate chain. Once a certificate chain has been built
* its status can be examined.
*
* This will lookup missing certificates in PKCS#11
* modules and also that each certificate in the chain is the signer of the
* previous one. If a trust anchor, pinned certificate, or self-signed certificate
* is found, then the chain is considered built. Any extra certificates are
* removed from the chain.
*
* It's important to understand that building of a certificate chain does not
* constitute verifying that chain. This is merely the first step towards
* trust verification.
*
* The `purpose` is a string like %GCR_PURPOSE_CLIENT_AUTH and is the purpose
* for which the certificate chain will be used. Trust anchors are looked up
* for this purpose. This argument is required.
*
* The `peer` is usually the host name of the peer whith which this certificate
* chain is being used. It is used to look up pinned certificates that have
* been stored for this peer. If %NULL then no pinned certificates will
* be considered.
*
* If the %GCR_CERTIFICATE_CHAIN_NO_LOOKUPS flag is specified then no
* lookups for anchors or pinned certificates are done, and the resulting chain
* will be neither anchored or pinned. Additionally no missing certificate
* authorities are looked up in PKCS#11
*
* When the operation is finished, `callback` will be called. You can then call
* gcr_certificate_chain_build_finish() to get the result of the operation.
* @param purpose the purpose the certificate chain will be used for
* @param peer the peer the certificate chain will be used with, or %NULL
* @param flags chain completion flags
* @param cancellable a #GCancellable or %NULL
* @param callback this will be called when the operation completes.
*/
build_async(
purpose: string,
peer: string | null,
flags: CertificateChainFlags | null,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<boolean> | void;
/**
* Finishes an asynchronous operation started by
* gcr_certificate_chain_build_async().
* @param result the #GAsyncResult passed to the callback
* @returns whether the operation succeeded
*/
build_finish(result: Gio.AsyncResult): boolean;
/**
* If the certificate chain has been built and is of status
* %GCR_CERTIFICATE_CHAIN_ANCHORED, then this will return the anchor
* certificate that was found. This is not necessarily a root certificate
* authority. If an intermediate certificate authority in the chain was
* found to be anchored, then that certificate will be returned.
*
* If an anchor is returned it does not mean that the certificate chain has
* been verified, but merely that an anchor has been found.
* @returns the anchor certificate, or %NULL if not anchored.
*/
get_anchor(): Certificate;
/**
* Get a certificate in the chain. It is an error to call this function
* with an invalid index.
* @param index index of the certificate to get
* @returns the certificate
*/
get_certificate(index: number): Certificate;
/**
* Get the endpoint certificate in the chain. This is always the first
* certificate in the chain. The endpoint certificate cannot be anchored.
* @returns the endpoint certificate, or %NULL if the chain is empty
*/
get_endpoint(): Certificate;
/**
* Get the length of the certificate chain.
* @returns the length of the certificate chain
*/
get_length(): number;
/**
* Get the status of a certificate chain. If the certificate chain has not
* been built, then the status will be %GCR_CERTIFICATE_CHAIN_UNKNOWN.
*
* A status of %GCR_CERTIFICATE_CHAIN_ANCHORED does not mean that the
* certificate chain has been verified, but merely that an anchor has been
* found.
* @returns the status of the certificate chain.
*/
get_status(): CertificateChainStatus;
}
namespace CertificateRequest {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
private_key: Gck.Object;
privateKey: Gck.Object;
}
}
/**
* An object that allows creation of certificate requests. A certificate
* request is sent to a certificate authority to request an X.509 certificate.
*
* Use [func`CertificateRequest`.prepare] to create a blank certificate
* request for a given private key. Set the common name on the certificate
* request with [method`CertificateRequest`.set_cn], and then sign the request
* with [method`CertificateRequest`.complete_async].
*/
class CertificateRequest extends GObject.Object {
static $gtype: GObject.GType<CertificateRequest>;
// Properties
/**
* The private key that this certificate request is for.
*/
get private_key(): Gck.Object;
/**
* The private key that this certificate request is for.
*/
get privateKey(): Gck.Object;
// Constructors
constructor(properties?: Partial<CertificateRequest.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
// Static methods
/**
* Check whether [class`CertificateRequest]` is capable of creating a request
* for the given `private_key`.
* @param private_key a private key
* @param cancellable cancellation object
*/
static capable(private_key: Gck.Object, cancellable?: Gio.Cancellable | null): boolean;
/**
* Asynchronously check whether [class`CertificateRequest]` is capable of
* creating a request for the given `private_key`.
* @param private_key a private key
* @param cancellable cancellation object
* @param callback will be called when the operation completes
*/
static capable_async(
private_key: Gck.Object,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<CertificateRequest> | null,
): void;
/**
* Get the result for asynchronously check whether [class`CertificateRequest]` is
* capable of creating a request for the given `private_key`.
* @param result asynchronous result
*/
static capable_finish(result: Gio.AsyncResult): boolean;
/**
* Create a new certificate request, in the given format for the private key.
* @param format the format for the certificate request
* @param private_key the private key the the certificate is being requested for
*/
static prepare(format: CertificateRequestFormat, private_key: Gck.Object): CertificateRequest;
// Methods
/**
* Complete and sign a certificate request, so that it can be encoded
* and sent to a certificate authority.
*
* This call may block as it signs the request using the private key.
* @param cancellable a cancellation object
* @returns whether certificate request was successfully completed or not
*/
complete(cancellable?: Gio.Cancellable | null): boolean;
/**
* Asynchronously complete and sign a certificate request, so that it can
* be encoded and sent to a certificate authority.
*
* This call will return immediately and complete later.
* @param cancellable a cancellation object
*/
complete_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
/**
* Asynchronously complete and sign a certificate request, so that it can
* be encoded and sent to a certificate authority.
*
* This call will return immediately and complete later.
* @param cancellable a cancellation object
* @param callback called when the operation completes
*/
complete_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Asynchronously complete and sign a certificate request, so that it can
* be encoded and sent to a certificate authority.
*
* This call will return immediately and complete later.
* @param cancellable a cancellation object
* @param callback called when the operation completes
*/
complete_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<boolean> | void;
/**
* Finish an asynchronous operation to complete and sign a certificate
* request.
* @param result result of the asynchronous operation
* @returns whether certificate request was successfully completed or not
*/
complete_finish(result: Gio.AsyncResult): boolean;
/**
* Encode the certificate request. It must have been completed with
* [method`CertificateRequest`.complete] or
* [method`CertificateRequest`.complete_async].
*
* If `textual` is %FALSE, the output is a DER encoded certificate request.
*
* If `textual` is %TRUE, the output is encoded as text. For PKCS#10 requests
* this is done using the OpenSSL style PEM encoding.
* @param textual whether to encode output as text
* @returns the encoded certificate request
*/
encode(textual: boolean): Uint8Array;
/**
* Get the format of this certificate request.
* @returns the format
*/
get_format(): CertificateRequestFormat;
/**
* Get the private key this certificate request is for.
* @returns the private key,
*/
get_private_key(): Gck.Object;
/**
* Set the common name encoded in the certificate request.
* @param cn common name to set on the request
*/
set_cn(cn: string): void;
}
namespace FilterCollection {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps, Collection.ConstructorProps {
underlying: Collection;
}
}
/**
* A collection which filters a [iface`Collection]`.
*
* An implementation of [iface`Collection]` which filters objects from another
* underlying collection. Use [ctor`FilterCollection`.new_with_callback]
* to create a new filter collection.
*
* The callback will determine the criteria for whether an object shows through
* the filter or not.
*/
class FilterCollection extends GObject.Object implements Collection {
static $gtype: GObject.GType<FilterCollection>;
// Properties
get underlying(): Collection;
// Constructors
constructor(properties?: Partial<FilterCollection.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static new_with_callback(underlying: Collection, callback?: FilterCollectionFunc | null): FilterCollection;
// Methods
/**
* Get the collection that is being filtered by this filter collection.
* @returns the underlying collection
*/
get_underlying(): Collection;
/**
* Refilter all objects in the underlying collection. Call this function if
* the filter callback function changes its filtering criteria.
*/
refilter(): void;
/**
* Set the callback used to filter the objects in the underlying collection.
* The callback should return %TRUE if an object should appear in the
* filtered collection.
*
* If a %NULL callback is set, then all underlynig objects will appear in the
* filtered collection.
*
* This will refilter the collection.
* @param callback function to call for each object
*/
set_callback(callback?: FilterCollectionFunc | null): void;
// Inherited methods
/**
* Check whether the collection contains an object or not.
* @param object object to check
* @returns whether the collection contains this object
*/
contains(object: GObject.Object): boolean;
/**
* Emit the #GcrCollection::added signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was added
*/
emit_added(object: GObject.Object): void;
/**
* Emit the #GcrCollection::removed signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was removed
*/
emit_removed(object: GObject.Object): void;
/**
* Get the number of objects in this collection.
* @returns The number of objects.
*/
get_length(): number;
/**
* Get a list of the objects in this collection.
* @returns a list of the objects in this collection, which should be freed with g_list_free()
*/
get_objects(): GObject.Object[];
vfunc_added(object: GObject.Object): void;
/**
* Check whether the collection contains an object or not.
* @param object object to check
*/
vfunc_contains(object: GObject.Object): boolean;
/**
* Get the number of objects in this collection.
*/
vfunc_get_length(): number;
/**
* Get a list of the objects in this collection.
*/
vfunc_get_objects(): GObject.Object[];
vfunc_removed(object: GObject.Object): void;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
namespace Parser {
// Signal callback interfaces
interface Authenticate {
(count: number): boolean;
}
interface Parsed {
(): void;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
parsed_attributes: Gck.Attributes;
parsedAttributes: Gck.Attributes;
parsed_description: string;
parsedDescription: string;
parsed_label: string;
parsedLabel: string;
}
}
/**
* A parser for parsing various types of files or data.
*
* A `GcrParser` can parse various certificate and key files such as OpenSSL
* PEM files, DER encoded certifictes, PKCS#8 keys and so on. Each various
* format is identified by a value in the [enum`DataFormat]` enumeration.
*
* In order to parse data, a new parser is created with gcr_parser_new() and
* then the [signal`Parser:`:authenticate] and [signal`Parser:`:parsed] signals
* should be connected to. Data is then fed to the parser via
* [method`Parser`.parse_data] or [method`Parser`.parse_stream].
*
* During the [signal`Parser:`:parsed] signal the attributes that make up the
* currently parsed item can be retrieved using the
* [method`Parser`.get_parsed_attributes] function.
*/
class Parser extends GObject.Object {
static $gtype: GObject.GType<Parser>;
// Properties
/**
* Get the attributes that make up the currently parsed item. This is
* generally only valid during a #GcrParser::parsed signal.
*/
get parsed_attributes(): Gck.Attributes;
/**
* Get the attributes that make up the currently parsed item. This is
* generally only valid during a #GcrParser::parsed signal.
*/
get parsedAttributes(): Gck.Attributes;
/**
* The description of the type of the currently parsed item. This is generally
* only valid during a #GcrParser::parsed signal.
*/
get parsed_description(): string;
/**
* The description of the type of the currently parsed item. This is generally
* only valid during a #GcrParser::parsed signal.
*/
get parsedDescription(): string;
/**
* The label of the currently parsed item. This is generally
* only valid during a #GcrParser::parsed signal.
*/
get parsed_label(): string;
/**
* The label of the currently parsed item. This is generally
* only valid during a #GcrParser::parsed signal.
*/
get parsedLabel(): string;
// Constructors
constructor(properties?: Partial<Parser.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): Parser;
// Signals
connect(id: string, callback: (...args: any[]) => any): number;
connect_after(id: string, callback: (...args: any[]) => any): number;
emit(id: string, ...args: any[]): void;
connect(signal: 'authenticate', callback: (_source: this, count: number) => boolean): number;
connect_after(signal: 'authenticate', callback: (_source: this, count: number) => boolean): number;
emit(signal: 'authenticate', count: number): void;
connect(signal: 'parsed', callback: (_source: this) => void): number;
connect_after(signal: 'parsed', callback: (_source: this) => void): number;
emit(signal: 'parsed'): void;
// Virtual methods
/**
* The default handler for the authenticate signal.
* @param count
*/
vfunc_authenticate(count: number): boolean;
/**
* The default handler for the parsed signal.
*/
vfunc_parsed(): void;
// Methods
/**
* Add a password to the set of passwords to try when parsing locked or encrypted
* items. This is usually called from the #GcrParser::authenticate signal.
* @param password a password to try
*/
add_password(password?: string | null): void;
/**
* Disable parsing of the given format. Use %GCR_FORMAT_ALL to disable all the formats.
* @param format The format identifier
*/
format_disable(format: DataFormat | null): void;
/**
* Enable parsing of the given format. Use %GCR_FORMAT_ALL to enable all the formats.
* @param format The format identifier
*/
format_enable(format: DataFormat | null): void;
/**
* Check whether the given format is supported by the parser.
* @param format The format identifier
* @returns Whether the format is supported.
*/
format_supported(format: DataFormat | null): boolean;
/**
* Get the filename of the parser item.
* @returns the filename set on the parser, or %NULL
*/
get_filename(): string;
/**
* Get the currently parsed item
* @returns the currently parsed item
*/
get_parsed(): Parsed;
/**
* Get the attributes which make up the currently parsed item. This is generally
* only valid during the #GcrParser::parsed signal.
* @returns the attributes for the current item, which are owned by the parser and should not be freed
*/
get_parsed_attributes(): Gck.Attributes | null;
/**
* Get the raw data block that represents this parsed object. This is only
* valid during the #GcrParser::parsed signal.
* @returns the raw data block of the currently parsed item; the value is owned by the parser and should not be freed
*/
get_parsed_block(): Uint8Array | null;
/**
* Get the raw data block that represents this parsed object. This is only
* valid during the #GcrParser::parsed signal.
* @returns the raw data block of the currently parsed item
*/
get_parsed_bytes(): GLib.Bytes;
/**
* Get a description for the type of the currently parsed item. This is generally
* only valid during the #GcrParser::parsed signal.
* @returns the description for the current item; this is owned by the parser and should not be freed
*/
get_parsed_description(): string | null;
/**
* Get the format of the raw data block that represents this parsed object.
* This corresponds with the data returned from gcr_parser_get_parsed_block().
*
* This is only valid during the #GcrParser::parsed signal.
* @returns the data format of the currently parsed item
*/
get_parsed_format(): DataFormat;
/**
* Get the label of the currently parsed item. This is generally only valid
* during the #GcrParser::parsed signal.
* @returns the label of the currently parsed item. The value is owned by the parser and should not be freed.
*/
get_parsed_label(): string | null;
/**
* Parse the data. The #GcrParser::parsed and #GcrParser::authenticate signals
* may fire during the parsing.
* @param data the data to parse
* @returns Whether the data was parsed successfully or not.
*/
parse_bytes(data: GLib.Bytes | Uint8Array): boolean;
/**
* Parse the data. The #GcrParser::parsed and #GcrParser::authenticate signals
* may fire during the parsing.
*
* A copy of the data will be made. Use gcr_parser_parse_bytes() to avoid this.
* @param data the data to parse
* @returns Whether the data was parsed successfully or not.
*/
parse_data(data: Uint8Array | string): boolean;
/**
* Parse items from the data in a #GInputStream. This function may block while
* reading from the input stream. Use gcr_parser_parse_stream_async() for
* a non-blocking variant.
*
* The #GcrParser::parsed and #GcrParser::authenticate signals
* may fire during the parsing.
* @param input The input stream
* @param cancellable An optional cancellation object
* @returns Whether the parsing completed successfully or not.
*/
parse_stream(input: Gio.InputStream, cancellable?: Gio.Cancellable | null): boolean;
/**
* Parse items from the data in a #GInputStream. This function completes
* asyncronously and doesn't block.
*
* The #GcrParser::parsed and #GcrParser::authenticate signals
* may fire during the parsing.
* @param input The input stream
* @param cancellable An optional cancellation object
*/
parse_stream_async(input: Gio.InputStream, cancellable?: Gio.Cancellable | null): Promise<boolean>;
/**
* Parse items from the data in a #GInputStream. This function completes
* asyncronously and doesn't block.
*
* The #GcrParser::parsed and #GcrParser::authenticate signals
* may fire during the parsing.
* @param input The input stream
* @param cancellable An optional cancellation object
* @param callback Called when the operation result is ready.
*/
parse_stream_async(
input: Gio.InputStream,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Parse items from the data in a #GInputStream. This function completes
* asyncronously and doesn't block.
*
* The #GcrParser::parsed and #GcrParser::authenticate signals
* may fire during the parsing.
* @param input The input stream
* @param cancellable An optional cancellation object
* @param callback Called when the operation result is ready.
*/
parse_stream_async(
input: Gio.InputStream,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<boolean> | void;
/**
* Complete an operation to parse a stream.
* @param result The operation result
* @returns Whether the parsing completed successfully or not.
*/
parse_stream_finish(result: Gio.AsyncResult): boolean;
/**
* Sets the filename of the parser item.
* @param filename a string of the filename of the parser item
*/
set_filename(filename?: string | null): void;
}
namespace Pkcs11Certificate {
// Constructor properties interface
interface ConstructorProps
extends Gck.Object.ConstructorProps,
Certificate.ConstructorProps,
Comparable.ConstructorProps {
attributes: Gck.Attributes;
}
}
/**
* A certificate loaded from a PKCS#11 storage.
* It is also a valid [class`Gck`.Object] and can be used as such.
*
* Use gcr_pkcs11_certificate_lookup_issuer() to lookup the issuer of a given
* certificate in the PKCS#11 store.
*
* Various common PKCS#11 certificate attributes are automatically loaded and
* are available via gcr_pkcs11_certificate_get_attributes().
*/
class Pkcs11Certificate extends Gck.Object implements Certificate, Comparable {
static $gtype: GObject.GType<Pkcs11Certificate>;
// Properties
/**
* Automatically loaded attributes for this certificate.
*/
get attributes(): Gck.Attributes;
// Constructors
constructor(properties?: Partial<Pkcs11Certificate.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
// Static methods
/**
* Lookup a the issuer of a `certificate` in the PKCS#11 storage. The
* lookup is done using the issuer DN of the certificate. No certificate chain
* verification is done. Use a crypto library to make trust decisions.
*
* This call may block, see gcr_pkcs11_certificate_lookup_issuer() for the
* non-blocking version.
*
* Will return %NULL if no issuer certificate is found. Use `error` to determine
* if an error occurred.
* @param certificate a #GcrCertificate
* @param cancellable a #GCancellable
*/
static lookup_issuer(certificate: Certificate, cancellable?: Gio.Cancellable | null): Certificate;
/**
* Lookup a the issuer of a `certificate` in the PKCS#11 storage. The
* lookup is done using the issuer DN of the certificate. No certificate chain
* verification is done. Use a crypto library to make trust decisions.
*
* When the operation is finished, callback will be called. You can then call
* gcr_pkcs11_certificate_lookup_issuer_finish() to get the result of the
* operation.
* @param certificate a #GcrCertificate
* @param cancellable a #GCancellable
* @param callback a #GAsyncReadyCallback to call when the operation completes
*/
static lookup_issuer_async(
certificate: Certificate,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<Pkcs11Certificate> | null,
): void;
/**
* Finishes an asynchronous operation started by
* gcr_pkcs11_certificate_lookup_issuer_async().
*
* Will return %NULL if no issuer certificate is found. Use `error` to determine
* if an error occurred.
* @param result the #GAsyncResult passed to the callback
*/
static lookup_issuer_finish(result: Gio.AsyncResult): Certificate;
// Methods
/**
* Access the automatically loaded attributes for this certificate.
* @returns the certificate attributes
*/
get_attributes(): Gck.Attributes;
// Inherited properties
/**
* A readable description for this certificate
*/
get description(): string;
/**
* The expiry date of the certificate
*/
get expiry(): GLib.Date;
/**
* An icon representing the certificate
*/
get icon(): Gio.Icon;
/**
* Common name part of the certificate issuer
*/
get issuer(): string;
/**
* A readable label for this certificate.
*/
get label(): string;
/**
* GLib markup to describe the certificate
*/
get markup(): string;
/**
* Common name part of the certificate subject
*/
get subject(): string;
// Inherited methods
/**
* Get the basic constraints for the certificate if present. If %FALSE is
* returned then no basic constraints are present and the `is_ca` and
* `path_len` arguments are not changed.
* @returns whether basic constraints are present or not
*/
get_basic_constraints(): [boolean, boolean, number];
/**
* Gets the raw DER data for an X.509 certificate.
* @returns raw DER data of the X.509 certificate
*/
get_der_data(): Uint8Array;
/**
* Get the expiry date of this certificate.
*
* The #GDate returned should be freed by the caller using
* g_date_free() when no longer required.
* @returns An allocated expiry date of this certificate.
*/
get_expiry_date(): GLib.Date;
/**
* Calculate the fingerprint for this certificate.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @param type the type of algorithm for the fingerprint.
* @returns the raw binary fingerprint
*/
get_fingerprint(type: GLib.ChecksumType | null): Uint8Array;
/**
* Calculate the fingerprint for this certificate, and return it
* as a hex string.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @param type the type of algorithm for the fingerprint.
* @returns an allocated hex string which contains the fingerprint.
*/
get_fingerprint_hex(type: GLib.ChecksumType | null): string;
/**
* Get the issued date of this certificate.
*
* The #GDate returned should be freed by the caller using
* g_date_free() when no longer required.
* @returns An allocated issued date of this certificate.
*/
get_issued_date(): GLib.Date;
/**
* Get the common name of the issuer of this certificate.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated issuer CN, or %NULL if no issuer CN present.
*/
get_issuer_cn(): string;
/**
* Get the full issuer DN of the certificate as a (mostly)
* readable string.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated issuer DN of the certificate.
*/
get_issuer_dn(): string;
/**
* Get a name to represent the issuer of this certificate.
*
* This will try to lookup the common name, orianizational unit,
* organization in that order.
* @returns the allocated issuer name, or %NULL if no issuer name
*/
get_issuer_name(): string;
/**
* Get a part of the DN of the issuer of this certificate.
*
* Examples of a `part` might be the 'OU' (organizational unit)
* or the 'CN' (common name). Only the value of that part
* of the DN is returned.
*
* The string returned should be freed by the caller when no longer
* required.
* @param part a DN type string or OID.
* @returns the allocated part of the issuer DN, or %NULL if no such part is present
*/
get_issuer_part(part: string): string | null;
/**
* Get the raw DER data for the issuer DN of the certificate.
*
* The data should be freed by using g_free() when no longer required.
* @returns allocated memory containing the raw issuer
*/
get_issuer_raw(): Uint8Array;
/**
* Get the key size in bits of the public key represented
* by this certificate.
* @returns The key size of the certificate.
*/
get_key_size(): number;
/**
* Calculate a GMarkup string for displaying this certificate.
* @returns the markup string
*/
get_markup_text(): string;
/**
* Get the raw binary serial number of the certificate.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @returns the raw binary serial number.
*/
get_serial_number(): Uint8Array;
/**
* Get the serial number of the certificate as a hex string.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @returns an allocated string containing the serial number as hex.
*/
get_serial_number_hex(): string;
/**
* Get the common name of the subject of this certificate.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated subject CN, or %NULL if no subject CN present.
*/
get_subject_cn(): string;
/**
* Get the full subject DN of the certificate as a (mostly)
* readable string.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated subject DN of the certificate.
*/
get_subject_dn(): string;
/**
* Get a name to represent the subject of this certificate.
*
* This will try to lookup the common name, orianizational unit,
* organization in that order.
* @returns the allocated subject name, or %NULL if no subject name
*/
get_subject_name(): string;
/**
* Get a part of the DN of the subject of this certificate.
*
* Examples of a `part` might be the 'OU' (organizational unit)
* or the 'CN' (common name). Only the value of that part
* of the DN is returned.
*
* The string returned should be freed by the caller when no longer
* required.
* @param part a DN type string or OID.
* @returns the allocated part of the subject DN, or %NULL if no such part is present.
*/
get_subject_part(part: string): string | null;
/**
* Get the raw DER data for the subject DN of the certificate.
*
* The data should be freed by using g_free() when no longer required.
* @returns allocated memory containing the raw subject
*/
get_subject_raw(): Uint8Array;
/**
* Check if `issuer` could be the issuer of this certificate. This is done by
* comparing the relevant subject and issuer fields. No signature check is
* done. Proper verification of certificates must be done via a crypto
* library.
* @param issuer a possible issuer #GcrCertificate
* @returns whether @issuer could be the issuer of the certificate.
*/
is_issuer(issuer: Certificate): boolean;
/**
* Implementers of the #GcrCertificate mixin should call this function to notify
* when the certificate has changed to emit notifications on the various
* properties.
*/
mixin_emit_notify(): void;
/**
* Gets the raw DER data for an X.509 certificate.
*/
vfunc_get_der_data(): Uint8Array;
/**
* Compare whether two objects represent the same thing. The return value can
* also be used to sort the objects.
* @param other Another comparable object
* @returns Zero if the two objects represent the same thing, non-zero if not.
*/
compare(other?: Comparable | null): number;
/**
* Compare whether two objects represent the same thing. The return value can
* also be used to sort the objects.
* @param other Another comparable object
*/
vfunc_compare(other?: Comparable | null): number;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
// Conflicted with Gck.Object.get_data
get_data(...args: never[]): any;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
// Conflicted with Gck.Object.set
set(...args: never[]): any;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
namespace SecretExchange {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
protocol: string;
}
}
/**
* Allows exchange of secrets between two processes on the same system without
* exposing those secrets to things like loggers, non-pageable memory etc.
*
* This does not protect against active attacks like MITM attacks.
*
* Each side creates a secret exchange object, and one of the sides calls
* [method`SecretExchange`.begin]. This creates a string, which should be passed
* to the other side. Each side passes the strings it receives into
* [method`SecretExchange`.receive].
*
* In order to send a reply (either with or without a secret) use
* [method`SecretExchange`.send]. A side must have successfully called
* [method`SecretExchange`.receive] before it can use
* [method`SecretExchange`.send].
*
* The secret exchange objects can be used for multiple iterations of the
* conversation, or for just one request/reply. The only limitation being that
* the initial request cannot contain a secret.
*
* Caveat: Information about the approximate length (rounded up to the nearest
* 16 bytes) may be leaked. If this is considered inacceptable, do not use
* [class`SecretExchange]`.
*/
class SecretExchange extends GObject.Object {
static $gtype: GObject.GType<SecretExchange>;
// Properties
/**
* The protocol being used for the exchange.
*
* Will be %NULL if no protocol was specified when creating this object,
* and either [method`SecretExchange`.begin] or [method`SecretExchange`.receive]
* have not been called successfully.
*/
get protocol(): string;
// Constructors
constructor(properties?: Partial<SecretExchange.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](protocol?: string | null): SecretExchange;
// Virtual methods
vfunc_derive_transport_key(peer: number, n_peer: number): boolean;
vfunc_generate_exchange_key(scheme: string, public_key: number, n_public_key: number): boolean;
// Methods
/**
* Begin the secret exchange. The resulting string should be sent to the other
* side of the exchange. The other side should use [method`SecretExchange`.receive]
* to process the string.
* @returns A newly allocated string to be sent to the other side of the secret exchange
*/
begin(): string;
/**
* Will return %NULL if no protocol was specified, and either
* [method`SecretExchange`.begin] or [method`SecretExchange`.receive] have not
* been called successfully.
* @returns the protocol or %NULL
*/
get_protocol(): string;
/**
* Returns the last secret received. If no secret has yet been received this
* will return %NULL. The string is owned by the #GcrSecretExchange object
* and will be valid until the next time that gcr_secret_exchange_receive()
* is called on this object, or the object is destroyed.
*
* Depending on the secret passed into the other side of the secret exchange,
* the result may be a binary string. It does however have a null terminator,
* so if you're certain that it is does not contain arbitrary binary data,
* it can be used as a string.
* @returns the last secret received
*/
get_secret(): string[];
/**
* Receive a string from the other side of secret exchange. This string will
* have been created by [method`SecretExchange`.begin] or
* [method`SecretExchange`.send].
*
* After this call completes successfully the value returned from
* gcr_secret_exchange_get_secret() will have changed.
* @param exchange the string received
* @returns whether the string was successfully parsed and received
*/
receive(exchange: string): boolean;
/**
* Send a reply to the other side of the secret exchange, optionally sending a
* secret.
*
* [method`SecretExchange`.receive] must have been successfully called at least
* once on this object. In other words this object must have received data
* from the other side of the secret exchange, before we can send a secret.
* @param secret optionally, a secret to send to the other side
* @param secret_len length of @secret, or -1 if null terminated
* @returns a newly allocated string to be sent to the other side of the secret exchange
*/
send(secret: string | null, secret_len: number): string;
}
namespace SimpleCertificate {
// Constructor properties interface
interface ConstructorProps
extends GObject.Object.ConstructorProps,
Certificate.ConstructorProps,
Comparable.ConstructorProps {}
}
/**
* An implementation of [iface`Certificate]` which loads a certificate from DER
* data already located in memory.
*
* To create an object, use the [ctor`SimpleCertificate`.new] or
* [ctor`SimpleCertificate`.new_static] functions.
*/
class SimpleCertificate extends GObject.Object implements Certificate, Comparable {
static $gtype: GObject.GType<SimpleCertificate>;
// Constructors
constructor(properties?: Partial<SimpleCertificate.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](data: Uint8Array | string): SimpleCertificate;
// Inherited properties
/**
* A readable description for this certificate
*/
get description(): string;
/**
* The expiry date of the certificate
*/
get expiry(): GLib.Date;
/**
* An icon representing the certificate
*/
get icon(): Gio.Icon;
/**
* Common name part of the certificate issuer
*/
get issuer(): string;
/**
* A readable label for this certificate.
*/
get label(): string;
/**
* GLib markup to describe the certificate
*/
get markup(): string;
/**
* Common name part of the certificate subject
*/
get subject(): string;
// Inherited methods
/**
* Get the basic constraints for the certificate if present. If %FALSE is
* returned then no basic constraints are present and the `is_ca` and
* `path_len` arguments are not changed.
* @returns whether basic constraints are present or not
*/
get_basic_constraints(): [boolean, boolean, number];
/**
* Gets the raw DER data for an X.509 certificate.
* @returns raw DER data of the X.509 certificate
*/
get_der_data(): Uint8Array;
/**
* Get the expiry date of this certificate.
*
* The #GDate returned should be freed by the caller using
* g_date_free() when no longer required.
* @returns An allocated expiry date of this certificate.
*/
get_expiry_date(): GLib.Date;
/**
* Calculate the fingerprint for this certificate.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @param type the type of algorithm for the fingerprint.
* @returns the raw binary fingerprint
*/
get_fingerprint(type: GLib.ChecksumType | null): Uint8Array;
/**
* Calculate the fingerprint for this certificate, and return it
* as a hex string.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @param type the type of algorithm for the fingerprint.
* @returns an allocated hex string which contains the fingerprint.
*/
get_fingerprint_hex(type: GLib.ChecksumType | null): string;
/**
* Get the issued date of this certificate.
*
* The #GDate returned should be freed by the caller using
* g_date_free() when no longer required.
* @returns An allocated issued date of this certificate.
*/
get_issued_date(): GLib.Date;
/**
* Get the common name of the issuer of this certificate.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated issuer CN, or %NULL if no issuer CN present.
*/
get_issuer_cn(): string;
/**
* Get the full issuer DN of the certificate as a (mostly)
* readable string.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated issuer DN of the certificate.
*/
get_issuer_dn(): string;
/**
* Get a name to represent the issuer of this certificate.
*
* This will try to lookup the common name, orianizational unit,
* organization in that order.
* @returns the allocated issuer name, or %NULL if no issuer name
*/
get_issuer_name(): string;
/**
* Get a part of the DN of the issuer of this certificate.
*
* Examples of a `part` might be the 'OU' (organizational unit)
* or the 'CN' (common name). Only the value of that part
* of the DN is returned.
*
* The string returned should be freed by the caller when no longer
* required.
* @param part a DN type string or OID.
* @returns the allocated part of the issuer DN, or %NULL if no such part is present
*/
get_issuer_part(part: string): string | null;
/**
* Get the raw DER data for the issuer DN of the certificate.
*
* The data should be freed by using g_free() when no longer required.
* @returns allocated memory containing the raw issuer
*/
get_issuer_raw(): Uint8Array;
/**
* Get the key size in bits of the public key represented
* by this certificate.
* @returns The key size of the certificate.
*/
get_key_size(): number;
/**
* Calculate a GMarkup string for displaying this certificate.
* @returns the markup string
*/
get_markup_text(): string;
/**
* Get the raw binary serial number of the certificate.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @returns the raw binary serial number.
*/
get_serial_number(): Uint8Array;
/**
* Get the serial number of the certificate as a hex string.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @returns an allocated string containing the serial number as hex.
*/
get_serial_number_hex(): string;
/**
* Get the common name of the subject of this certificate.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated subject CN, or %NULL if no subject CN present.
*/
get_subject_cn(): string;
/**
* Get the full subject DN of the certificate as a (mostly)
* readable string.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated subject DN of the certificate.
*/
get_subject_dn(): string;
/**
* Get a name to represent the subject of this certificate.
*
* This will try to lookup the common name, orianizational unit,
* organization in that order.
* @returns the allocated subject name, or %NULL if no subject name
*/
get_subject_name(): string;
/**
* Get a part of the DN of the subject of this certificate.
*
* Examples of a `part` might be the 'OU' (organizational unit)
* or the 'CN' (common name). Only the value of that part
* of the DN is returned.
*
* The string returned should be freed by the caller when no longer
* required.
* @param part a DN type string or OID.
* @returns the allocated part of the subject DN, or %NULL if no such part is present.
*/
get_subject_part(part: string): string | null;
/**
* Get the raw DER data for the subject DN of the certificate.
*
* The data should be freed by using g_free() when no longer required.
* @returns allocated memory containing the raw subject
*/
get_subject_raw(): Uint8Array;
/**
* Check if `issuer` could be the issuer of this certificate. This is done by
* comparing the relevant subject and issuer fields. No signature check is
* done. Proper verification of certificates must be done via a crypto
* library.
* @param issuer a possible issuer #GcrCertificate
* @returns whether @issuer could be the issuer of the certificate.
*/
is_issuer(issuer: Certificate): boolean;
/**
* Implementers of the #GcrCertificate mixin should call this function to notify
* when the certificate has changed to emit notifications on the various
* properties.
*/
mixin_emit_notify(): void;
/**
* Gets the raw DER data for an X.509 certificate.
*/
vfunc_get_der_data(): Uint8Array;
/**
* Compare whether two objects represent the same thing. The return value can
* also be used to sort the objects.
* @param other Another comparable object
* @returns Zero if the two objects represent the same thing, non-zero if not.
*/
compare(other?: Comparable | null): number;
/**
* Compare whether two objects represent the same thing. The return value can
* also be used to sort the objects.
* @param other Another comparable object
*/
vfunc_compare(other?: Comparable | null): number;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
namespace SimpleCollection {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps, Collection.ConstructorProps {}
}
/**
* A simple implementation of [iface`Collection]`, which you can add and remove
* objects from.
*
* You can use [method`SimpleCollection`.add] to add objects, and
* [method`SimpleCollection`.remove] to remove them again.
*/
class SimpleCollection extends GObject.Object implements Collection {
static $gtype: GObject.GType<SimpleCollection>;
// Constructors
constructor(properties?: Partial<SimpleCollection.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): SimpleCollection;
// Methods
/**
* Add an object to this collection
* @param object The object to add
*/
add(object: GObject.Object): void;
/**
* Remove an object from the collection.
* @param object The object to remove from the collection
*/
remove(object: GObject.Object): void;
// Inherited methods
/**
* Check whether the collection contains an object or not.
* @param object object to check
* @returns whether the collection contains this object
*/
contains(object: GObject.Object): boolean;
/**
* Emit the #GcrCollection::added signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was added
*/
emit_added(object: GObject.Object): void;
/**
* Emit the #GcrCollection::removed signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was removed
*/
emit_removed(object: GObject.Object): void;
/**
* Get the number of objects in this collection.
* @returns The number of objects.
*/
get_length(): number;
/**
* Get a list of the objects in this collection.
* @returns a list of the objects in this collection, which should be freed with g_list_free()
*/
get_objects(): GObject.Object[];
vfunc_added(object: GObject.Object): void;
/**
* Check whether the collection contains an object or not.
* @param object object to check
*/
vfunc_contains(object: GObject.Object): boolean;
/**
* Get the number of objects in this collection.
*/
vfunc_get_length(): number;
/**
* Get a list of the objects in this collection.
*/
vfunc_get_objects(): GObject.Object[];
vfunc_removed(object: GObject.Object): void;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
namespace SshAskpass {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
interaction: Gio.TlsInteraction;
}
}
/**
* When used as the setup function while spawning an ssh command like ssh-add
* or ssh, this allows callbacks for passwords on the provided interaction.
*/
class SshAskpass extends GObject.Object {
static $gtype: GObject.GType<SshAskpass>;
// Properties
/**
* The interaction used to prompt for passwords.
*/
get interaction(): Gio.TlsInteraction;
// Constructors
constructor(properties?: Partial<SshAskpass.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](interaction: Gio.TlsInteraction): SshAskpass;
// Static methods
/**
* Use this function as a callback setup function passed to g_spawn_sync(),
* g_spawn_async(), g_spawn_async_with_pipes().
* @param askpass a #GcrSshAskpass object
*/
static child_setup(askpass?: any | null): void;
// Methods
/**
* Get the interaction associated with this object.
* @returns the interaction
*/
get_interaction(): Gio.TlsInteraction;
}
namespace SystemPrompt {
// Constructor properties interface
interface ConstructorProps
extends GObject.Object.ConstructorProps,
Prompt.ConstructorProps,
Gio.AsyncInitable.ConstructorProps,
Gio.Initable.ConstructorProps {
bus_name: string;
busName: string;
secret_exchange: SecretExchange;
secretExchange: SecretExchange;
timeout_seconds: number;
timeoutSeconds: number;
}
}
/**
* A [iface`Prompt]` implementation which calls to the system prompter to
* display prompts in a system modal fashion.
*
* Since the system prompter usually only displays one prompt at a time, you
* may have to wait for the prompt to be displayed. Use [func`SystemPrompt`.open]
* or a related function to open a prompt. Since this can take a long time, you
* should always check that the prompt is still needed after it is opened. A
* previous prompt may have already provided the information needed and you
* may no longer need to prompt.
*
* Use [method`SystemPrompt`.close] to close the prompt when you're done with it.
*/
class SystemPrompt extends GObject.Object implements Prompt, Gio.AsyncInitable<SystemPrompt>, Gio.Initable {
static $gtype: GObject.GType<SystemPrompt>;
// Properties
/**
* The DBus bus name of the prompter to use for prompting, or %NULL
* for the default prompter.
*/
get bus_name(): string;
/**
* The DBus bus name of the prompter to use for prompting, or %NULL
* for the default prompter.
*/
get busName(): string;
/**
* The #GcrSecretExchange to use when transferring passwords. A default
* secret exchange will be used if this is not set.
*/
get secret_exchange(): SecretExchange;
set secret_exchange(val: SecretExchange);
/**
* The #GcrSecretExchange to use when transferring passwords. A default
* secret exchange will be used if this is not set.
*/
get secretExchange(): SecretExchange;
set secretExchange(val: SecretExchange);
/**
* The timeout in seconds to wait when opening the prompt.
*/
set timeout_seconds(val: number);
/**
* The timeout in seconds to wait when opening the prompt.
*/
set timeoutSeconds(val: number);
// Constructors
constructor(properties?: Partial<SystemPrompt.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
// Static methods
static error_get_domain(): GLib.Quark;
/**
* Opens a system prompt with the default prompter.
*
* Most system prompters only allow showing one prompt at a time, and if
* another prompt is shown then this method will block for up to
* `timeout_seconds` seconds. If `timeout_seconds` is equal to -1, then this
* will block indefinitely until the prompt can be opened. If `timeout_seconds`
* expires, then this function will fail with a %GCR_SYSTEM_PROMPT_IN_PROGRESS
* error.
* @param timeout_seconds the number of seconds to wait to access the prompt, or -1
* @param cancellable optional cancellation object
*/
static open(timeout_seconds: number, cancellable?: Gio.Cancellable | null): SystemPrompt;
/**
* Asynchronously open a system prompt with the default system prompter.
*
* Most system prompters only allow showing one prompt at a time, and if
* another prompt is shown then this method will block for up to
* `timeout_seconds` seconds. If `timeout_seconds` is equal to -1, then this
* will block indefinitely until the prompt can be opened. If `timeout_seconds`
* expires, then this operation will fail with a %GCR_SYSTEM_PROMPT_IN_PROGRESS
* error.
* @param timeout_seconds the number of seconds to wait to access the prompt, or -1
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
static open_async(
timeout_seconds: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<SystemPrompt> | null,
): void;
/**
* Complete an operation to asynchronously open a system prompt.
* @param result the asynchronous result
*/
static open_finish(result: Gio.AsyncResult): SystemPrompt;
/**
* Opens a system prompt. If prompter_name is %NULL, then the default
* system prompter is used.
*
* Most system prompters only allow showing one prompt at a time, and if
* another prompt is shown then this method will block for up to
* `timeout_seconds` seconds. If `timeout_seconds` is equal to -1, then this
* will block indefinitely until the prompt can be opened. If `timeout_seconds`
* expires, then this function will fail with a %GCR_SYSTEM_PROMPT_IN_PROGRESS
* error.
* @param prompter_name the prompter dbus name
* @param timeout_seconds the number of seconds to wait to access the prompt, or -1
* @param cancellable optional cancellation object
*/
static open_for_prompter(
prompter_name: string | null,
timeout_seconds: number,
cancellable?: Gio.Cancellable | null,
): SystemPrompt;
/**
* Opens a system prompt asynchronously. If prompter_name is %NULL, then the
* default system prompter is used.
*
* Most system prompters only allow showing one prompt at a time, and if
* another prompt is shown then this method will block for up to
* `timeout_seconds` seconds. If `timeout_seconds` is equal to -1, then this
* will block indefinitely until the prompt can be opened. If `timeout_seconds`
* expires, then this operation will fail with a %GCR_SYSTEM_PROMPT_IN_PROGRESS
* error.
* @param prompter_name the prompter D-Bus name
* @param timeout_seconds the number of seconds to wait to access the prompt, or -1
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
static open_for_prompter_async(
prompter_name: string | null,
timeout_seconds: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<SystemPrompt> | null,
): void;
// Methods
/**
* Close this prompt. After calling this function, no further prompts will
* succeed on this object. The prompt object is not unreferenced by this
* function, and you must unreference it once done.
*
* This call may block, use the gcr_system_prompt_close_async() to perform
* this action indefinitely.
*
* Whether or not this function returns %TRUE, the system prompt object is
* still closed and may not be further used.
* @param cancellable an optional cancellation object
* @returns whether close was cleanly completed
*/
close(cancellable?: Gio.Cancellable | null): boolean;
// Conflicted with Gcr.Prompt.close
close(...args: never[]): any;
/**
* Close this prompt asynchronously. After calling this function, no further
* methods may be called on this object. The prompt object is not unreferenced
* by this function, and you must unreference it once done.
*
* This call returns immediately and completes asynchronously.
* @param cancellable an optional cancellation object
*/
close_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
/**
* Close this prompt asynchronously. After calling this function, no further
* methods may be called on this object. The prompt object is not unreferenced
* by this function, and you must unreference it once done.
*
* This call returns immediately and completes asynchronously.
* @param cancellable an optional cancellation object
* @param callback called when the operation completes
*/
close_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Close this prompt asynchronously. After calling this function, no further
* methods may be called on this object. The prompt object is not unreferenced
* by this function, and you must unreference it once done.
*
* This call returns immediately and completes asynchronously.
* @param cancellable an optional cancellation object
* @param callback called when the operation completes
*/
close_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<boolean> | void;
/**
* Complete operation to close this prompt.
*
* Whether or not this function returns %TRUE, the system prompt object is
* still closed and may not be further used.
* @param result asynchronous operation result
* @returns whether close was cleanly completed
*/
close_finish(result: Gio.AsyncResult): boolean;
/**
* Get the current [class`SecretExchange]` used to transfer secrets in this prompt.
* @returns the secret exchange
*/
get_secret_exchange(): SecretExchange;
// Inherited properties
/**
* The string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
*
* In X11, this will be a stringified version of the XWindow handle; in
* Wayland this is the result of an export using the XDG foreign
* protocol.
*/
get caller_window(): string;
set caller_window(val: string);
/**
* The string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
*
* In X11, this will be a stringified version of the XWindow handle; in
* Wayland this is the result of an export using the XDG foreign
* protocol.
*/
get callerWindow(): string;
set callerWindow(val: string);
/**
* The label for the cancel button in the prompt.
*/
get cancel_label(): string;
set cancel_label(val: string);
/**
* The label for the cancel button in the prompt.
*/
get cancelLabel(): string;
set cancelLabel(val: string);
/**
* Whether the additional choice is chosen or not.
*
* The additional choice would have been setup using #GcrPrompt:choice-label.
*/
get choice_chosen(): boolean;
set choice_chosen(val: boolean);
/**
* Whether the additional choice is chosen or not.
*
* The additional choice would have been setup using #GcrPrompt:choice-label.
*/
get choiceChosen(): boolean;
set choiceChosen(val: boolean);
/**
* The label for the additional choice.
*
* If this is a non-%NULL value then an additional boolean choice will be
* displayed by the prompt allowing the user to select or deselect it.
*
* If %NULL, then no additional choice is displayed.
*
* The initial value of the choice can be set with #GcrPrompt:choice-chosen.
*/
get choice_label(): string;
set choice_label(val: string);
/**
* The label for the additional choice.
*
* If this is a non-%NULL value then an additional boolean choice will be
* displayed by the prompt allowing the user to select or deselect it.
*
* If %NULL, then no additional choice is displayed.
*
* The initial value of the choice can be set with #GcrPrompt:choice-chosen.
*/
get choiceLabel(): string;
set choiceLabel(val: string);
/**
* The label for the continue button in the prompt.
*/
get continue_label(): string;
set continue_label(val: string);
/**
* The label for the continue button in the prompt.
*/
get continueLabel(): string;
set continueLabel(val: string);
/**
* The detailed description of the prompt.
*
* A prompt implementation may choose not to display this detailed description.
* The prompt message should contain relevant information.
*/
get description(): string;
set description(val: string);
/**
* The prompt message for the user.
*
* A prompt implementation should always display this message.
*/
get message(): string;
set message(val: string);
/**
* Whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
*/
get password_new(): boolean;
set password_new(val: boolean);
/**
* Whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
*/
get passwordNew(): boolean;
set passwordNew(val: boolean);
/**
* Indication of the password strength.
*
* Prompts will return a zero value if the password is empty, and a value
* greater than zero if the password has any characters.
*
* This is only valid after a successful prompt for a password.
*/
get password_strength(): number;
/**
* Indication of the password strength.
*
* Prompts will return a zero value if the password is empty, and a value
* greater than zero if the password has any characters.
*
* This is only valid after a successful prompt for a password.
*/
get passwordStrength(): number;
/**
* The title of the prompt.
*
* A prompt implementation may choose not to display the prompt title. The
* #GcrPrompt:message should contain relevant information.
*/
get title(): string;
set title(val: string);
/**
* A prompt warning displayed on the prompt, or %NULL for no warning.
*
* This is a warning like "The password is incorrect." usually displayed to the
* user about a previous 'unsuccessful' prompt.
*/
get warning(): string;
set warning(val: string);
// Inherited methods
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this function to
* represent the question correctly.
*
* This method will block until the a response is returned from the prompter.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the reply from the prompt
*/
confirm(cancellable?: Gio.Cancellable | null): PromptReply;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
*/
confirm_async(cancellable?: Gio.Cancellable | null): Promise<PromptReply>;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
confirm_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
confirm_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<PromptReply> | void;
/**
* Complete an operation to prompt for confirmation.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param result asynchronous result passed to callback
* @returns the reply from the prompt
*/
confirm_finish(result: Gio.AsyncResult): PromptReply;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this function to
* represent the question correctly.
*
* This method will block until the a response is returned from the prompter
* and will run a main loop similar to a `gtk_dialog_run()`. The application
* will remain responsive but care must be taken to handle reentrancy issues.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the reply from the prompt
*/
confirm_run(cancellable?: Gio.Cancellable | null): PromptReply;
/**
* Get the string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
* @returns a newly allocated string containing the string handle of the window.
*/
get_caller_window(): string;
/**
* Get the label for the cancel button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CANCEL reply
* from the prompt.
* @returns a newly allocated string containing the label
*/
get_cancel_label(): string;
/**
* Get whether the additional choice was chosen or not.
*
* The additional choice would have been setup using
* gcr_prompt_set_choice_label().
* @returns whether chosen
*/
get_choice_chosen(): boolean;
/**
* Get the label for the additional choice.
*
* This will be %NULL if no additional choice is being displayed.
* @returns a newly allocated string containing the additional choice or %NULL
*/
get_choice_label(): string;
/**
* Get the label for the continue button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CONTINUE reply
* from the prompt.
* @returns a newly allocated string containing the label
*/
get_continue_label(): string;
/**
* Get the detailed description of the prompt.
*
* A prompt implementation may choose not to display this detailed description.
* The prompt message should contain relevant information.
* @returns a newly allocated string containing the detailed description of the prompt
*/
get_description(): string;
/**
* Gets the prompt message for the user.
*
* A prompt implementation should always display this message.
* @returns a newly allocated string containing the detailed description of the prompt
*/
get_message(): string;
/**
* Get whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
* @returns whether in new password mode or not
*/
get_password_new(): boolean;
/**
* Get indication of the password strength.
*
* Prompts will return a zero value if the password is empty, and a value
* greater than zero if the password has any characters.
*
* This is only valid after a successful prompt for a password.
* @returns zero if the password is empty, greater than zero if not
*/
get_password_strength(): number;
/**
* Gets the title of the prompt.
*
* A prompt implementation may choose not to display the prompt title. The
* prompt message should contain relevant information.
* @returns a newly allocated string containing the prompt title.
*/
get_title(): string;
/**
* Get a prompt warning displayed on the prompt.
*
* This is a warning like "The password is incorrect." usually displayed to the
* user about a previous 'unsuccessful' prompt.
*
* If this string is %NULL then no warning is displayed.
* @returns a newly allocated string containing the prompt warning, or %NULL if no warning
*/
get_warning(): string;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will block until the a response is returned from the prompter.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the password owned by the prompt, or %NULL
*/
password(cancellable?: Gio.Cancellable | null): string;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
*/
password_async(cancellable?: Gio.Cancellable | null): Promise<string>;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
password_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
password_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<string> | void;
/**
* Complete an operation to prompt for a password.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param result asynchronous result passed to callback
* @returns the password owned by the prompt, or %NULL
*/
password_finish(result: Gio.AsyncResult): string;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will block until the a response is returned from the prompter
* and will run a main loop similar to a gtk_dialog_run(). The application
* will remain responsive but care must be taken to handle reentrancy issues.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the password owned by the prompt, or %NULL
*/
password_run(cancellable?: Gio.Cancellable | null): string;
/**
* Reset the contents and properties of the prompt.
*/
reset(): void;
/**
* Set the string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
* @param window_id the window id
*/
set_caller_window(window_id: string): void;
/**
* Set the label for the continue button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CANCEL reply
* from the prompt.
* @param cancel_label the label
*/
set_cancel_label(cancel_label: string): void;
/**
* Set whether the additional choice is chosen or not.
*
* The additional choice should be set up using gcr_prompt_set_choice_label().
* @param chosen whether chosen
*/
set_choice_chosen(chosen: boolean): void;
/**
* Set the label for the additional choice.
*
* If this is a non-%NULL value then an additional boolean choice will be
* displayed by the prompt allowing the user to select or deselect it.
*
* The initial value of the choice can be set with the
* gcr_prompt_set_choice_label() method.
*
* If this is %NULL, then no additional choice is being displayed.
* @param choice_label the additional choice or %NULL
*/
set_choice_label(choice_label?: string | null): void;
/**
* Set the label for the continue button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CONTINUE reply
* from the prompt.
* @param continue_label the label
*/
set_continue_label(continue_label: string): void;
/**
* Set the detailed description of the prompt.
*
* A prompt implementation may choose not to display this detailed description.
* Use gcr_prompt_set_message() to set a general message containing relevant
* information.
* @param description the detailed description
*/
set_description(description: string): void;
/**
* Sets the prompt message for the user.
*
* A prompt implementation should always display this message.
* @param message the prompt message
*/
set_message(message: string): void;
/**
* Set whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
* @param new_password whether in new password mode or not
*/
set_password_new(new_password: boolean): void;
/**
* Sets the title of the prompt.
*
* A prompt implementation may choose not to display the prompt title. The
* prompt message should contain relevant information.
* @param title the prompt title
*/
set_title(title: string): void;
/**
* Set a prompt warning displayed on the prompt.
*
* This is a warning like "The password is incorrect." usually displayed to the
* user about a previous 'unsuccessful' prompt.
*
* If this string is %NULL then no warning is displayed.
* @param warning the warning or %NULL
*/
set_warning(warning?: string | null): void;
/**
* close a prompt
*/
vfunc_prompt_close(): void;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
vfunc_prompt_confirm_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete an operation to prompt for confirmation.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param result asynchronous result passed to callback
*/
vfunc_prompt_confirm_finish(result: Gio.AsyncResult): PromptReply;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
vfunc_prompt_password_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete an operation to prompt for a password.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param result asynchronous result passed to callback
*/
vfunc_prompt_password_finish(result: Gio.AsyncResult): string;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
*/
init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied
*/
init_async(
io_priority: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied
*/
init_async(
io_priority: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<boolean> | void;
/**
* Finishes asynchronous initialization and returns the result.
* See g_async_initable_init_async().
* @param res a #GAsyncResult.
* @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
*/
init_finish(res: Gio.AsyncResult): boolean;
/**
* Finishes the async construction for the various g_async_initable_new
* calls, returning the created object or %NULL on error.
* @param res the #GAsyncResult from the callback
* @returns a newly created #GObject, or %NULL on error. Free with g_object_unref().
*/
new_finish(res: Gio.AsyncResult): SystemPrompt;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied
*/
vfunc_init_async(
io_priority: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Finishes asynchronous initialization and returns the result.
* See g_async_initable_init_async().
* @param res a #GAsyncResult.
*/
vfunc_init_finish(res: Gio.AsyncResult): boolean;
/**
* Initializes the object implementing the interface.
*
* This method is intended for language bindings. If writing in C,
* g_initable_new() should typically be used instead.
*
* The object must be initialized before any real use after initial
* construction, either with this function or g_async_initable_init_async().
*
* Implementations may also support cancellation. If `cancellable` is not %NULL,
* then initialization can be cancelled by triggering the cancellable object
* from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
* the object doesn't support cancellable initialization the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* If the object is not initialized, or initialization returns with an
* error, then all operations on the object except g_object_ref() and
* g_object_unref() are considered to be invalid, and have undefined
* behaviour. See the [description][iface`Gio`.Initable#description] for more details.
*
* Callers should not assume that a class which implements #GInitable can be
* initialized multiple times, unless the class explicitly documents itself as
* supporting this. Generally, a class’ implementation of init() can assume
* (and assert) that it will only be called once. Previously, this documentation
* recommended all #GInitable implementations should be idempotent; that
* recommendation was relaxed in GLib 2.54.
*
* If a class explicitly supports being initialized multiple times, it is
* recommended that the method is idempotent: multiple calls with the same
* arguments should return the same results. Only the first call initializes
* the object; further calls return the result of the first call.
*
* One reason why a class might need to support idempotent initialization is if
* it is designed to be used via the singleton pattern, with a
* #GObjectClass.constructor that sometimes returns an existing instance.
* In this pattern, a caller would expect to be able to call g_initable_init()
* on the result of g_object_new(), regardless of whether it is in fact a new
* instance.
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
*/
init(cancellable?: Gio.Cancellable | null): boolean;
/**
* Initializes the object implementing the interface.
*
* This method is intended for language bindings. If writing in C,
* g_initable_new() should typically be used instead.
*
* The object must be initialized before any real use after initial
* construction, either with this function or g_async_initable_init_async().
*
* Implementations may also support cancellation. If `cancellable` is not %NULL,
* then initialization can be cancelled by triggering the cancellable object
* from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
* the object doesn't support cancellable initialization the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* If the object is not initialized, or initialization returns with an
* error, then all operations on the object except g_object_ref() and
* g_object_unref() are considered to be invalid, and have undefined
* behaviour. See the [description][iface`Gio`.Initable#description] for more details.
*
* Callers should not assume that a class which implements #GInitable can be
* initialized multiple times, unless the class explicitly documents itself as
* supporting this. Generally, a class’ implementation of init() can assume
* (and assert) that it will only be called once. Previously, this documentation
* recommended all #GInitable implementations should be idempotent; that
* recommendation was relaxed in GLib 2.54.
*
* If a class explicitly supports being initialized multiple times, it is
* recommended that the method is idempotent: multiple calls with the same
* arguments should return the same results. Only the first call initializes
* the object; further calls return the result of the first call.
*
* One reason why a class might need to support idempotent initialization is if
* it is designed to be used via the singleton pattern, with a
* #GObjectClass.constructor that sometimes returns an existing instance.
* In this pattern, a caller would expect to be able to call g_initable_init()
* on the result of g_object_new(), regardless of whether it is in fact a new
* instance.
* @param cancellable optional #GCancellable object, %NULL to ignore.
*/
vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
namespace SystemPrompter {
// Signal callback interfaces
interface NewPrompt {
(): Prompt;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
prompt_type: GObject.GType;
promptType: GObject.GType;
prompting: boolean;
}
}
/**
* A prompter used by implementations of system prompts.
*
* This is a D-Bus service which is rarely implemented. Use [class`SystemPrompt]`
* to display system prompts.
*
* The system prompter service responds to D-Bus requests to create system
* prompts and creates #GcrPrompt type objects to display those prompts.
*
* Pass the GType of the implementation of [iface`Prompt]` to
* [ctor`SystemPrompter`.new].
*/
class SystemPrompter extends GObject.Object {
static $gtype: GObject.GType<SystemPrompter>;
// Properties
/**
* The #GType for prompts created by this prompter. This must be a
* #GcrPrompt implementation.
*/
get prompt_type(): GObject.GType;
/**
* The #GType for prompts created by this prompter. This must be a
* #GcrPrompt implementation.
*/
get promptType(): GObject.GType;
/**
* Whether the prompter is prompting or not.
*/
get prompting(): boolean;
// Constructors
constructor(properties?: Partial<SystemPrompter.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](mode: SystemPrompterMode, prompt_type: GObject.GType): SystemPrompter;
// Signals
connect(id: string, callback: (...args: any[]) => any): number;
connect_after(id: string, callback: (...args: any[]) => any): number;
emit(id: string, ...args: any[]): void;
connect(signal: 'new-prompt', callback: (_source: this) => Prompt): number;
connect_after(signal: 'new-prompt', callback: (_source: this) => Prompt): number;
emit(signal: 'new-prompt'): void;
// Methods
/**
* Get the mode for this prompter.
*
* Most system prompters only display one prompt at a time and therefore
* return %GCR_SYSTEM_PROMPTER_SINGLE.
* @returns the prompter mode
*/
get_mode(): SystemPrompterMode;
/**
* Get the #GType for prompts created by this prompter.
*
* The returned #GType will be a #GcrPrompt implementation.
* @returns the prompt #GType
*/
get_prompt_type(): GObject.GType;
/**
* Get whether prompting or not.
* @returns whether prompting or not
*/
get_prompting(): boolean;
/**
* Register this system prompter on the DBus `connection`.
*
* This makes the prompter available for clients to call. The prompter will
* remain registered until gcr_system_prompter_unregister() is called, or the
* prompter is unreferenced.
* @param connection a DBus connection
*/
register(connection: Gio.DBusConnection): void;
/**
* Unregister this system prompter on the DBus `connection`.
*
* The prompter must have previously been registered with gcr_system_prompter_register().
*
* If `wait` is set then this function will wait until all prompts have been closed
* or cancelled. This is usually only used by tests.
* @param wait whether to wait for closing prompts
*/
unregister(wait: boolean): void;
}
namespace UnionCollection {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps, Collection.ConstructorProps {}
}
/**
* An implementation of #GcrCollection, which combines the objects in
* other [iface`Collection]`s. Use [method`UnionCollection`.add] to add and
* [method`UnionCollection`.remove] to remove them.
*/
class UnionCollection extends GObject.Object implements Collection {
static $gtype: GObject.GType<UnionCollection>;
// Constructors
constructor(properties?: Partial<UnionCollection.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): UnionCollection;
// Methods
/**
* Add objects from this collection to the union
* @param collection The collection whose objects to add
*/
add(collection: Collection): void;
/**
* Get the collections that have been added to this union.
* @returns collections added to the union
*/
elements(): Collection[];
/**
* Check whether the collection is present in the union.
* @param collection the collection to check
* @returns whether present or not
*/
have(collection: Collection): boolean;
/**
* Remove an object from the collection.
* @param collection The collection whose objects to remove
*/
remove(collection: Collection): void;
/**
* Return the number of collections in this union. This does not reflect
* the number of objects in the combined collection.
* @returns number of collections inlcuded
*/
size(): number;
/**
* Add objects from this collection to the union. Do not add an additional
* reference to the collection.
* @param collection The collection whose objects to add
*/
take(collection: Collection): void;
// Inherited methods
/**
* Check whether the collection contains an object or not.
* @param object object to check
* @returns whether the collection contains this object
*/
contains(object: GObject.Object): boolean;
/**
* Emit the #GcrCollection::added signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was added
*/
emit_added(object: GObject.Object): void;
/**
* Emit the #GcrCollection::removed signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was removed
*/
emit_removed(object: GObject.Object): void;
/**
* Get the number of objects in this collection.
* @returns The number of objects.
*/
get_length(): number;
/**
* Get a list of the objects in this collection.
* @returns a list of the objects in this collection, which should be freed with g_list_free()
*/
get_objects(): GObject.Object[];
vfunc_added(object: GObject.Object): void;
/**
* Check whether the collection contains an object or not.
* @param object object to check
*/
vfunc_contains(object: GObject.Object): boolean;
/**
* Get the number of objects in this collection.
*/
vfunc_get_length(): number;
/**
* Get a list of the objects in this collection.
*/
vfunc_get_objects(): GObject.Object[];
vfunc_removed(object: GObject.Object): void;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
type CertificateChainClass = typeof CertificateChain;
abstract class CertificateChainPrivate {
static $gtype: GObject.GType<CertificateChainPrivate>;
// Constructors
_init(...args: any[]): void;
}
type CertificateIface = typeof Certificate;
type CertificateRequestClass = typeof CertificateRequest;
type CollectionIface = typeof Collection;
class Column {
static $gtype: GObject.GType<Column>;
// Fields
property_name: string;
property_type: GObject.GType;
column_type: GObject.GType;
label: string;
flags: ColumnFlags;
transformer: GObject.ValueTransform;
user_data: any;
// Constructors
_init(...args: any[]): void;
}
type ComparableIface = typeof Comparable;
type FilterCollectionClass = typeof FilterCollection;
abstract class FilterCollectionPrivate {
static $gtype: GObject.GType<FilterCollectionPrivate>;
// Constructors
_init(...args: any[]): void;
}
type ImportInteractionIface = typeof ImportInteraction;
type ImporterIface = typeof Importer;
/**
* A parsed item parsed by a #GcrParser.
*/
abstract class Parsed {
static $gtype: GObject.GType<Parsed>;
// Constructors
_init(...args: any[]): void;
// Static methods
/**
* Unreferences a parsed item which was referenced with gcr_parsed_ref()
* @param parsed a parsed item
*/
static unref(parsed?: any | null): void;
// Methods
/**
* Get the attributes which make up the parsed item.
* @returns the attributes for the item; these are owned by the parsed item and should not be freed
*/
get_attributes(): Gck.Attributes | null;
/**
* Get the raw data block for the parsed item.
* @returns the raw data of the parsed item, or %NULL
*/
get_bytes(): GLib.Bytes;
/**
* Get the raw data block for the parsed item.
* @returns the raw data of the parsed item, or %NULL
*/
get_data(): Uint8Array | null;
/**
* Get the descirption for a parsed item.
* @returns the description
*/
get_description(): string | null;
/**
* Get the filename of the parsed item.
* @returns the filename of the parsed item, or %NULL
*/
get_filename(): string;
/**
* Get the format of the parsed item.
* @returns the data format of the item
*/
get_format(): DataFormat;
/**
* Get the label for the parsed item.
* @returns the label for the item
*/
get_label(): string | null;
/**
* Add a reference to a parsed item. An item may not be shared across threads
* until it has been referenced at least once.
* @returns the parsed item
*/
ref(): Parsed;
}
type ParserClass = typeof Parser;
abstract class ParserPrivate {
static $gtype: GObject.GType<ParserPrivate>;
// Constructors
_init(...args: any[]): void;
}
type Pkcs11CertificateClass = typeof Pkcs11Certificate;
abstract class Pkcs11CertificatePrivate {
static $gtype: GObject.GType<Pkcs11CertificatePrivate>;
// Constructors
_init(...args: any[]): void;
}
type PromptIface = typeof Prompt;
type SecretExchangeClass = typeof SecretExchange;
abstract class SecretExchangePrivate {
static $gtype: GObject.GType<SecretExchangePrivate>;
// Constructors
_init(...args: any[]): void;
}
type SimpleCertificateClass = typeof SimpleCertificate;
abstract class SimpleCertificatePrivate {
static $gtype: GObject.GType<SimpleCertificatePrivate>;
// Constructors
_init(...args: any[]): void;
}
type SimpleCollectionClass = typeof SimpleCollection;
abstract class SimpleCollectionPrivate {
static $gtype: GObject.GType<SimpleCollectionPrivate>;
// Constructors
_init(...args: any[]): void;
}
type SshAskpassClass = typeof SshAskpass;
type SystemPromptClass = typeof SystemPrompt;
abstract class SystemPromptPrivate {
static $gtype: GObject.GType<SystemPromptPrivate>;
// Constructors
_init(...args: any[]): void;
}
type SystemPrompterClass = typeof SystemPrompter;
abstract class SystemPrompterPrivate {
static $gtype: GObject.GType<SystemPrompterPrivate>;
// Constructors
_init(...args: any[]): void;
}
type UnionCollectionClass = typeof UnionCollection;
abstract class UnionCollectionPrivate {
static $gtype: GObject.GType<UnionCollectionPrivate>;
// Constructors
_init(...args: any[]): void;
}
namespace Certificate {
// Constructor properties interface
interface ConstructorProps extends Comparable.ConstructorProps {
description: string;
expiry: GLib.Date;
icon: Gio.Icon;
issuer: string;
label: string;
markup: string;
subject: string;
}
}
export interface CertificateNamespace {
$gtype: GObject.GType<Certificate>;
prototype: Certificate;
/**
* Compare one certificate against another. If the certificates are equal
* then zero is returned. If one certificate is %NULL or not a certificate,
* then a non-zero value is returned.
*
* The return value is useful in a stable sort, but has no user logical
* meaning.
* @param first the certificate to compare
* @param other the certificate to compare against
*/
compare(first?: Comparable | null, other?: Comparable | null): number;
}
interface Certificate extends Comparable {
// Properties
/**
* A readable description for this certificate
*/
get description(): string;
/**
* The expiry date of the certificate
*/
get expiry(): GLib.Date;
/**
* An icon representing the certificate
*/
get icon(): Gio.Icon;
/**
* Common name part of the certificate issuer
*/
get issuer(): string;
/**
* A readable label for this certificate.
*/
get label(): string;
/**
* GLib markup to describe the certificate
*/
get markup(): string;
/**
* Common name part of the certificate subject
*/
get subject(): string;
// Methods
/**
* Get the basic constraints for the certificate if present. If %FALSE is
* returned then no basic constraints are present and the `is_ca` and
* `path_len` arguments are not changed.
* @returns whether basic constraints are present or not
*/
get_basic_constraints(): [boolean, boolean, number];
/**
* Gets the raw DER data for an X.509 certificate.
* @returns raw DER data of the X.509 certificate
*/
get_der_data(): Uint8Array;
/**
* Get the expiry date of this certificate.
*
* The #GDate returned should be freed by the caller using
* g_date_free() when no longer required.
* @returns An allocated expiry date of this certificate.
*/
get_expiry_date(): GLib.Date;
/**
* Calculate the fingerprint for this certificate.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @param type the type of algorithm for the fingerprint.
* @returns the raw binary fingerprint
*/
get_fingerprint(type: GLib.ChecksumType | null): Uint8Array;
/**
* Calculate the fingerprint for this certificate, and return it
* as a hex string.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @param type the type of algorithm for the fingerprint.
* @returns an allocated hex string which contains the fingerprint.
*/
get_fingerprint_hex(type: GLib.ChecksumType | null): string;
/**
* Get the issued date of this certificate.
*
* The #GDate returned should be freed by the caller using
* g_date_free() when no longer required.
* @returns An allocated issued date of this certificate.
*/
get_issued_date(): GLib.Date;
/**
* Get the common name of the issuer of this certificate.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated issuer CN, or %NULL if no issuer CN present.
*/
get_issuer_cn(): string;
/**
* Get the full issuer DN of the certificate as a (mostly)
* readable string.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated issuer DN of the certificate.
*/
get_issuer_dn(): string;
/**
* Get a name to represent the issuer of this certificate.
*
* This will try to lookup the common name, orianizational unit,
* organization in that order.
* @returns the allocated issuer name, or %NULL if no issuer name
*/
get_issuer_name(): string;
/**
* Get a part of the DN of the issuer of this certificate.
*
* Examples of a `part` might be the 'OU' (organizational unit)
* or the 'CN' (common name). Only the value of that part
* of the DN is returned.
*
* The string returned should be freed by the caller when no longer
* required.
* @param part a DN type string or OID.
* @returns the allocated part of the issuer DN, or %NULL if no such part is present
*/
get_issuer_part(part: string): string | null;
/**
* Get the raw DER data for the issuer DN of the certificate.
*
* The data should be freed by using g_free() when no longer required.
* @returns allocated memory containing the raw issuer
*/
get_issuer_raw(): Uint8Array;
/**
* Get the key size in bits of the public key represented
* by this certificate.
* @returns The key size of the certificate.
*/
get_key_size(): number;
/**
* Calculate a GMarkup string for displaying this certificate.
* @returns the markup string
*/
get_markup_text(): string;
/**
* Get the raw binary serial number of the certificate.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @returns the raw binary serial number.
*/
get_serial_number(): Uint8Array;
/**
* Get the serial number of the certificate as a hex string.
*
* The caller should free the returned data using g_free() when
* it is no longer required.
* @returns an allocated string containing the serial number as hex.
*/
get_serial_number_hex(): string;
/**
* Get the common name of the subject of this certificate.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated subject CN, or %NULL if no subject CN present.
*/
get_subject_cn(): string;
/**
* Get the full subject DN of the certificate as a (mostly)
* readable string.
*
* The string returned should be freed by the caller when no longer
* required.
* @returns The allocated subject DN of the certificate.
*/
get_subject_dn(): string;
/**
* Get a name to represent the subject of this certificate.
*
* This will try to lookup the common name, orianizational unit,
* organization in that order.
* @returns the allocated subject name, or %NULL if no subject name
*/
get_subject_name(): string;
/**
* Get a part of the DN of the subject of this certificate.
*
* Examples of a `part` might be the 'OU' (organizational unit)
* or the 'CN' (common name). Only the value of that part
* of the DN is returned.
*
* The string returned should be freed by the caller when no longer
* required.
* @param part a DN type string or OID.
* @returns the allocated part of the subject DN, or %NULL if no such part is present.
*/
get_subject_part(part: string): string | null;
/**
* Get the raw DER data for the subject DN of the certificate.
*
* The data should be freed by using g_free() when no longer required.
* @returns allocated memory containing the raw subject
*/
get_subject_raw(): Uint8Array;
/**
* Check if `issuer` could be the issuer of this certificate. This is done by
* comparing the relevant subject and issuer fields. No signature check is
* done. Proper verification of certificates must be done via a crypto
* library.
* @param issuer a possible issuer #GcrCertificate
* @returns whether @issuer could be the issuer of the certificate.
*/
is_issuer(issuer: Certificate): boolean;
/**
* Implementers of the #GcrCertificate mixin should call this function to notify
* when the certificate has changed to emit notifications on the various
* properties.
*/
mixin_emit_notify(): void;
// Virtual methods
/**
* Gets the raw DER data for an X.509 certificate.
*/
vfunc_get_der_data(): Uint8Array;
}
export const Certificate: CertificateNamespace & {
new (): Certificate; // This allows `obj instanceof Certificate`
};
namespace Collection {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
export interface CollectionNamespace {
$gtype: GObject.GType<Collection>;
prototype: Collection;
}
interface Collection extends GObject.Object {
// Methods
/**
* Check whether the collection contains an object or not.
* @param object object to check
* @returns whether the collection contains this object
*/
contains(object: GObject.Object): boolean;
/**
* Emit the #GcrCollection::added signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was added
*/
emit_added(object: GObject.Object): void;
/**
* Emit the #GcrCollection::removed signal for the given object. This function
* is used by implementors of this interface.
* @param object The object that was removed
*/
emit_removed(object: GObject.Object): void;
/**
* Get the number of objects in this collection.
* @returns The number of objects.
*/
get_length(): number;
/**
* Get a list of the objects in this collection.
* @returns a list of the objects in this collection, which should be freed with g_list_free()
*/
get_objects(): GObject.Object[];
// Virtual methods
vfunc_added(object: GObject.Object): void;
/**
* Check whether the collection contains an object or not.
* @param object object to check
*/
vfunc_contains(object: GObject.Object): boolean;
/**
* Get the number of objects in this collection.
*/
vfunc_get_length(): number;
/**
* Get a list of the objects in this collection.
*/
vfunc_get_objects(): GObject.Object[];
vfunc_removed(object: GObject.Object): void;
}
export const Collection: CollectionNamespace & {
new (): Collection; // This allows `obj instanceof Collection`
};
namespace Comparable {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
export interface ComparableNamespace {
$gtype: GObject.GType<Comparable>;
prototype: Comparable;
}
interface Comparable extends GObject.Object {
// Methods
/**
* Compare whether two objects represent the same thing. The return value can
* also be used to sort the objects.
* @param other Another comparable object
* @returns Zero if the two objects represent the same thing, non-zero if not.
*/
compare(other?: Comparable | null): number;
// Virtual methods
/**
* Compare whether two objects represent the same thing. The return value can
* also be used to sort the objects.
* @param other Another comparable object
*/
vfunc_compare(other?: Comparable | null): number;
}
export const Comparable: ComparableNamespace & {
new (): Comparable; // This allows `obj instanceof Comparable`
};
namespace ImportInteraction {
// Constructor properties interface
interface ConstructorProps extends Gio.TlsInteraction.ConstructorProps {}
}
export interface ImportInteractionNamespace {
$gtype: GObject.GType<ImportInteraction>;
prototype: ImportInteraction;
}
interface ImportInteraction extends Gio.TlsInteraction {
// Methods
/**
* Supplement attributes before import. This means prompting the user for
* things like labels and the like. The needed attributes will have been passed
* to gcr_import_interaction_supplement_prep().
*
* This method prompts the user and fills in the attributes. If the user or
* cancellable cancels the operation the error should be set with %G_IO_ERROR_CANCELLED.
* @param builder supplemented attributes
* @param cancellable optional cancellable object
* @returns %G_TLS_INTERACTION_HANDLED if successful or %G_TLS_INTERACTION_FAILED
*/
supplement(builder: Gck.Builder, cancellable?: Gio.Cancellable | null): Gio.TlsInteractionResult;
/**
* Asynchronously supplement attributes before import. This means prompting the
* user for things like labels and the like. The needed attributes will have
* been passed to gcr_import_interaction_supplement_prep().
*
* This method prompts the user and fills in the attributes.
* @param builder supplemented attributes
* @param cancellable optional cancellable object
*/
supplement_async(
builder: Gck.Builder,
cancellable?: Gio.Cancellable | null,
): Promise<Gio.TlsInteractionResult>;
/**
* Asynchronously supplement attributes before import. This means prompting the
* user for things like labels and the like. The needed attributes will have
* been passed to gcr_import_interaction_supplement_prep().
*
* This method prompts the user and fills in the attributes.
* @param builder supplemented attributes
* @param cancellable optional cancellable object
* @param callback called when the operation completes
*/
supplement_async(
builder: Gck.Builder,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Asynchronously supplement attributes before import. This means prompting the
* user for things like labels and the like. The needed attributes will have
* been passed to gcr_import_interaction_supplement_prep().
*
* This method prompts the user and fills in the attributes.
* @param builder supplemented attributes
* @param cancellable optional cancellable object
* @param callback called when the operation completes
*/
supplement_async(
builder: Gck.Builder,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<Gio.TlsInteractionResult> | void;
/**
* Complete operation to asynchronously supplement attributes before import.
*
* If the user or cancellable cancels the operation the error should be set
* with %G_IO_ERROR_CANCELLED.
* @param result the asynchronous result
* @returns %G_TLS_INTERACTION_HANDLED if successful or %G_TLS_INTERACTION_FAILED
*/
supplement_finish(result: Gio.AsyncResult): Gio.TlsInteractionResult;
/**
* Prepare for supplementing the given attributes before import. This means
* prompting the user for things like labels and the like. The attributes
* will contain attributes for values that the importer needs, either empty
* or prefilled with suggested values.
*
* This method does not prompt the user, but rather just prepares the
* interaction that these are the attributes that are needed.
* @param builder attributes to supplement
*/
supplement_prep(builder: Gck.Builder): void;
// Virtual methods
/**
* Supplement attributes before import. This means prompting the user for
* things like labels and the like. The needed attributes will have been passed
* to gcr_import_interaction_supplement_prep().
*
* This method prompts the user and fills in the attributes. If the user or
* cancellable cancels the operation the error should be set with %G_IO_ERROR_CANCELLED.
* @param builder supplemented attributes
* @param cancellable optional cancellable object
*/
vfunc_supplement(builder: Gck.Builder, cancellable?: Gio.Cancellable | null): Gio.TlsInteractionResult;
/**
* Asynchronously supplement attributes before import. This means prompting the
* user for things like labels and the like. The needed attributes will have
* been passed to gcr_import_interaction_supplement_prep().
*
* This method prompts the user and fills in the attributes.
* @param builder supplemented attributes
* @param cancellable optional cancellable object
* @param callback called when the operation completes
*/
vfunc_supplement_async(
builder: Gck.Builder,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete operation to asynchronously supplement attributes before import.
*
* If the user or cancellable cancels the operation the error should be set
* with %G_IO_ERROR_CANCELLED.
* @param result the asynchronous result
*/
vfunc_supplement_finish(result: Gio.AsyncResult): Gio.TlsInteractionResult;
/**
* Prepare for supplementing the given attributes before import. This means
* prompting the user for things like labels and the like. The attributes
* will contain attributes for values that the importer needs, either empty
* or prefilled with suggested values.
*
* This method does not prompt the user, but rather just prepares the
* interaction that these are the attributes that are needed.
* @param builder attributes to supplement
*/
vfunc_supplement_prep(builder: Gck.Builder): void;
}
export const ImportInteraction: ImportInteractionNamespace & {
new (): ImportInteraction; // This allows `obj instanceof ImportInteraction`
};
namespace Importer {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
icon: Gio.Icon;
interaction: Gio.TlsInteraction;
label: string;
uri: string;
}
}
export interface ImporterNamespace {
$gtype: GObject.GType<Importer>;
prototype: Importer;
/**
* Create a set of importers which can import this parsed item.
* The parsed item is represented by the state of the GcrParser at the
* time of calling this method.
* @param parsed a parser with a parsed item to import
*/
create_for_parsed(parsed: Parsed): Importer[];
/**
* Queues an additional item to be imported in all compattible importers
* in the set. The parsed item is represented by the state of the #GcrParser
* at the time of calling this method.
*
* If the parsed item is incompatible with an importer, then that the item
* will not be queued on that importer.
* @param importers a set of importers
* @param parsed a parsed item
*/
queue_and_filter_for_parsed(importers: Importer[], parsed: Parsed): Importer[];
/**
* Register an importer to handle parsed items that match the given attributes.
*
* If `attrs` are a floating reference, then it is consumed.
* @param importer_type the GType of the importer being registered
* @param attrs the attributes that this importer is compatible with
*/
register(importer_type: GObject.GType, attrs: Gck.Attributes): void;
/**
* Register built-in PKCS#11 and GnuPG importers.
*/
register_well_known(): void;
}
interface Importer extends GObject.Object {
// Properties
/**
* The icon for the importer.
*/
get icon(): Gio.Icon;
/**
* The interaction for the importer.
*/
get interaction(): Gio.TlsInteraction;
set interaction(val: Gio.TlsInteraction);
/**
* The label for the importer.
*/
get label(): string;
/**
* The URI of the location imported to.
*/
get uri(): string;
// Methods
/**
* Get the interaction used to prompt the user when needed by this
* importer.
* @returns the interaction or %NULL
*/
get_interaction(): Gio.TlsInteraction | null;
/**
* Import the queued items in the importer. This call will block
* until the operation completes.
* @param cancellable a #GCancellable, or %NULL
* @returns whether the items were imported successfully or not
*/
['import'](cancellable?: Gio.Cancellable | null): boolean;
/**
* Import the queued items in the importer. This function returns immediately
* and completes asynchronously.
* @param cancellable a #GCancellable, or %NULL
*/
import_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
/**
* Import the queued items in the importer. This function returns immediately
* and completes asynchronously.
* @param cancellable a #GCancellable, or %NULL
* @param callback called when the operation completes
*/
import_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Import the queued items in the importer. This function returns immediately
* and completes asynchronously.
* @param cancellable a #GCancellable, or %NULL
* @param callback called when the operation completes
*/
import_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<boolean> | void;
/**
* Complete an asynchronous operation to import queued items.
* @param result an asynchronous result
* @returns whether the import succeeded or failed
*/
import_finish(result: Gio.AsyncResult): boolean;
/**
* Queues an additional item to be imported. The parsed item is represented
* by the state of the [class`Parser]` at the time of calling this method.
*
* If the parsed item is incompatible with the importer, then this will
* fail and the item will not be queued.
* @param parsed a parsed item to import
* @returns whether the item was queued or not
*/
queue_for_parsed(parsed: Parsed): boolean;
/**
* Set the interaction used to prompt the user when needed by this
* importer.
* @param interaction the interaction used by the importer
*/
set_interaction(interaction: Gio.TlsInteraction): void;
// Virtual methods
/**
* Import the queued items in the importer. This function returns immediately
* and completes asynchronously.
* @param cancellable a #GCancellable, or %NULL
* @param callback called when the operation completes
*/
vfunc_import_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete an asynchronous operation to import queued items.
* @param result an asynchronous result
*/
vfunc_import_finish(result: Gio.AsyncResult): boolean;
/**
* optional implementation of [method`Importer`.import]
* @param cancellable
*/
vfunc_import_sync(cancellable?: Gio.Cancellable | null): boolean;
/**
* Queues an additional item to be imported. The parsed item is represented
* by the state of the [class`Parser]` at the time of calling this method.
*
* If the parsed item is incompatible with the importer, then this will
* fail and the item will not be queued.
* @param parsed a parsed item to import
*/
vfunc_queue_for_parsed(parsed: Parsed): boolean;
}
export const Importer: ImporterNamespace & {
new (): Importer; // This allows `obj instanceof Importer`
};
namespace Prompt {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
caller_window: string;
callerWindow: string;
cancel_label: string;
cancelLabel: string;
choice_chosen: boolean;
choiceChosen: boolean;
choice_label: string;
choiceLabel: string;
continue_label: string;
continueLabel: string;
description: string;
message: string;
password_new: boolean;
passwordNew: boolean;
password_strength: number;
passwordStrength: number;
title: string;
warning: string;
}
}
export interface PromptNamespace {
$gtype: GObject.GType<Prompt>;
prototype: Prompt;
}
interface Prompt extends GObject.Object {
// Properties
/**
* The string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
*
* In X11, this will be a stringified version of the XWindow handle; in
* Wayland this is the result of an export using the XDG foreign
* protocol.
*/
get caller_window(): string;
set caller_window(val: string);
/**
* The string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
*
* In X11, this will be a stringified version of the XWindow handle; in
* Wayland this is the result of an export using the XDG foreign
* protocol.
*/
get callerWindow(): string;
set callerWindow(val: string);
/**
* The label for the cancel button in the prompt.
*/
get cancel_label(): string;
set cancel_label(val: string);
/**
* The label for the cancel button in the prompt.
*/
get cancelLabel(): string;
set cancelLabel(val: string);
/**
* Whether the additional choice is chosen or not.
*
* The additional choice would have been setup using #GcrPrompt:choice-label.
*/
get choice_chosen(): boolean;
set choice_chosen(val: boolean);
/**
* Whether the additional choice is chosen or not.
*
* The additional choice would have been setup using #GcrPrompt:choice-label.
*/
get choiceChosen(): boolean;
set choiceChosen(val: boolean);
/**
* The label for the additional choice.
*
* If this is a non-%NULL value then an additional boolean choice will be
* displayed by the prompt allowing the user to select or deselect it.
*
* If %NULL, then no additional choice is displayed.
*
* The initial value of the choice can be set with #GcrPrompt:choice-chosen.
*/
get choice_label(): string;
set choice_label(val: string);
/**
* The label for the additional choice.
*
* If this is a non-%NULL value then an additional boolean choice will be
* displayed by the prompt allowing the user to select or deselect it.
*
* If %NULL, then no additional choice is displayed.
*
* The initial value of the choice can be set with #GcrPrompt:choice-chosen.
*/
get choiceLabel(): string;
set choiceLabel(val: string);
/**
* The label for the continue button in the prompt.
*/
get continue_label(): string;
set continue_label(val: string);
/**
* The label for the continue button in the prompt.
*/
get continueLabel(): string;
set continueLabel(val: string);
/**
* The detailed description of the prompt.
*
* A prompt implementation may choose not to display this detailed description.
* The prompt message should contain relevant information.
*/
get description(): string;
set description(val: string);
/**
* The prompt message for the user.
*
* A prompt implementation should always display this message.
*/
get message(): string;
set message(val: string);
/**
* Whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
*/
get password_new(): boolean;
set password_new(val: boolean);
/**
* Whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
*/
get passwordNew(): boolean;
set passwordNew(val: boolean);
/**
* Indication of the password strength.
*
* Prompts will return a zero value if the password is empty, and a value
* greater than zero if the password has any characters.
*
* This is only valid after a successful prompt for a password.
*/
get password_strength(): number;
/**
* Indication of the password strength.
*
* Prompts will return a zero value if the password is empty, and a value
* greater than zero if the password has any characters.
*
* This is only valid after a successful prompt for a password.
*/
get passwordStrength(): number;
/**
* The title of the prompt.
*
* A prompt implementation may choose not to display the prompt title. The
* #GcrPrompt:message should contain relevant information.
*/
get title(): string;
set title(val: string);
/**
* A prompt warning displayed on the prompt, or %NULL for no warning.
*
* This is a warning like "The password is incorrect." usually displayed to the
* user about a previous 'unsuccessful' prompt.
*/
get warning(): string;
set warning(val: string);
// Methods
/**
* Closes the prompt so that in can no longer be used to prompt. The various
* prompt methods will return results as if the user dismissed the prompt.
*
* The prompt may also be closed by the implementor of the prompt object.
*
* This emits the [signal`Prompt:`:prompt-close] signal on the prompt object.
*/
close(): void;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this function to
* represent the question correctly.
*
* This method will block until the a response is returned from the prompter.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the reply from the prompt
*/
confirm(cancellable?: Gio.Cancellable | null): PromptReply;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
*/
confirm_async(cancellable?: Gio.Cancellable | null): Promise<PromptReply>;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
confirm_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
confirm_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<PromptReply> | void;
/**
* Complete an operation to prompt for confirmation.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param result asynchronous result passed to callback
* @returns the reply from the prompt
*/
confirm_finish(result: Gio.AsyncResult): PromptReply;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this function to
* represent the question correctly.
*
* This method will block until the a response is returned from the prompter
* and will run a main loop similar to a `gtk_dialog_run()`. The application
* will remain responsive but care must be taken to handle reentrancy issues.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the reply from the prompt
*/
confirm_run(cancellable?: Gio.Cancellable | null): PromptReply;
/**
* Get the string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
* @returns a newly allocated string containing the string handle of the window.
*/
get_caller_window(): string;
/**
* Get the label for the cancel button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CANCEL reply
* from the prompt.
* @returns a newly allocated string containing the label
*/
get_cancel_label(): string;
/**
* Get whether the additional choice was chosen or not.
*
* The additional choice would have been setup using
* gcr_prompt_set_choice_label().
* @returns whether chosen
*/
get_choice_chosen(): boolean;
/**
* Get the label for the additional choice.
*
* This will be %NULL if no additional choice is being displayed.
* @returns a newly allocated string containing the additional choice or %NULL
*/
get_choice_label(): string;
/**
* Get the label for the continue button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CONTINUE reply
* from the prompt.
* @returns a newly allocated string containing the label
*/
get_continue_label(): string;
/**
* Get the detailed description of the prompt.
*
* A prompt implementation may choose not to display this detailed description.
* The prompt message should contain relevant information.
* @returns a newly allocated string containing the detailed description of the prompt
*/
get_description(): string;
/**
* Gets the prompt message for the user.
*
* A prompt implementation should always display this message.
* @returns a newly allocated string containing the detailed description of the prompt
*/
get_message(): string;
/**
* Get whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
* @returns whether in new password mode or not
*/
get_password_new(): boolean;
/**
* Get indication of the password strength.
*
* Prompts will return a zero value if the password is empty, and a value
* greater than zero if the password has any characters.
*
* This is only valid after a successful prompt for a password.
* @returns zero if the password is empty, greater than zero if not
*/
get_password_strength(): number;
/**
* Gets the title of the prompt.
*
* A prompt implementation may choose not to display the prompt title. The
* prompt message should contain relevant information.
* @returns a newly allocated string containing the prompt title.
*/
get_title(): string;
/**
* Get a prompt warning displayed on the prompt.
*
* This is a warning like "The password is incorrect." usually displayed to the
* user about a previous 'unsuccessful' prompt.
*
* If this string is %NULL then no warning is displayed.
* @returns a newly allocated string containing the prompt warning, or %NULL if no warning
*/
get_warning(): string;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will block until the a response is returned from the prompter.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the password owned by the prompt, or %NULL
*/
password(cancellable?: Gio.Cancellable | null): string;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
*/
password_async(cancellable?: Gio.Cancellable | null): Promise<string>;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
password_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
password_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): Promise<string> | void;
/**
* Complete an operation to prompt for a password.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param result asynchronous result passed to callback
* @returns the password owned by the prompt, or %NULL
*/
password_finish(result: Gio.AsyncResult): string;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will block until the a response is returned from the prompter
* and will run a main loop similar to a gtk_dialog_run(). The application
* will remain responsive but care must be taken to handle reentrancy issues.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param cancellable optional cancellation object
* @returns the password owned by the prompt, or %NULL
*/
password_run(cancellable?: Gio.Cancellable | null): string;
/**
* Reset the contents and properties of the prompt.
*/
reset(): void;
/**
* Set the string handle of the caller's window.
*
* The caller window indicates to the prompt which window is prompting the
* user. The prompt may choose to ignore this information or use it in whatever
* way it sees fit.
* @param window_id the window id
*/
set_caller_window(window_id: string): void;
/**
* Set the label for the continue button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CANCEL reply
* from the prompt.
* @param cancel_label the label
*/
set_cancel_label(cancel_label: string): void;
/**
* Set whether the additional choice is chosen or not.
*
* The additional choice should be set up using gcr_prompt_set_choice_label().
* @param chosen whether chosen
*/
set_choice_chosen(chosen: boolean): void;
/**
* Set the label for the additional choice.
*
* If this is a non-%NULL value then an additional boolean choice will be
* displayed by the prompt allowing the user to select or deselect it.
*
* The initial value of the choice can be set with the
* gcr_prompt_set_choice_label() method.
*
* If this is %NULL, then no additional choice is being displayed.
* @param choice_label the additional choice or %NULL
*/
set_choice_label(choice_label?: string | null): void;
/**
* Set the label for the continue button.
*
* This is the button that results in a %GCR_PROMPT_REPLY_CONTINUE reply
* from the prompt.
* @param continue_label the label
*/
set_continue_label(continue_label: string): void;
/**
* Set the detailed description of the prompt.
*
* A prompt implementation may choose not to display this detailed description.
* Use gcr_prompt_set_message() to set a general message containing relevant
* information.
* @param description the detailed description
*/
set_description(description: string): void;
/**
* Sets the prompt message for the user.
*
* A prompt implementation should always display this message.
* @param message the prompt message
*/
set_message(message: string): void;
/**
* Set whether the prompt will prompt for a new password.
*
* This will cause the prompt implementation to ask the user to confirm the
* password and/or display other relevant user interface for creating a new
* password.
* @param new_password whether in new password mode or not
*/
set_password_new(new_password: boolean): void;
/**
* Sets the title of the prompt.
*
* A prompt implementation may choose not to display the prompt title. The
* prompt message should contain relevant information.
* @param title the prompt title
*/
set_title(title: string): void;
/**
* Set a prompt warning displayed on the prompt.
*
* This is a warning like "The password is incorrect." usually displayed to the
* user about a previous 'unsuccessful' prompt.
*
* If this string is %NULL then no warning is displayed.
* @param warning the warning or %NULL
*/
set_warning(warning?: string | null): void;
// Virtual methods
/**
* close a prompt
*/
vfunc_prompt_close(): void;
/**
* Prompts for confirmation asking a cancel/continue style question.
* Set the various properties on the prompt before calling this method to
* represent the question correctly.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
vfunc_prompt_confirm_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete an operation to prompt for confirmation.
*
* %GCR_PROMPT_REPLY_CONTINUE will be returned if the user confirms the prompt. The
* return value will also be %GCR_PROMPT_REPLY_CANCEL if the user cancels or if
* an error occurs. Check the `error` argument to tell the difference.
* @param result asynchronous result passed to callback
*/
vfunc_prompt_confirm_finish(result: Gio.AsyncResult): PromptReply;
/**
* Prompts for password. Set the various properties on the prompt before calling
* this method to explain which password should be entered.
*
* This method will return immediately and complete asynchronously.
* @param cancellable optional cancellation object
* @param callback called when the operation completes
*/
vfunc_prompt_password_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback<this> | null,
): void;
/**
* Complete an operation to prompt for a password.
*
* A password will be returned if the user enters a password successfully.
* The returned password is valid until the next time a method is called
* to display another prompt.
*
* %NULL will be returned if the user cancels or if an error occurs. Check the
* `error` argument to tell the difference.
* @param result asynchronous result passed to callback
*/
vfunc_prompt_password_finish(result: Gio.AsyncResult): string;
}
export const Prompt: PromptNamespace & {
new (): Prompt; // This allows `obj instanceof Prompt`
};
/**
* Name of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
*/
const __name__: string;
/**
* Version of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
*/
const __version__: string;
}
export default Gcr;
}
declare module 'gi://Gcr' {
import Gcr3 from 'gi://Gcr?version=3';
export default Gcr3;
}
// END
Reference in New Issue View Git Blame Copy Permalink