@gtkx/ffi 0.1.44 → 0.1.46

package/dist/generated/gio/debug-controller.js

@@ -1,4 +1,22 @@
 import { call } from "@gtkx/native";
+/**
+ * `GDebugController` is an interface to expose control of debugging features and
+ * debug output.
+ *
+ * It is implemented on Linux using [class@Gio.DebugControllerDBus], which
+ * exposes a D-Bus interface to allow authenticated peers to control debug
+ * features in this process.
+ *
+ * Whether debug output is enabled is exposed as
+ * [property@Gio.DebugController:debug-enabled]. This controls
+ * [func@GLib.log_set_debug_enabled] by default. Application code may
+ * connect to the [signal@GObject.Object::notify] signal for it
+ * to control other parts of its debug infrastructure as necessary.
+ *
+ * If your application or service is using the default GLib log writer function,
+ * creating one of the built-in implementations of `GDebugController` should be
+ * all that’s needed to dynamically enable or disable debug output.
+ */
 export class DebugController {
     ptr;
     constructor(ptr) {
@@ -7,6 +25,9 @@ export class DebugController {
     static fromPtr(ptr) {
         return new DebugController(ptr);
     }
+    /**
+     * Get the value of #GDebugController:debug-enabled.
+     */
     getDebugEnabled() {
         return call("libgio-2.0.so.0", "g_debug_controller_get_debug_enabled", [
             {
@@ -15,6 +36,10 @@ export class DebugController {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Set the value of #GDebugController:debug-enabled.
+     * @param debugEnabled - %TRUE if debug output should be exposed, %FALSE otherwise
+     */
     setDebugEnabled(debugEnabled) {
         call("libgio-2.0.so.0", "g_debug_controller_set_debug_enabled", [
             {

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

@@ -4,36 +4,204 @@ import { Cancellable } from "./cancellable.js";
 import { Icon } from "./icon.js";
 import { MountOperation } from "./mount-operation.js";
 import { Volume } from "./volume.js";
+/**
+ * `GDrive` represents a piece of hardware connected to the machine.
+ * It’s generally only created for removable hardware or hardware with
+ * removable media. For example, an optical disc drive, or a USB flash drive.
+ *
+ * `GDrive` is a container class for [iface@Gio.Volume] objects that stem from
+ * the same piece of media. As such, `GDrive` abstracts a drive with
+ * (or without) removable media and provides operations for querying
+ * whether media is available, determining whether media change is
+ * automatically detected and ejecting the media.
+ *
+ * If the `GDrive` reports that media isn’t automatically detected, one
+ * can poll for media; typically one should not do this periodically
+ * as a poll for media operation is potentially expensive and may
+ * spin up the drive creating noise.
+ *
+ * `GDrive` supports starting and stopping drives with authentication
+ * support for the former. This can be used to support a diverse set
+ * of use cases including connecting/disconnecting iSCSI devices,
+ * powering down external disk enclosures and starting/stopping
+ * multi-disk devices such as RAID devices. Note that the actual
+ * semantics and side-effects of starting/stopping a `GDrive` may vary
+ * according to implementation. To choose the correct verbs in e.g. a
+ * file manager, use [method@Gio.Drive.get_start_stop_type].
+ *
+ * For porting from GnomeVFS note that there is no
+ * equivalent of `GDrive` in that API.
+ */
 export declare class Drive {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Drive;
+    /**
+     * Checks if a drive can be ejected.
+     */
     canEject(): boolean;
+    /**
+     * Checks if a drive can be polled for media changes.
+     */
     canPollForMedia(): boolean;
+    /**
+     * Checks if a drive can be started.
+     */
     canStart(): boolean;
+    /**
+     * Checks if a drive can be started degraded.
+     */
     canStartDegraded(): boolean;
+    /**
+     * Checks if a drive can be stopped.
+     */
     canStop(): boolean;
+    /**
+     * Asynchronously ejects a drive.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_eject_finish() to obtain the
+     * result of the operation.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     eject(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes ejecting a drive.
+     * @param result - a #GAsyncResult.
+     */
     ejectFinish(result: AsyncResult): boolean;
+    /**
+     * Ejects a drive. This is an asynchronous operation, and is
+     * finished by calling g_drive_eject_with_operation_finish() with the `drive` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     ejectWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes ejecting a drive. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     ejectWithOperationFinish(result: AsyncResult): boolean;
+    /**
+     * Gets the kinds of identifiers that `drive` has.
+     * Use g_drive_get_identifier() to obtain the identifiers
+     * themselves.
+     */
     enumerateIdentifiers(): string[];
+    /**
+     * Gets the icon for @drive.
+     */
     getIcon(): Icon;
+    /**
+     * Gets the identifier of the given kind for @drive. The only
+     * identifier currently available is
+     * %G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE.
+     * @param kind - the kind of identifier to return
+     */
     getIdentifier(kind: string): string | null;
+    /**
+     * Gets the name of @drive.
+     */
     getName(): string;
+    /**
+     * Gets the sort key for @drive, if any.
+     */
     getSortKey(): string | null;
+    /**
+     * Gets a hint about how a drive can be started/stopped.
+     */
     getStartStopType(): DriveStartStopType;
+    /**
+     * Gets the icon for @drive.
+     */
     getSymbolicIcon(): Icon;
+    /**
+     * Get a list of mountable volumes for @drive.
+     *
+     * The returned list should be freed with g_list_free(), after
+     * its elements have been unreffed with g_object_unref().
+     */
     getVolumes(): Volume[];
+    /**
+     * Checks if the `drive` has media. Note that the OS may not be polling
+     * the drive for media changes; see g_drive_is_media_check_automatic()
+     * for more details.
+     */
     hasMedia(): boolean;
+    /**
+     * Check if `drive` has any mountable volumes.
+     */
     hasVolumes(): boolean;
+    /**
+     * Checks if `drive` is capable of automatically detecting media changes.
+     */
     isMediaCheckAutomatic(): boolean;
+    /**
+     * Checks if the `drive` supports removable media.
+     */
     isMediaRemovable(): boolean;
+    /**
+     * Checks if the #GDrive and/or its media is considered removable by the user.
+     * See g_drive_is_media_removable().
+     */
     isRemovable(): boolean;
+    /**
+     * Asynchronously polls `drive` to see if media has been inserted or removed.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_poll_for_media_finish() to obtain the
+     * result of the operation.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     pollForMedia(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an operation started with g_drive_poll_for_media() on a drive.
+     * @param result - a #GAsyncResult.
+     */
     pollForMediaFinish(result: AsyncResult): boolean;
+    /**
+     * Asynchronously starts a drive.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_start_finish() to obtain the
+     * result of the operation.
+     * @param flags - flags affecting the start operation.
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     start(flags: DriveStartFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes starting a drive.
+     * @param result - a #GAsyncResult.
+     */
     startFinish(result: AsyncResult): boolean;
+    /**
+     * Asynchronously stops a drive.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_stop_finish() to obtain the
+     * result of the operation.
+     * @param flags - flags affecting the unmount if required for stopping.
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     stop(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes stopping a drive.
+     * @param result - a #GAsyncResult.
+     */
     stopFinish(result: AsyncResult): boolean;
 }

package/dist/generated/gio/drive.js

@@ -2,6 +2,34 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { Icon } from "./icon.js";
 import { Volume } from "./volume.js";
+/**
+ * `GDrive` represents a piece of hardware connected to the machine.
+ * It’s generally only created for removable hardware or hardware with
+ * removable media. For example, an optical disc drive, or a USB flash drive.
+ *
+ * `GDrive` is a container class for [iface@Gio.Volume] objects that stem from
+ * the same piece of media. As such, `GDrive` abstracts a drive with
+ * (or without) removable media and provides operations for querying
+ * whether media is available, determining whether media change is
+ * automatically detected and ejecting the media.
+ *
+ * If the `GDrive` reports that media isn’t automatically detected, one
+ * can poll for media; typically one should not do this periodically
+ * as a poll for media operation is potentially expensive and may
+ * spin up the drive creating noise.
+ *
+ * `GDrive` supports starting and stopping drives with authentication
+ * support for the former. This can be used to support a diverse set
+ * of use cases including connecting/disconnecting iSCSI devices,
+ * powering down external disk enclosures and starting/stopping
+ * multi-disk devices such as RAID devices. Note that the actual
+ * semantics and side-effects of starting/stopping a `GDrive` may vary
+ * according to implementation. To choose the correct verbs in e.g. a
+ * file manager, use [method@Gio.Drive.get_start_stop_type].
+ *
+ * For porting from GnomeVFS note that there is no
+ * equivalent of `GDrive` in that API.
+ */
 export class Drive {
     ptr;
     constructor(ptr) {
@@ -10,6 +38,9 @@ export class Drive {
     static fromPtr(ptr) {
         return new Drive(ptr);
     }
+    /**
+     * Checks if a drive can be ejected.
+     */
     canEject() {
         return call("libgio-2.0.so.0", "g_drive_can_eject", [
             {
@@ -18,6 +49,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a drive can be polled for media changes.
+     */
     canPollForMedia() {
         return call("libgio-2.0.so.0", "g_drive_can_poll_for_media", [
             {
@@ -26,6 +60,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a drive can be started.
+     */
     canStart() {
         return call("libgio-2.0.so.0", "g_drive_can_start", [
             {
@@ -34,6 +71,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a drive can be started degraded.
+     */
     canStartDegraded() {
         return call("libgio-2.0.so.0", "g_drive_can_start_degraded", [
             {
@@ -42,6 +82,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a drive can be stopped.
+     */
     canStop() {
         return call("libgio-2.0.so.0", "g_drive_can_stop", [
             {
@@ -50,6 +93,17 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Asynchronously ejects a drive.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_eject_finish() to obtain the
+     * result of the operation.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     eject(flags, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_drive_eject", [
             {
@@ -77,6 +131,10 @@ export class Drive {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes ejecting a drive.
+     * @param result - a #GAsyncResult.
+     */
     ejectFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_drive_eject_finish", [
@@ -105,6 +163,15 @@ export class Drive {
         }
         return _result;
     }
+    /**
+     * Ejects a drive. This is an asynchronous operation, and is
+     * finished by calling g_drive_eject_with_operation_finish() with the `drive` and #GAsyncResult data returned in the @callback.
+     * @param flags - flags affecting the unmount if required for eject
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data passed to @callback.
+     */
     ejectWithOperation(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_drive_eject_with_operation", [
             {
@@ -137,6 +204,11 @@ export class Drive {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes ejecting a drive. If any errors occurred during the operation,
+     * `error` will be set to contain the errors and %FALSE will be returned.
+     * @param result - a #GAsyncResult.
+     */
     ejectWithOperationFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_drive_eject_with_operation_finish", [
@@ -165,6 +237,11 @@ export class Drive {
         }
         return _result;
     }
+    /**
+     * Gets the kinds of identifiers that `drive` has.
+     * Use g_drive_get_identifier() to obtain the identifiers
+     * themselves.
+     */
     enumerateIdentifiers() {
         return call("libgio-2.0.so.0", "g_drive_enumerate_identifiers", [
             {
@@ -173,6 +250,9 @@ export class Drive {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Gets the icon for @drive.
+     */
     getIcon() {
         const ptr = call("libgio-2.0.so.0", "g_drive_get_icon", [
             {
@@ -182,6 +262,12 @@ export class Drive {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Icon);
     }
+    /**
+     * Gets the identifier of the given kind for @drive. The only
+     * identifier currently available is
+     * %G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE.
+     * @param kind - the kind of identifier to return
+     */
     getIdentifier(kind) {
         return call("libgio-2.0.so.0", "g_drive_get_identifier", [
             {
@@ -194,6 +280,9 @@ export class Drive {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the name of @drive.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_drive_get_name", [
             {
@@ -202,6 +291,9 @@ export class Drive {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the sort key for @drive, if any.
+     */
     getSortKey() {
         return call("libgio-2.0.so.0", "g_drive_get_sort_key", [
             {
@@ -210,6 +302,9 @@ export class Drive {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets a hint about how a drive can be started/stopped.
+     */
     getStartStopType() {
         return call("libgio-2.0.so.0", "g_drive_get_start_stop_type", [
             {
@@ -218,6 +313,9 @@ export class Drive {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the icon for @drive.
+     */
     getSymbolicIcon() {
         const ptr = call("libgio-2.0.so.0", "g_drive_get_symbolic_icon", [
             {
@@ -227,6 +325,12 @@ export class Drive {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Icon);
     }
+    /**
+     * Get a list of mountable volumes for @drive.
+     *
+     * The returned list should be freed with g_list_free(), after
+     * its elements have been unreffed with g_object_unref().
+     */
     getVolumes() {
         const ptrs = call("libgio-2.0.so.0", "g_drive_get_volumes", [
             {
@@ -241,6 +345,11 @@ export class Drive {
         });
         return ptrs.map((ptr) => getObject(ptr, Volume));
     }
+    /**
+     * Checks if the `drive` has media. Note that the OS may not be polling
+     * the drive for media changes; see g_drive_is_media_check_automatic()
+     * for more details.
+     */
     hasMedia() {
         return call("libgio-2.0.so.0", "g_drive_has_media", [
             {
@@ -249,6 +358,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Check if `drive` has any mountable volumes.
+     */
     hasVolumes() {
         return call("libgio-2.0.so.0", "g_drive_has_volumes", [
             {
@@ -257,6 +369,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if `drive` is capable of automatically detecting media changes.
+     */
     isMediaCheckAutomatic() {
         return call("libgio-2.0.so.0", "g_drive_is_media_check_automatic", [
             {
@@ -265,6 +380,9 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if the `drive` supports removable media.
+     */
     isMediaRemovable() {
         return call("libgio-2.0.so.0", "g_drive_is_media_removable", [
             {
@@ -273,6 +391,10 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if the #GDrive and/or its media is considered removable by the user.
+     * See g_drive_is_media_removable().
+     */
     isRemovable() {
         return call("libgio-2.0.so.0", "g_drive_is_removable", [
             {
@@ -281,6 +403,16 @@ export class Drive {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Asynchronously polls `drive` to see if media has been inserted or removed.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_poll_for_media_finish() to obtain the
+     * result of the operation.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     pollForMedia(cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_drive_poll_for_media", [
             {
@@ -304,6 +436,10 @@ export class Drive {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an operation started with g_drive_poll_for_media() on a drive.
+     * @param result - a #GAsyncResult.
+     */
     pollForMediaFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_drive_poll_for_media_finish", [
@@ -332,6 +468,18 @@ export class Drive {
         }
         return _result;
     }
+    /**
+     * Asynchronously starts a drive.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_start_finish() to obtain the
+     * result of the operation.
+     * @param flags - flags affecting the start operation.
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     start(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_drive_start", [
             {
@@ -364,6 +512,10 @@ export class Drive {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes starting a drive.
+     * @param result - a #GAsyncResult.
+     */
     startFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_drive_start_finish", [
@@ -392,6 +544,18 @@ export class Drive {
         }
         return _result;
     }
+    /**
+     * Asynchronously stops a drive.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_drive_stop_finish() to obtain the
+     * result of the operation.
+     * @param flags - flags affecting the unmount if required for stopping.
+     * @param mountOperation - a #GMountOperation or %NULL to avoid
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback, or %NULL.
+     * @param userData - user data to pass to @callback
+     */
     stop(flags, mountOperation, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_drive_stop", [
             {
@@ -424,6 +588,10 @@ export class Drive {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes stopping a drive.
+     * @param result - a #GAsyncResult.
+     */
     stopFinish(result) {
         const error = { value: null };
         const _result = call("libgio-2.0.so.0", "g_drive_stop_finish", [

package/dist/generated/gio/dtls-client-connection.d.ts

@@ -1,13 +1,53 @@
 import { TlsCertificateFlags } from "./enums.js";
 import { SocketConnectable } from "./socket-connectable.js";
 import * as GLib from "../glib/index.js";
+/**
+ * `GDtlsClientConnection` is the client-side subclass of
+ * [iface@Gio.DtlsConnection], representing a client-side DTLS connection.
+ */
 export declare class DtlsClientConnection {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): DtlsClientConnection;
+    /**
+     * Gets the list of distinguished names of the Certificate Authorities
+     * that the server will accept certificates from. This will be set
+     * during the TLS handshake if the server requests a certificate.
+     * Otherwise, it will be %NULL.
+     *
+     * Each item in the list is a #GByteArray which contains the complete
+     * subject DN of the certificate authority.
+     */
     getAcceptedCas(): GLib.ByteArray[];
+    /**
+     * Gets @conn's expected server identity
+     */
     getServerIdentity(): SocketConnectable;
+    /**
+     * Gets @conn's validation flags
+     *
+     * This function does not work as originally designed and is impossible
+     * to use correctly. See #GDtlsClientConnection:validation-flags for more
+     * information.
+     */
     getValidationFlags(): TlsCertificateFlags;
+    /**
+     * Sets @conn's expected server identity, which is used both to tell
+     * servers on virtual hosts which certificate to present, and also
+     * to let `conn` know what name to look for in the certificate when
+     * performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
+     * @param identity - a #GSocketConnectable describing the expected server identity
+     */
     setServerIdentity(identity: SocketConnectable): void;
+    /**
+     * Sets @conn's validation flags, to override the default set of
+     * checks performed when validating a server certificate. By default,
+     * %G_TLS_CERTIFICATE_VALIDATE_ALL is used.
+     *
+     * This function does not work as originally designed and is impossible
+     * to use correctly. See #GDtlsClientConnection:validation-flags for more
+     * information.
+     * @param flags - the #GTlsCertificateFlags to use
+     */
     setValidationFlags(flags: TlsCertificateFlags): void;
 }