///
///
///
///
///
/**
* 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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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 gcr_mock_prompter_expect_xxx()
* 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
* setup() 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
* teardown() 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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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 {
(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;
}
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;
}
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;
// Properties
/**
* The length of the certificate chain.
*/
get length(): number;
// Constructors
constructor(properties?: Partial, ...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;
/**
* 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 | 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 | null,
): Promise | 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;
// 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, ...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 | 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;
/**
* 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 | 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 | null,
): Promise | 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;
// Properties
get underlying(): Collection;
// Constructors
constructor(properties?: Partial, ...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;
// 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, ...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;
/**
* 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 | 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 | null,
): Promise | 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;
// Properties
/**
* Automatically loaded attributes for this certificate.
*/
get attributes(): Gck.Attributes;
// Constructors
constructor(properties?: Partial, ...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 | 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;
// 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, ...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;
// Constructors
constructor(properties?: Partial, ...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;
// Constructors
constructor(properties?: Partial, ...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;
// Properties
/**
* The interaction used to prompt for passwords.
*/
get interaction(): Gio.TlsInteraction;
// Constructors
constructor(properties?: Partial, ...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, Gio.Initable {
static $gtype: GObject.GType;
// 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, ...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 | 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 | 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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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 | 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 | 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;
/**
* 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 | 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 | null,
): Promise | 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 | 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;
// 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, ...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;
// Constructors
constructor(properties?: Partial, ...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;
// Constructors
_init(...args: any[]): void;
}
type CertificateIface = typeof Certificate;
type CertificateRequestClass = typeof CertificateRequest;
type CollectionIface = typeof Collection;
class Column {
static $gtype: GObject.GType;
// 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;
// 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;
// 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;
// Constructors
_init(...args: any[]): void;
}
type Pkcs11CertificateClass = typeof Pkcs11Certificate;
abstract class Pkcs11CertificatePrivate {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
}
type PromptIface = typeof Prompt;
type SecretExchangeClass = typeof SecretExchange;
abstract class SecretExchangePrivate {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
}
type SimpleCertificateClass = typeof SimpleCertificate;
abstract class SimpleCertificatePrivate {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
}
type SimpleCollectionClass = typeof SimpleCollection;
abstract class SimpleCollectionPrivate {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
}
type SshAskpassClass = typeof SshAskpass;
type SystemPromptClass = typeof SystemPrompt;
abstract class SystemPromptPrivate {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
}
type SystemPrompterClass = typeof SystemPrompter;
abstract class SystemPrompterPrivate {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
}
type UnionCollectionClass = typeof UnionCollection;
abstract class UnionCollectionPrivate {
static $gtype: GObject.GType;
// 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;
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;
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;
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;
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;
/**
* 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 | 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 | null,
): Promise | 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 | 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;
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;
/**
* 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 | 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 | null,
): Promise | 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 | 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;
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;
/**
* 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 | 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 | null,
): Promise | 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;
/**
* 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 | 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 | null,
): Promise | 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 | 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 | 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