@sphereon/idk-lib-conf-settings 0.25.0-SNAPSHOT-build-1d61bce

package/idk-lib-conf-settings.d.mts

@@ -0,0 +1,1054 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface KtList<E> /* extends Collection<E> */ {
+    asJsReadonlyArrayView(): ReadonlyArray<E>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtList": unique symbol;
+    };
+}
+export declare namespace KtList {
+    function fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
+}
+export declare interface KtMap<K, V> {
+    asJsReadonlyMapView(): ReadonlyMap<K, V>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtMap": unique symbol;
+    };
+}
+export declare namespace KtMap {
+    function fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMap<K, V>;
+}
+export declare interface KtMutableList<E> extends KtList<E>/*, MutableCollection<E> */ {
+    asJsArrayView(): Array<E>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtMutableList": unique symbol;
+    } & KtList<any>["__doNotUseOrImplementIt"];
+}
+export declare namespace KtMutableList {
+    function fromJsArray<E>(array: ReadonlyArray<E>): KtMutableList<E>;
+}
+export declare interface KtMutableMap<K, V> extends KtMap<K, V> {
+    asJsMapView(): Map<K, V>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtMutableMap": unique symbol;
+    } & KtMap<any, any>["__doNotUseOrImplementIt"];
+}
+export declare namespace KtMutableMap {
+    function fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMutableMap<K, V>;
+}
+export declare interface KtSet<E> /* extends Collection<E> */ {
+    asJsReadonlySetView(): ReadonlySet<E>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtSet": unique symbol;
+    };
+}
+export declare namespace KtSet {
+    function fromJsSet<E>(set: ReadonlySet<E>): KtSet<E>;
+}
+export declare abstract class Encoding {
+    private constructor();
+    static get BASE64(): Encoding & {
+        get name(): "BASE64";
+        get ordinal(): 0;
+    };
+    static get BASE64URL(): Encoding & {
+        get name(): "BASE64URL";
+        get ordinal(): 1;
+    };
+    static get BASE58BTC(): Encoding & {
+        get name(): "BASE58BTC";
+        get ordinal(): 2;
+    };
+    static get HEX(): Encoding & {
+        get name(): "HEX";
+        get ordinal(): 3;
+    };
+    static get UTF8(): Encoding & {
+        get name(): "UTF8";
+        get ordinal(): 4;
+    };
+    static values(): [typeof Encoding.BASE64, typeof Encoding.BASE64URL, typeof Encoding.BASE58BTC, typeof Encoding.HEX, typeof Encoding.UTF8];
+    static valueOf(value: string): Encoding;
+    get name(): "BASE64" | "BASE64URL" | "BASE58BTC" | "HEX" | "UTF8";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+}
+export declare namespace Encoding {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Encoding;
+    }
+}
+export declare function decodeFromHex(_this_: string): Int8Array;
+export declare function encodeToHex(_this_: Int8Array): string;
+export declare function encodeToBase58Btc(_this_: Int8Array): string;
+export declare function decodeFromBase58Btc(_this_: string): Int8Array;
+export declare function decodeFromBase64Url(_this_: string): Int8Array;
+export declare function encodeToBase64Url(_this_: Int8Array): string;
+export declare function encodeToBase64(_this_: Int8Array, urlSafe?: boolean): string;
+export declare function decodeFromBase64(_this_: string, urlSafe?: boolean): Int8Array;
+export declare function decodeFrom(_this_: string, encoding: Encoding): Int8Array;
+export declare function encodeTo(_this_: Int8Array, encoding: Encoding): string;
+export declare function decodeUrlGraph(_this_: string): string;
+export declare function encodeUrlGraph(_this_: string): string;
+export declare class IdkResult<V, E> {
+    private constructor();
+    get isOk(): boolean;
+    get isErr(): boolean;
+    get value(): V;
+    get error(): E;
+    component1(): Nullable<V>;
+    component2(): Nullable<E>;
+    toString(): string;
+    onSuccess(action: (p0: V) => void): IdkResult<V, E>;
+    onFailure(action: (p0: E) => void): IdkResult<V, E>;
+    map<R>(transform: (p0: V) => R): IdkResult<R, E>;
+    mapError<F>(transform: (p0: E) => F): IdkResult<V, F>;
+    flatMap<R>(transform: (p0: V) => IdkResult<R, E>): IdkResult<R, E>;
+    andThen<R>(transform: (p0: V) => IdkResult<R, E>): IdkResult<R, E>;
+    recover(transform: (p0: E) => V): IdkResult<V, E>;
+    getOr(defaultValue: V): V;
+    getOrElse(transform: (p0: E) => V): V;
+    fold<R>(success: (p0: V) => R, failure: (p0: E) => R): R;
+    mapBoth<R>(success: (p0: V) => R, failure: (p0: E) => R): R;
+    get(): Nullable<V>;
+    getErrorOrNull(): Nullable<E>;
+    getOrNull(): Nullable<V>;
+    errorOrNull(): Nullable<E>;
+    getOrThrow(): V;
+}
+export declare namespace IdkResult {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <V, E>() => IdkResult<V, E>;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                ok<V, E>(value: V): IdkResult<V, E>;
+                err<V, E>(error: E): IdkResult<V, E>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class Ok<V> extends IdkResult.$metadata$.constructor<V, never> {
+    constructor(_value: V);
+    get value(): V;
+    asResult<E>(): IdkResult<V, E>;
+    toString(): string;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+}
+export declare namespace Ok {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <V>() => Ok<V>;
+    }
+}
+export declare class Err<E> extends IdkResult.$metadata$.constructor<never, E> {
+    constructor(_error: E);
+    get error(): E;
+    asResult<V>(): IdkResult<V, E>;
+    toString(): string;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+}
+export declare namespace Err {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <E>() => Err<E>;
+    }
+}
+export declare function IdkIsOk<V, E>(result: IdkResult<V, E>): boolean;
+export declare function IdkIsErr<V, E>(result: IdkResult<V, E>): boolean;
+export declare function IdkGetOrNull<V, E>(result: IdkResult<V, E>): Nullable<V>;
+export declare function IdkErrorOrNull<V, E>(result: IdkResult<V, E>): Nullable<E>;
+export declare function IdkOkResult<V>(value: V): IdkResult<V, never>;
+export declare function IdkErrorResult<E extends IdkErrorType>(error: E): IdkResult<never, E>;
+export declare interface IdkErrorType {
+    readonly code: string;
+    readonly message: IdkError.Message;
+    readonly severity: IdkError.Severity;
+    readonly exception: Nullable<Error>;
+    readonly causes: KtList<IdkErrorType>;
+    readonly meta: KtMap<string, Nullable<any>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.error.IdkErrorType": unique symbol;
+    };
+}
+export declare class IdkError implements IdkErrorType {
+    constructor(code: string, message: IdkError.Message, severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, meta?: KtMap<string, Nullable<any>>, exception?: Nullable<Error>);
+    get code(): string;
+    get message(): IdkError.Message;
+    get severity(): IdkError.Severity;
+    get causes(): KtList<IdkErrorType>;
+    get meta(): KtMap<string, Nullable<any>>;
+    get exception(): Nullable<Error>;
+    hasException(): boolean;
+    hasCauses(): boolean;
+    hasMeta(): boolean;
+    addCause(cause: IdkError): IdkError;
+    toString(): string;
+    static fromDTO(error: IdkErrorType): IdkError;
+    static fromString(message: string, code?: string, exception?: Nullable<Error>/* Nullable<Exception> */, i18nKey?: string, severity?: IdkError.Severity): IdkError;
+    static fromDefinition(definition: ErrorDefinitionType, i18nParams?: KtMap<string, Nullable<any>>, causes?: KtList<IdkError>, meta?: KtMap<string, Nullable<any>>, severity?: IdkError.Severity, exception?: Nullable<Error>): IdkError;
+    static UNKNOWN_ERROR(severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, message?: string, exception?: Nullable<Error>): IdkError;
+    static ILLEGAL_ARGUMENT_ERROR(severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, arg?: Nullable<any>, message?: string, throwable?: Nullable<Error>): IdkError;
+    static COMMAND_ARG_NOT_SUPPORTED_ERROR(severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, command?: Nullable<any>/* Nullable<BaseCommand<UnknownType *, UnknownType *, UnknownType *>> */, arg?: Nullable<any>, message?: string, throwable?: Nullable<Error>): IdkError;
+    static NOT_FOUND_ERROR(severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, resource?: Nullable<string>, message?: string, throwable?: Nullable<Error>): IdkError;
+    static COMMAND_DISABLED_ERROR(commandId: string, severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, throwable?: Nullable<Error>): IdkError;
+    static COMMAND_SKIPPED_ERROR(commandId: string, reason?: Nullable<string>, severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, throwable?: Nullable<Error>): IdkError;
+    static COMMAND_NOT_AUTHORIZED_ERROR(commandId: string, reason: string, actor?: Nullable<string>, severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, throwable?: Nullable<Error>): IdkError;
+    static ALL_HANDLERS_FAILED_ERROR(errors: KtList<IdkError>, severity?: IdkError.Severity, throwable?: Nullable<Error>): IdkError;
+    static UNAUTHORIZED_ERROR(message?: string, severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, throwable?: Nullable<Error>): IdkError;
+    static FORBIDDEN_ERROR(message?: string, severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, throwable?: Nullable<Error>): IdkError;
+    static ALREADY_EXISTS_ERROR(severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, resource?: Nullable<string>, message?: string, throwable?: Nullable<Error>): IdkError;
+    static INVALID_STATE(severity?: IdkError.Severity, causes?: KtList<IdkErrorType>, message?: string, throwable?: Nullable<Error>): IdkError;
+    readonly __doNotUseOrImplementIt: IdkErrorType["__doNotUseOrImplementIt"];
+}
+export declare namespace IdkError {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => IdkError;
+    }
+    abstract class Severity {
+        private constructor();
+        static get INFO(): IdkError.Severity & {
+            get name(): "INFO";
+            get ordinal(): 0;
+        };
+        static get WARNING(): IdkError.Severity & {
+            get name(): "WARNING";
+            get ordinal(): 1;
+        };
+        static get ERROR(): IdkError.Severity & {
+            get name(): "ERROR";
+            get ordinal(): 2;
+        };
+        static get FATAL(): IdkError.Severity & {
+            get name(): "FATAL";
+            get ordinal(): 3;
+        };
+        static values(): [typeof IdkError.Severity.INFO, typeof IdkError.Severity.WARNING, typeof IdkError.Severity.ERROR, typeof IdkError.Severity.FATAL];
+        static valueOf(value: string): IdkError.Severity;
+        get name(): "INFO" | "WARNING" | "ERROR" | "FATAL";
+        get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
+        isAtLeast(severity: IdkError.Severity): boolean;
+        isAtMost(severity: IdkError.Severity): boolean;
+    }
+    namespace Severity {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => Severity;
+        }
+    }
+    class Message {
+        constructor(i18nKey: string, i18nParams: KtMap<string, Nullable<any>> | undefined, defaultMessage: string);
+        get i18nKey(): string;
+        get i18nParams(): KtMap<string, Nullable<any>>;
+        get defaultMessage(): string;
+        copy(i18nKey?: string, i18nParams?: KtMap<string, Nullable<any>>, defaultMessage?: string): IdkError.Message;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace Message {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => Message;
+        }
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface ErrorDefinitionType {
+    readonly code: string;
+    readonly i18nKey: string;
+    readonly defaultMessage: string;
+    readonly severity: IdkError.Severity;
+    asError(i18nParams?: KtMap<string, Nullable<any>>, exception?: Nullable<Error>, causes?: KtList<IdkError>, meta?: KtMap<string, Nullable<any>>, severity?: IdkError.Severity): IdkError;
+    asResult(i18nParams?: KtMap<string, Nullable<any>>, exception?: Nullable<Error>, causes?: KtList<IdkError>, meta?: KtMap<string, Nullable<any>>, severity?: IdkError.Severity): IdkResult<never, IdkError>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.error.ErrorDefinitionType": unique symbol;
+    };
+}
+export declare const jsonSerializer: {
+    get(): any/* Json */;
+};
+export declare abstract class JsonSupport {
+    static readonly getInstance: () => typeof JsonSupport.$metadata$.type;
+    private constructor();
+}
+export declare namespace JsonSupport {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            register(registrationId: Nullable<string> | undefined, block: (p0: any/* SerializersModuleBuilder */) => void): void;
+            get module(): any/* SerializersModule */;
+            get serializer(): any/* Json */;
+            private constructor();
+        }
+    }
+}
+export declare abstract class LogOutputFormat {
+    private constructor();
+    static get TEXT(): LogOutputFormat & {
+        get name(): "TEXT";
+        get ordinal(): 0;
+    };
+    static get JSON(): LogOutputFormat & {
+        get name(): "JSON";
+        get ordinal(): 1;
+    };
+    static values(): [typeof LogOutputFormat.TEXT, typeof LogOutputFormat.JSON];
+    static valueOf(value: string): LogOutputFormat;
+    get name(): "TEXT" | "JSON";
+    get ordinal(): 0 | 1;
+}
+export declare namespace LogOutputFormat {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => LogOutputFormat;
+    }
+}
+export declare class LogMessage {
+    constructor(level: LogLevel | undefined, message: string, tag?: Nullable<string>, exception?: Nullable<Error>, errorResult?: Nullable<IdkResult<never, any /*UnknownType **/>>, metadata?: Nullable<KtMap<string, string>>, timestamp?: bigint);
+    get level(): LogLevel;
+    get message(): string;
+    get tag(): Nullable<string>;
+    get exception(): Nullable<Error>;
+    get errorResult(): Nullable<IdkResult<never, any /*UnknownType **/>>;
+    get metadata(): Nullable<KtMap<string, string>>;
+    get timestamp(): bigint;
+    copy(level?: LogLevel, message?: string, tag?: Nullable<string>, exception?: Nullable<Error>, errorResult?: Nullable<IdkResult<never, any /*UnknownType **/>>, metadata?: Nullable<KtMap<string, string>>, timestamp?: bigint): LogMessage;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace LogMessage {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => LogMessage;
+    }
+}
+export declare abstract class LogLevel {
+    private constructor();
+    static get TRACE(): LogLevel & {
+        get name(): "TRACE";
+        get ordinal(): 0;
+    };
+    static get DEBUG(): LogLevel & {
+        get name(): "DEBUG";
+        get ordinal(): 1;
+    };
+    static get INFO(): LogLevel & {
+        get name(): "INFO";
+        get ordinal(): 2;
+    };
+    static get WARN(): LogLevel & {
+        get name(): "WARN";
+        get ordinal(): 3;
+    };
+    static get ERROR(): LogLevel & {
+        get name(): "ERROR";
+        get ordinal(): 4;
+    };
+    static get OFF(): LogLevel & {
+        get name(): "OFF";
+        get ordinal(): 5;
+    };
+    static values(): [typeof LogLevel.TRACE, typeof LogLevel.DEBUG, typeof LogLevel.INFO, typeof LogLevel.WARN, typeof LogLevel.ERROR, typeof LogLevel.OFF];
+    static valueOf(value: string): LogLevel;
+    get name(): "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "OFF";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+    get value(): number;
+    toString(): string;
+}
+export declare namespace LogLevel {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => LogLevel;
+    }
+}
+export declare class LoggerConfig {
+    constructor(minLevel?: LogLevel, tag?: string, outputFormat?: LogOutputFormat, includeTimestamp?: boolean);
+    get minLevel(): LogLevel;
+    get tag(): string;
+    get outputFormat(): LogOutputFormat;
+    get includeTimestamp(): boolean;
+    isEnabled(level: LogLevel): boolean;
+    disable(): LoggerConfig;
+    copy(minLevel?: LogLevel, tag?: string, outputFormat?: LogOutputFormat, includeTimestamp?: boolean): LoggerConfig;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    static get Disabled(): LoggerConfig;
+    static get Debug(): LoggerConfig;
+    static get Default(): LoggerConfig;
+    static get JsonWithTimestamp(): LoggerConfig;
+}
+export declare namespace LoggerConfig {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => LoggerConfig;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface BaseChainCommand<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> /* extends BaseCommand<Arg, SuccessResult, ErrorResult> */ {
+    readonly next: Nullable<any>/* Nullable<BaseCommand<Arg, SuccessResult, ErrorResult>> */;
+    readonly config: IChainCommandConfig;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.BaseChainCommand": unique symbol;
+    };
+}
+export declare interface IChainCommandConfig {
+    readonly minExecutions: number;
+    readonly maxExecutions: Nullable<number>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.IChainCommandConfig": unique symbol;
+    };
+}
+export declare interface BasePipelineCommand<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> /* extends BaseCommand<Arg, SuccessResult, ErrorResult> */ {
+    readonly commands: KtMutableList<any/* BaseCommand<UnknownType *, UnknownType *, UnknownType *> */>;
+    addCommand(filter: any/* BaseCommand<UnknownType *, UnknownType *, UnknownType *> */): BasePipelineCommand<Arg, SuccessResult, ErrorResult>;
+    removeCommand(filter: any/* BaseCommand<UnknownType *, UnknownType *, UnknownType *> */): BasePipelineCommand<Arg, SuccessResult, ErrorResult>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.BasePipelineCommand": unique symbol;
+    };
+}
+export declare interface Command<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> /* extends HasId, BaseCommand<Arg, SuccessResult, ErrorResult> */ {
+    readonly isEnabled: boolean;
+    readonly subsystem: any/* EventSubsystem */;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.Command": unique symbol;
+    };
+}
+export declare interface ChainCommand<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> extends Command<Arg, SuccessResult, ErrorResult>, BaseChainCommand<Arg, SuccessResult, ErrorResult> {
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.ChainCommand": unique symbol;
+    } & BaseChainCommand<any, any, any>["__doNotUseOrImplementIt"] & Command<any, any, any>["__doNotUseOrImplementIt"];
+}
+export declare interface PipelineCommand<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> extends Command<Arg, SuccessResult, ErrorResult>, BasePipelineCommand<Arg, SuccessResult, ErrorResult> {
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.PipelineCommand": unique symbol;
+    } & BasePipelineCommand<any, any, any>["__doNotUseOrImplementIt"] & Command<any, any, any>["__doNotUseOrImplementIt"];
+}
+export declare interface MultiService<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> extends PipelineCommand<Arg, SuccessResult, ErrorResult> {
+    readonly commands: KtMutableList<Command<Arg, SuccessResult, ErrorResult>>;
+    hasId(id: string): boolean;
+    getById(id: string): Nullable<Command<Arg, SuccessResult, ErrorResult>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.MultiService": unique symbol;
+    } & PipelineCommand<any, any, any>["__doNotUseOrImplementIt"];
+}
+export declare interface ICommandInitExtension<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> {
+    beforeInit(service: Command<Arg, SuccessResult, ErrorResult>): void;
+    afterInit(service: Command<Arg, SuccessResult, ErrorResult>): void;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.ICommandInitExtension": unique symbol;
+    };
+}
+export declare abstract class CommandExecutionPhase {
+    private constructor();
+    static get BEFORE(): CommandExecutionPhase & {
+        get name(): "BEFORE";
+        get ordinal(): 0;
+    };
+    static get DURING(): CommandExecutionPhase & {
+        get name(): "DURING";
+        get ordinal(): 1;
+    };
+    static get AFTER(): CommandExecutionPhase & {
+        get name(): "AFTER";
+        get ordinal(): 2;
+    };
+    static values(): [typeof CommandExecutionPhase.BEFORE, typeof CommandExecutionPhase.DURING, typeof CommandExecutionPhase.AFTER];
+    static valueOf(value: string): CommandExecutionPhase;
+    get name(): "BEFORE" | "DURING" | "AFTER";
+    get ordinal(): 0 | 1 | 2;
+}
+export declare namespace CommandExecutionPhase {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CommandExecutionPhase;
+    }
+}
+export declare interface ICommandExecutionExtension<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> {
+    beforeExecute(service: Command<Arg, SuccessResult, ErrorResult>, args: Arg): void;
+    duringExecute(service: Command<Arg, SuccessResult, ErrorResult>, args: Arg): Arg;
+    afterExecute(service: Command<Arg, SuccessResult, ErrorResult>, args: Arg, result: IdkResult<SuccessResult, ErrorResult>): void;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.ICommandExecutionExtension": unique symbol;
+    };
+}
+export declare interface ICommandExecutionListener<Arg extends any, SuccessResult extends any, ErrorResult extends IdkErrorType> {
+    onBeforeExecute(serviceId: string, args: Arg): void;
+    onDuringExecute(serviceId: string, args: Arg): Arg;
+    onAfterExecute(serviceId: string, args: Arg, result: IdkResult<SuccessResult, ErrorResult>): void;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.core.api.session.ICommandExecutionListener": unique symbol;
+    };
+}
+export declare function kmpListOf<T>(elements: Array<T>): KtList<T>;
+export declare function kmpSetOf<T>(elements: Array<T>): KtSet<T>;
+export declare function kmpMapOf<K, V>(): KtMutableMap<K, V>;
+export declare class LocalDateTimeKMP /* implements Comparable<LocalDateTimeKMP> */ {
+    constructor(year: number, month: number, day: number, hour: number, minute: number, second?: number, nanosecond?: number);
+    get year(): number;
+    get month(): number;
+    get day(): number;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get nanosecond(): number;
+    toMdocTdateString(): string;
+    toString(): string;
+    toEpochSeconds(timeZoneId?: Nullable<string>): bigint;
+    toInstant(utils?: DateTimeUtils, timeZoneId?: Nullable<string>): any/* Instant */;
+    static now(): LocalDateTimeKMP;
+    static nowWithTimezone(utils?: DateTimeUtils, timeZoneId?: Nullable<string>): LocalDateTimeKMP;
+    static fromString(value: string): LocalDateTimeKMP;
+}
+export declare namespace LocalDateTimeKMP {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => LocalDateTimeKMP;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class DateTimeUtils {
+    constructor(clock?: any/* Clock */, timeZoneId?: string);
+    get clock(): any/* Clock */;
+    set clock(value: any/* Clock */);
+    get timeZoneId(): string;
+    set timeZoneId(value: string);
+    epochSeconds(): number;
+    dateTimeUTC(epochSeconds?: Nullable<number>): LocalDateTimeKMP;
+    dateTimeLocal(epochSeconds?: Nullable<number>): LocalDateTimeKMP;
+    dateTime(timeZoneId?: Nullable<string>, epochSeconds?: Nullable<number>): LocalDateTimeKMP;
+    dateLocalISO(epochSeconds?: Nullable<number>): string;
+    dateISO(timeZoneId: Nullable<string>, epochSeconds?: Nullable<number>): string;
+    timeZone(timeZoneId: Nullable<string>): any/* TimeZone */;
+    static get DEFAULTS(): DateTimeUtils;
+}
+export declare namespace DateTimeUtils {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DateTimeUtils;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class DateTimeUtilsDefault {
+    static readonly getInstance: () => typeof DateTimeUtilsDefault.$metadata$.type;
+    private constructor();
+}
+export declare namespace DateTimeUtilsDefault {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            get INSTANCE(): DateTimeUtils;
+            private constructor();
+        }
+    }
+}
+export declare abstract class Uuid {
+    static readonly getInstance: () => typeof Uuid.$metadata$.type;
+    private constructor();
+}
+export declare namespace Uuid {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            v4(): any/* Uuid */;
+            v4String(): string;
+            private constructor();
+        }
+    }
+}
+export declare class TenantContextDataImpl implements TenantContextData {
+    constructor(tenantId: string);
+    get tenantId(): string;
+    toString(): string;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    readonly __doNotUseOrImplementIt: TenantContextData["__doNotUseOrImplementIt"];
+}
+export declare namespace TenantContextDataImpl {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => TenantContextDataImpl;
+    }
+}
+export declare interface UserContext extends TenantAware, PrincipalAware {
+    readonly id: string;
+    readonly secureDetails: Nullable<SecuredTenantContextDetails>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.UserContext": unique symbol;
+    } & PrincipalAware["__doNotUseOrImplementIt"] & TenantAware["__doNotUseOrImplementIt"];
+}
+export declare namespace UserContext {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get BACKGROUND_SERVICE(): string;
+                get ANONYMOUS(): string;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface SecuredTenantContextDetails {
+    readonly validFrom: bigint;
+    readonly validUntil: bigint;
+    readonly iss: string;
+    readonly jwt: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.SecuredTenantContextDetails": unique symbol;
+    };
+}
+export declare interface UserSecuredContext extends UserContext {
+    readonly secureDetails: SecuredTenantContextDetails;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.UserSecuredContext": unique symbol;
+    } & UserContext["__doNotUseOrImplementIt"];
+}
+export declare interface ContextAware {
+    readonly context: UserContext;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.ContextAware": unique symbol;
+    };
+}
+export declare interface TenantAware {
+    readonly tenant: TenantContextData;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.TenantAware": unique symbol;
+    };
+}
+export declare interface PrincipalAware {
+    readonly principal: Nullable<any>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.PrincipalAware": unique symbol;
+    };
+}
+export declare interface TenantContextData {
+    readonly tenantId: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.context.TenantContextData": unique symbol;
+    };
+}
+export declare abstract class UserScope {
+}
+export declare namespace UserScope {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => UserScope;
+    }
+}
+export declare interface ISessionContextAware {
+    readonly sessionContext: ContextAware/* SessionContext */;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.di.session.ISessionContextAware": unique symbol;
+    };
+}
+export declare abstract class SessionScope {
+}
+export declare namespace SessionScope {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => SessionScope;
+    }
+}
+export declare interface PromptRegistry {
+    validatePairing(request: PromptRequest, response: PromptResponse): Nullable<string>;
+    isRequestTypeRegistered(request: PromptRequest): boolean;
+    getExpectedResponseType(request: PromptRequest): Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.ui.prompt.coordinator.PromptRegistry": unique symbol;
+    };
+}
+export declare abstract class CancelReason {
+    private constructor();
+    static get USER(): CancelReason & {
+        get name(): "USER";
+        get ordinal(): 0;
+    };
+    static get SUPERSEDED(): CancelReason & {
+        get name(): "SUPERSEDED";
+        get ordinal(): 1;
+    };
+    static get BACKGROUND(): CancelReason & {
+        get name(): "BACKGROUND";
+        get ordinal(): 2;
+    };
+    static get SYSTEM(): CancelReason & {
+        get name(): "SYSTEM";
+        get ordinal(): 3;
+    };
+    static values(): [typeof CancelReason.USER, typeof CancelReason.SUPERSEDED, typeof CancelReason.BACKGROUND, typeof CancelReason.SYSTEM];
+    static valueOf(value: string): CancelReason;
+    get name(): "USER" | "SUPERSEDED" | "BACKGROUND" | "SYSTEM";
+    get ordinal(): 0 | 1 | 2 | 3;
+}
+export declare namespace CancelReason {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CancelReason;
+    }
+}
+export declare class PromptPresentationHint {
+    constructor(priority?: PromptPriority, deferUntilForeground?: boolean, timeout?: Nullable<any>/* Nullable<Duration> */, dismissOnBackground?: boolean, showOverLockScreen?: boolean);
+    get priority(): PromptPriority;
+    get deferUntilForeground(): boolean;
+    get timeout(): Nullable<any>/* Nullable<Duration> */;
+    get dismissOnBackground(): boolean;
+    get showOverLockScreen(): boolean;
+    copy(priority?: PromptPriority, deferUntilForeground?: boolean, timeout?: Nullable<any>/* Nullable<Duration> */, dismissOnBackground?: boolean, showOverLockScreen?: boolean): PromptPresentationHint;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PromptPresentationHint {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PromptPresentationHint;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get DEFAULT(): PromptPresentationHint;
+                get CRITICAL(): PromptPresentationHint;
+                get DEFERRED(): PromptPresentationHint;
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class PromptPriority {
+    private constructor();
+    static get CRITICAL(): PromptPriority & {
+        get name(): "CRITICAL";
+        get ordinal(): 0;
+    };
+    static get HIGH(): PromptPriority & {
+        get name(): "HIGH";
+        get ordinal(): 1;
+    };
+    static get NORMAL(): PromptPriority & {
+        get name(): "NORMAL";
+        get ordinal(): 2;
+    };
+    static get LOW(): PromptPriority & {
+        get name(): "LOW";
+        get ordinal(): 3;
+    };
+    static get BACKGROUND(): PromptPriority & {
+        get name(): "BACKGROUND";
+        get ordinal(): 4;
+    };
+    static values(): [typeof PromptPriority.CRITICAL, typeof PromptPriority.HIGH, typeof PromptPriority.NORMAL, typeof PromptPriority.LOW, typeof PromptPriority.BACKGROUND];
+    static valueOf(value: string): PromptPriority;
+    get name(): "CRITICAL" | "HIGH" | "NORMAL" | "LOW" | "BACKGROUND";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    get order(): number;
+    isHigherThan(other: PromptPriority): boolean;
+    isAtLeast(other: PromptPriority): boolean;
+}
+export declare namespace PromptPriority {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PromptPriority;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                sortedByPriority(): KtList<PromptPriority>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface PromptRequest {
+    readonly id: any/* PromptId */;
+    readonly presentationHint: PromptPresentationHint;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.ui.prompt.core.PromptRequest": unique symbol;
+    };
+}
+export declare interface SinglePromptRequest extends PromptRequest {
+    readonly show: boolean;
+    readonly title: string;
+    readonly subtitle: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.ui.prompt.core.SinglePromptRequest": unique symbol;
+    } & PromptRequest["__doNotUseOrImplementIt"];
+}
+export declare class NfcPromptRequest implements SinglePromptRequest {
+    constructor(id: any/* PromptId */ | undefined, title: string, subtitle: Nullable<string> | undefined, show: boolean | undefined, presentationHint: PromptPresentationHint | undefined, initialMessage: string, successMessage?: Nullable<string>, errorMessage?: Nullable<string>);
+    get id(): any/* PromptId */;
+    get title(): string;
+    get subtitle(): Nullable<string>;
+    get show(): boolean;
+    get presentationHint(): PromptPresentationHint;
+    get initialMessage(): string;
+    get successMessage(): Nullable<string>;
+    get errorMessage(): Nullable<string>;
+    copy(id?: any/* PromptId */, title?: string, subtitle?: Nullable<string>, show?: boolean, presentationHint?: PromptPresentationHint, initialMessage?: string, successMessage?: Nullable<string>, errorMessage?: Nullable<string>): NfcPromptRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: SinglePromptRequest["__doNotUseOrImplementIt"];
+}
+export declare namespace NfcPromptRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => NfcPromptRequest;
+    }
+}
+export declare class BiometricPromptRequest implements SinglePromptRequest {
+    constructor(id: any/* PromptId */ | undefined, title: string, subtitle: Nullable<string> | undefined, show: boolean | undefined, presentationHint: PromptPresentationHint | undefined, reason: string, fallbackToPasscode?: boolean);
+    get id(): any/* PromptId */;
+    get title(): string;
+    get subtitle(): Nullable<string>;
+    get show(): boolean;
+    get presentationHint(): PromptPresentationHint;
+    get reason(): string;
+    get fallbackToPasscode(): boolean;
+    copy(id?: any/* PromptId */, title?: string, subtitle?: Nullable<string>, show?: boolean, presentationHint?: PromptPresentationHint, reason?: string, fallbackToPasscode?: boolean): BiometricPromptRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: SinglePromptRequest["__doNotUseOrImplementIt"];
+}
+export declare namespace BiometricPromptRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BiometricPromptRequest;
+    }
+}
+export declare class BiometricUnlockPromptRequest implements SinglePromptRequest {
+    constructor(id: any/* PromptId */ | undefined, title: string, subtitle: Nullable<string> | undefined, show: boolean | undefined, presentationHint: PromptPresentationHint | undefined, keyId: string, reason: string, fallbackToPasscode?: boolean);
+    get id(): any/* PromptId */;
+    get title(): string;
+    get subtitle(): Nullable<string>;
+    get show(): boolean;
+    get presentationHint(): PromptPresentationHint;
+    get keyId(): string;
+    get reason(): string;
+    get fallbackToPasscode(): boolean;
+    copy(id?: any/* PromptId */, title?: string, subtitle?: Nullable<string>, show?: boolean, presentationHint?: PromptPresentationHint, keyId?: string, reason?: string, fallbackToPasscode?: boolean): BiometricUnlockPromptRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: SinglePromptRequest["__doNotUseOrImplementIt"];
+}
+export declare namespace BiometricUnlockPromptRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BiometricUnlockPromptRequest;
+    }
+}
+export declare class PassphrasePromptRequest implements SinglePromptRequest {
+    constructor(id: any/* PromptId */ | undefined, title: string, subtitle: Nullable<string> | undefined, show: boolean | undefined, presentationHint: PromptPresentationHint | undefined, purpose: string, minLength?: number, maxLength?: Nullable<number>, isNumericOnly?: boolean);
+    get id(): any/* PromptId */;
+    get title(): string;
+    get subtitle(): Nullable<string>;
+    get show(): boolean;
+    get presentationHint(): PromptPresentationHint;
+    get purpose(): string;
+    get minLength(): number;
+    get maxLength(): Nullable<number>;
+    get isNumericOnly(): boolean;
+    copy(id?: any/* PromptId */, title?: string, subtitle?: Nullable<string>, show?: boolean, presentationHint?: PromptPresentationHint, purpose?: string, minLength?: number, maxLength?: Nullable<number>, isNumericOnly?: boolean): PassphrasePromptRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: SinglePromptRequest["__doNotUseOrImplementIt"];
+}
+export declare namespace PassphrasePromptRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PassphrasePromptRequest;
+    }
+}
+export declare class ConfirmationPromptRequest implements SinglePromptRequest {
+    constructor(id: any/* PromptId */ | undefined, title: string, subtitle: Nullable<string> | undefined, show: boolean | undefined, presentationHint: PromptPresentationHint | undefined, message: string, confirmText?: string, cancelText?: string, isDestructive?: boolean);
+    get id(): any/* PromptId */;
+    get title(): string;
+    get subtitle(): Nullable<string>;
+    get show(): boolean;
+    get presentationHint(): PromptPresentationHint;
+    get message(): string;
+    get confirmText(): string;
+    get cancelText(): string;
+    get isDestructive(): boolean;
+    copy(id?: any/* PromptId */, title?: string, subtitle?: Nullable<string>, show?: boolean, presentationHint?: PromptPresentationHint, message?: string, confirmText?: string, cancelText?: string, isDestructive?: boolean): ConfirmationPromptRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: SinglePromptRequest["__doNotUseOrImplementIt"];
+}
+export declare namespace ConfirmationPromptRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ConfirmationPromptRequest;
+    }
+}
+export declare interface PromptResponse {
+    readonly promptId: any/* PromptId */;
+    readonly state: PromptState;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.ui.prompt.core.PromptResponse": unique symbol;
+    };
+}
+export declare abstract class PromptState {
+    private constructor();
+    static get PENDING(): PromptState & {
+        get name(): "PENDING";
+        get ordinal(): 0;
+    };
+    static get ACTIVE(): PromptState & {
+        get name(): "ACTIVE";
+        get ordinal(): 1;
+    };
+    static get SUCCESS(): PromptState & {
+        get name(): "SUCCESS";
+        get ordinal(): 2;
+    };
+    static get CANCELLED(): PromptState & {
+        get name(): "CANCELLED";
+        get ordinal(): 3;
+    };
+    static get TIMED_OUT(): PromptState & {
+        get name(): "TIMED_OUT";
+        get ordinal(): 4;
+    };
+    static get ERROR(): PromptState & {
+        get name(): "ERROR";
+        get ordinal(): 5;
+    };
+    static values(): [typeof PromptState.PENDING, typeof PromptState.ACTIVE, typeof PromptState.SUCCESS, typeof PromptState.CANCELLED, typeof PromptState.TIMED_OUT, typeof PromptState.ERROR];
+    static valueOf(value: string): PromptState;
+    get name(): "PENDING" | "ACTIVE" | "SUCCESS" | "CANCELLED" | "TIMED_OUT" | "ERROR";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+    get isTerminal(): boolean;
+    get isActive(): boolean;
+    get isPending(): boolean;
+}
+export declare namespace PromptState {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PromptState;
+    }
+}
+export declare abstract class ForegroundState {
+    private constructor();
+    static get FOREGROUND(): ForegroundState & {
+        get name(): "FOREGROUND";
+        get ordinal(): 0;
+    };
+    static get BACKGROUND(): ForegroundState & {
+        get name(): "BACKGROUND";
+        get ordinal(): 1;
+    };
+    static get UNKNOWN(): ForegroundState & {
+        get name(): "UNKNOWN";
+        get ordinal(): 2;
+    };
+    static values(): [typeof ForegroundState.FOREGROUND, typeof ForegroundState.BACKGROUND, typeof ForegroundState.UNKNOWN];
+    static valueOf(value: string): ForegroundState;
+    get name(): "FOREGROUND" | "BACKGROUND" | "UNKNOWN";
+    get ordinal(): 0 | 1 | 2;
+}
+export declare namespace ForegroundState {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ForegroundState;
+    }
+}
+export declare interface PromptPresenter {
+    readonly foregroundState: any/* StateFlow<ForegroundState> */;
+    readonly canPresentPrompts: boolean;
+    onForeground(): void;
+    onBackground(): void;
+    shouldDeferPrompt(request: PromptRequest): boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.ui.prompt.presenter.PromptPresenter": unique symbol;
+    };
+}
+export declare interface WizardStep {
+    readonly id: string;
+    readonly isFinal: boolean;
+    readonly data: Nullable<any>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.sphereon.ui.prompt.wizard.WizardStep": unique symbol;
+    };
+}
+/** @deprecated  */
+export declare const initHook: {
+    get(): any;
+};