@sphereon/idk-lib-conf-theme-core-public 0.25.0-SNAPSHOT-build-1d61bce

package/idk-lib-conf-theme-core-public.d.mts

@@ -0,0 +1,1934 @@
+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;
+};
+export declare class ThemePalette {
+    constructor(seedColor: string, primary: TonalPaletteResult, secondary: TonalPaletteResult, tertiary: TonalPaletteResult, neutral: TonalPaletteResult, error: TonalPaletteResult);
+    get seedColor(): string;
+    get primary(): TonalPaletteResult;
+    get secondary(): TonalPaletteResult;
+    get tertiary(): TonalPaletteResult;
+    get neutral(): TonalPaletteResult;
+    get error(): TonalPaletteResult;
+    copy(seedColor?: string, primary?: TonalPaletteResult, secondary?: TonalPaletteResult, tertiary?: TonalPaletteResult, neutral?: TonalPaletteResult, error?: TonalPaletteResult): ThemePalette;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace ThemePalette {
+    /** @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 () => ThemePalette;
+    }
+}
+export declare class ExtendedThemePalette {
+    constructor(base: ThemePalette, success: TonalPaletteResult, warning: TonalPaletteResult, info: TonalPaletteResult);
+    get base(): ThemePalette;
+    get success(): TonalPaletteResult;
+    get warning(): TonalPaletteResult;
+    get info(): TonalPaletteResult;
+    copy(base?: ThemePalette, success?: TonalPaletteResult, warning?: TonalPaletteResult, info?: TonalPaletteResult): ExtendedThemePalette;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace ExtendedThemePalette {
+    /** @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 () => ExtendedThemePalette;
+    }
+}
+export declare class TonalPaletteResult {
+    constructor(tone0: string, tone10: string, tone20: string, tone30: string, tone40: string, tone50: string, tone60: string, tone70: string, tone80: string, tone90: string, tone95: string, tone99: string, tone100: string);
+    get tone0(): string;
+    get tone10(): string;
+    get tone20(): string;
+    get tone30(): string;
+    get tone40(): string;
+    get tone50(): string;
+    get tone60(): string;
+    get tone70(): string;
+    get tone80(): string;
+    get tone90(): string;
+    get tone95(): string;
+    get tone99(): string;
+    get tone100(): string;
+    copy(tone0?: string, tone10?: string, tone20?: string, tone30?: string, tone40?: string, tone50?: string, tone60?: string, tone70?: string, tone80?: string, tone90?: string, tone95?: string, tone99?: string, tone100?: string): TonalPaletteResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace TonalPaletteResult {
+    /** @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 () => TonalPaletteResult;
+    }
+}
+export declare abstract class ThemeScope {
+    private constructor();
+    static get SYSTEM(): ThemeScope & {
+        get name(): "SYSTEM";
+        get ordinal(): 0;
+    };
+    static get APP(): ThemeScope & {
+        get name(): "APP";
+        get ordinal(): 1;
+    };
+    static get TENANT(): ThemeScope & {
+        get name(): "TENANT";
+        get ordinal(): 2;
+    };
+    static get PRINCIPAL(): ThemeScope & {
+        get name(): "PRINCIPAL";
+        get ordinal(): 3;
+    };
+    static values(): [typeof ThemeScope.SYSTEM, typeof ThemeScope.APP, typeof ThemeScope.TENANT, typeof ThemeScope.PRINCIPAL];
+    static valueOf(value: string): ThemeScope;
+    get name(): "SYSTEM" | "APP" | "TENANT" | "PRINCIPAL";
+    get ordinal(): 0 | 1 | 2 | 3;
+}
+export declare namespace ThemeScope {
+    /** @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 () => ThemeScope;
+    }
+}
+export declare abstract class ThemeTokenType {
+    private constructor();
+    static get COLOR(): ThemeTokenType & {
+        get name(): "COLOR";
+        get ordinal(): 0;
+    };
+    static get DIMENSION(): ThemeTokenType & {
+        get name(): "DIMENSION";
+        get ordinal(): 1;
+    };
+    static get FONT_FAMILY(): ThemeTokenType & {
+        get name(): "FONT_FAMILY";
+        get ordinal(): 2;
+    };
+    static get FONT_WEIGHT(): ThemeTokenType & {
+        get name(): "FONT_WEIGHT";
+        get ordinal(): 3;
+    };
+    static get OPACITY(): ThemeTokenType & {
+        get name(): "OPACITY";
+        get ordinal(): 4;
+    };
+    static get DURATION(): ThemeTokenType & {
+        get name(): "DURATION";
+        get ordinal(): 5;
+    };
+    static get EASING(): ThemeTokenType & {
+        get name(): "EASING";
+        get ordinal(): 6;
+    };
+    static get SHADOW(): ThemeTokenType & {
+        get name(): "SHADOW";
+        get ordinal(): 7;
+    };
+    static get BORDER_WIDTH(): ThemeTokenType & {
+        get name(): "BORDER_WIDTH";
+        get ordinal(): 8;
+    };
+    static get SPACING(): ThemeTokenType & {
+        get name(): "SPACING";
+        get ordinal(): 9;
+    };
+    static get STRING(): ThemeTokenType & {
+        get name(): "STRING";
+        get ordinal(): 10;
+    };
+    static values(): [typeof ThemeTokenType.COLOR, typeof ThemeTokenType.DIMENSION, typeof ThemeTokenType.FONT_FAMILY, typeof ThemeTokenType.FONT_WEIGHT, typeof ThemeTokenType.OPACITY, typeof ThemeTokenType.DURATION, typeof ThemeTokenType.EASING, typeof ThemeTokenType.SHADOW, typeof ThemeTokenType.BORDER_WIDTH, typeof ThemeTokenType.SPACING, typeof ThemeTokenType.STRING];
+    static valueOf(value: string): ThemeTokenType;
+    get name(): "COLOR" | "DIMENSION" | "FONT_FAMILY" | "FONT_WEIGHT" | "OPACITY" | "DURATION" | "EASING" | "SHADOW" | "BORDER_WIDTH" | "SPACING" | "STRING";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+}
+export declare namespace ThemeTokenType {
+    /** @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 () => ThemeTokenType;
+    }
+}
+export declare abstract class ThemeVariant {
+    private constructor();
+    static get LIGHT(): ThemeVariant & {
+        get name(): "LIGHT";
+        get ordinal(): 0;
+    };
+    static get DARK(): ThemeVariant & {
+        get name(): "DARK";
+        get ordinal(): 1;
+    };
+    static get HIGH_CONTRAST(): ThemeVariant & {
+        get name(): "HIGH_CONTRAST";
+        get ordinal(): 2;
+    };
+    static values(): [typeof ThemeVariant.LIGHT, typeof ThemeVariant.DARK, typeof ThemeVariant.HIGH_CONTRAST];
+    static valueOf(value: string): ThemeVariant;
+    get name(): "LIGHT" | "DARK" | "HIGH_CONTRAST";
+    get ordinal(): 0 | 1 | 2;
+}
+export declare namespace ThemeVariant {
+    /** @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 () => ThemeVariant;
+    }
+}
+export declare abstract class DesignSystemPaletteResolver {
+    static readonly getInstance: () => typeof DesignSystemPaletteResolver.$metadata$.type;
+    private constructor();
+}
+export declare namespace DesignSystemPaletteResolver {
+    /** @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 {
+            resolve(config: ThemeColorConfig, variant: ThemeVariant, mapping?: PaletteMapping): KtMap<string, string>;
+            private constructor();
+        }
+    }
+}
+export declare abstract class M3PaletteGenerator {
+    static readonly getInstance: () => typeof M3PaletteGenerator.$metadata$.type;
+    private constructor();
+}
+export declare namespace M3PaletteGenerator {
+    /** @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 {
+            generate(seedHex: string): ThemePalette;
+            generateFromSeeds(primarySeed: string, secondarySeed?: Nullable<string>, tertiarySeed?: Nullable<string>, neutralSeed?: Nullable<string>): ThemePalette;
+            generateExtended(seedHex: string): ExtendedThemePalette;
+            private constructor();
+        }
+    }
+}
+export declare class PaletteRef {
+    constructor(scale: string, stop: number);
+    get scale(): string;
+    get stop(): number;
+    copy(scale?: string, stop?: number): PaletteRef;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PaletteRef {
+    /** @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 () => PaletteRef;
+    }
+}
+export declare class PaletteMapping {
+    constructor(light: KtMap<string, PaletteRef>, dark: KtMap<string, PaletteRef>);
+    get light(): KtMap<string, PaletteRef>;
+    get dark(): KtMap<string, PaletteRef>;
+    copy(light?: KtMap<string, PaletteRef>, dark?: KtMap<string, PaletteRef>): PaletteMapping;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PaletteMapping {
+    /** @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 () => PaletteMapping;
+    }
+}
+export declare class PaletteScale {
+    constructor(s50: string, s100: string, s200: string, s300: string, s400: string, s500: string, s600: string, s700: string, s800: string, s900: string);
+    get s50(): string;
+    get s100(): string;
+    get s200(): string;
+    get s300(): string;
+    get s400(): string;
+    get s500(): string;
+    get s600(): string;
+    get s700(): string;
+    get s800(): string;
+    get s900(): string;
+    get(stop: number): string;
+    copy(s50?: string, s100?: string, s200?: string, s300?: string, s400?: string, s500?: string, s600?: string, s700?: string, s800?: string, s900?: string): PaletteScale;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PaletteScale {
+    /** @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 () => PaletteScale;
+    }
+    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 STOPS(): KtList<number>;
+                fromTonalPalette(palette: any/* TonalPalette */): PaletteScale;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class DesignSystemPalette {
+    constructor(brand: PaletteScale, secondary?: Nullable<PaletteScale>, neutral?: Nullable<PaletteScale>, error?: Nullable<PaletteScale>, success?: Nullable<PaletteScale>, warning?: Nullable<PaletteScale>, info?: Nullable<PaletteScale>, pending?: Nullable<PaletteScale>);
+    get brand(): PaletteScale;
+    get secondary(): Nullable<PaletteScale>;
+    get neutral(): Nullable<PaletteScale>;
+    get error(): Nullable<PaletteScale>;
+    get success(): Nullable<PaletteScale>;
+    get warning(): Nullable<PaletteScale>;
+    get info(): Nullable<PaletteScale>;
+    get pending(): Nullable<PaletteScale>;
+    getScale(role: string): Nullable<PaletteScale>;
+    get definedRoles(): KtList<string>;
+    copy(brand?: PaletteScale, secondary?: Nullable<PaletteScale>, neutral?: Nullable<PaletteScale>, error?: Nullable<PaletteScale>, success?: Nullable<PaletteScale>, warning?: Nullable<PaletteScale>, info?: Nullable<PaletteScale>, pending?: Nullable<PaletteScale>): DesignSystemPalette;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DesignSystemPalette {
+    /** @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 () => DesignSystemPalette;
+    }
+}
+export declare abstract class ThemeColorConfig {
+    private constructor();
+}
+export declare namespace ThemeColorConfig {
+    /** @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 () => ThemeColorConfig;
+    }
+    class SeedColor extends ThemeColorConfig.$metadata$.constructor {
+        constructor(seed: string);
+        get seed(): string;
+        copy(seed?: string): ThemeColorConfig.SeedColor;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace SeedColor {
+        /** @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 () => SeedColor;
+        }
+    }
+    class MultiSeed extends ThemeColorConfig.$metadata$.constructor {
+        constructor(primary: string, secondary?: Nullable<string>, tertiary?: Nullable<string>, neutral?: Nullable<string>);
+        get primary(): string;
+        get secondary(): Nullable<string>;
+        get tertiary(): Nullable<string>;
+        get neutral(): Nullable<string>;
+        copy(primary?: string, secondary?: Nullable<string>, tertiary?: Nullable<string>, neutral?: Nullable<string>): ThemeColorConfig.MultiSeed;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace MultiSeed {
+        /** @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 () => MultiSeed;
+        }
+    }
+    class ExplicitPalettes extends ThemeColorConfig.$metadata$.constructor {
+        constructor(palettes: DesignSystemPalette);
+        get palettes(): DesignSystemPalette;
+        copy(palettes?: DesignSystemPalette): ThemeColorConfig.ExplicitPalettes;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace ExplicitPalettes {
+        /** @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 () => ExplicitPalettes;
+        }
+    }
+    class Hybrid extends ThemeColorConfig.$metadata$.constructor {
+        constructor(palettes: DesignSystemPalette, fallbackSeed?: Nullable<string>);
+        get palettes(): DesignSystemPalette;
+        get fallbackSeed(): Nullable<string>;
+        copy(palettes?: DesignSystemPalette, fallbackSeed?: Nullable<string>): ThemeColorConfig.Hybrid;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace Hybrid {
+        /** @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 () => Hybrid;
+        }
+    }
+}
+export declare abstract class TokenKeyConstants {
+    static readonly getInstance: () => typeof TokenKeyConstants.$metadata$.type;
+    private constructor();
+}
+export declare namespace TokenKeyConstants {
+    /** @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 COLOR_PRIMARY(): string;
+            get COLOR_ON_PRIMARY(): string;
+            get COLOR_PRIMARY_CONTAINER(): string;
+            get COLOR_ON_PRIMARY_CONTAINER(): string;
+            get COLOR_SECONDARY(): string;
+            get COLOR_ON_SECONDARY(): string;
+            get COLOR_SECONDARY_CONTAINER(): string;
+            get COLOR_ON_SECONDARY_CONTAINER(): string;
+            get COLOR_TERTIARY(): string;
+            get COLOR_ON_TERTIARY(): string;
+            get COLOR_TERTIARY_CONTAINER(): string;
+            get COLOR_ON_TERTIARY_CONTAINER(): string;
+            get COLOR_ERROR(): string;
+            get COLOR_ON_ERROR(): string;
+            get COLOR_ERROR_CONTAINER(): string;
+            get COLOR_ON_ERROR_CONTAINER(): string;
+            get COLOR_SURFACE(): string;
+            get COLOR_ON_SURFACE(): string;
+            get COLOR_SURFACE_VARIANT(): string;
+            get COLOR_ON_SURFACE_VARIANT(): string;
+            get COLOR_SURFACE_CONTAINER(): string;
+            get COLOR_SURFACE_CONTAINER_HIGH(): string;
+            get COLOR_SURFACE_CONTAINER_HIGHEST(): string;
+            get COLOR_SURFACE_CONTAINER_LOW(): string;
+            get COLOR_SURFACE_CONTAINER_LOWEST(): string;
+            get COLOR_BACKGROUND(): string;
+            get COLOR_ON_BACKGROUND(): string;
+            get COLOR_OUTLINE(): string;
+            get COLOR_OUTLINE_VARIANT(): string;
+            get COLOR_INVERSE_SURFACE(): string;
+            get COLOR_INVERSE_ON_SURFACE(): string;
+            get COLOR_INVERSE_PRIMARY(): string;
+            get COLOR_SCRIM(): string;
+            get COLOR_SHADOW(): string;
+            get ELEVATION_NONE(): string;
+            get ELEVATION_XS(): string;
+            get ELEVATION_SM(): string;
+            get ELEVATION_MD(): string;
+            get ELEVATION_LG(): string;
+            get ELEVATION_XL(): string;
+            get TYPOGRAPHY_FONT_FAMILY(): string;
+            get TYPOGRAPHY_FONT_FAMILY_MONO(): string;
+            get TYPOGRAPHY_DISPLAY_LARGE_FONT_FAMILY(): string;
+            get TYPOGRAPHY_DISPLAY_LARGE_FONT_SIZE(): string;
+            get TYPOGRAPHY_DISPLAY_LARGE_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_LARGE_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_LARGE_LETTER_SPACING(): string;
+            get TYPOGRAPHY_DISPLAY_MEDIUM_FONT_FAMILY(): string;
+            get TYPOGRAPHY_DISPLAY_MEDIUM_FONT_SIZE(): string;
+            get TYPOGRAPHY_DISPLAY_MEDIUM_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_MEDIUM_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_MEDIUM_LETTER_SPACING(): string;
+            get TYPOGRAPHY_DISPLAY_SMALL_FONT_FAMILY(): string;
+            get TYPOGRAPHY_DISPLAY_SMALL_FONT_SIZE(): string;
+            get TYPOGRAPHY_DISPLAY_SMALL_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_SMALL_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_SMALL_LETTER_SPACING(): string;
+            get TYPOGRAPHY_HEADLINE_LARGE_FONT_FAMILY(): string;
+            get TYPOGRAPHY_HEADLINE_LARGE_FONT_SIZE(): string;
+            get TYPOGRAPHY_HEADLINE_LARGE_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_HEADLINE_LARGE_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_HEADLINE_LARGE_LETTER_SPACING(): string;
+            get TYPOGRAPHY_HEADLINE_MEDIUM_FONT_FAMILY(): string;
+            get TYPOGRAPHY_HEADLINE_MEDIUM_FONT_SIZE(): string;
+            get TYPOGRAPHY_HEADLINE_MEDIUM_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_HEADLINE_MEDIUM_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_HEADLINE_MEDIUM_LETTER_SPACING(): string;
+            get TYPOGRAPHY_HEADLINE_SMALL_FONT_FAMILY(): string;
+            get TYPOGRAPHY_HEADLINE_SMALL_FONT_SIZE(): string;
+            get TYPOGRAPHY_HEADLINE_SMALL_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_HEADLINE_SMALL_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_HEADLINE_SMALL_LETTER_SPACING(): string;
+            get TYPOGRAPHY_TITLE_LARGE_FONT_FAMILY(): string;
+            get TYPOGRAPHY_TITLE_LARGE_FONT_SIZE(): string;
+            get TYPOGRAPHY_TITLE_LARGE_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_TITLE_LARGE_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_TITLE_LARGE_LETTER_SPACING(): string;
+            get TYPOGRAPHY_TITLE_MEDIUM_FONT_FAMILY(): string;
+            get TYPOGRAPHY_TITLE_MEDIUM_FONT_SIZE(): string;
+            get TYPOGRAPHY_TITLE_MEDIUM_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_TITLE_MEDIUM_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_TITLE_MEDIUM_LETTER_SPACING(): string;
+            get TYPOGRAPHY_TITLE_SMALL_FONT_FAMILY(): string;
+            get TYPOGRAPHY_TITLE_SMALL_FONT_SIZE(): string;
+            get TYPOGRAPHY_TITLE_SMALL_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_TITLE_SMALL_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_TITLE_SMALL_LETTER_SPACING(): string;
+            get TYPOGRAPHY_BODY_LARGE_FONT_FAMILY(): string;
+            get TYPOGRAPHY_BODY_LARGE_FONT_SIZE(): string;
+            get TYPOGRAPHY_BODY_LARGE_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_BODY_LARGE_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_BODY_LARGE_LETTER_SPACING(): string;
+            get TYPOGRAPHY_BODY_MEDIUM_FONT_FAMILY(): string;
+            get TYPOGRAPHY_BODY_MEDIUM_FONT_SIZE(): string;
+            get TYPOGRAPHY_BODY_MEDIUM_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_BODY_MEDIUM_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_BODY_MEDIUM_LETTER_SPACING(): string;
+            get TYPOGRAPHY_BODY_SMALL_FONT_FAMILY(): string;
+            get TYPOGRAPHY_BODY_SMALL_FONT_SIZE(): string;
+            get TYPOGRAPHY_BODY_SMALL_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_BODY_SMALL_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_BODY_SMALL_LETTER_SPACING(): string;
+            get TYPOGRAPHY_LABEL_LARGE_FONT_FAMILY(): string;
+            get TYPOGRAPHY_LABEL_LARGE_FONT_SIZE(): string;
+            get TYPOGRAPHY_LABEL_LARGE_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_LABEL_LARGE_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_LABEL_LARGE_LETTER_SPACING(): string;
+            get TYPOGRAPHY_LABEL_MEDIUM_FONT_FAMILY(): string;
+            get TYPOGRAPHY_LABEL_MEDIUM_FONT_SIZE(): string;
+            get TYPOGRAPHY_LABEL_MEDIUM_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_LABEL_MEDIUM_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_LABEL_MEDIUM_LETTER_SPACING(): string;
+            get TYPOGRAPHY_LABEL_SMALL_FONT_FAMILY(): string;
+            get TYPOGRAPHY_LABEL_SMALL_FONT_SIZE(): string;
+            get TYPOGRAPHY_LABEL_SMALL_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_LABEL_SMALL_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_LABEL_SMALL_LETTER_SPACING(): string;
+            get BRANDING_APP_NAME(): string;
+            get BRANDING_PRIMARY_COLOR(): string;
+            get BRANDING_SECONDARY_COLOR(): string;
+            get BRANDING_LOGO_URL(): string;
+            get BRANDING_LOGO_DARK_URL(): string;
+            get BRANDING_FAVICON_URL(): string;
+            get BRANDING_FONT_RESOURCE_ID(): string;
+            get BRANDING_LOGO_RESOURCE_ID(): string;
+            get BRANDING_LOGO_DARK_RESOURCE_ID(): string;
+            get SHAPE_CORNER_EXTRA_SMALL(): string;
+            get SHAPE_CORNER_SMALL(): string;
+            get SHAPE_CORNER_MEDIUM(): string;
+            get SHAPE_CORNER_LARGE(): string;
+            get SHAPE_CORNER_EXTRA_LARGE(): string;
+            get MOTION_DURATION_SHORT1(): string;
+            get MOTION_DURATION_SHORT2(): string;
+            get MOTION_DURATION_SHORT3(): string;
+            get MOTION_DURATION_SHORT4(): string;
+            get MOTION_DURATION_MEDIUM1(): string;
+            get MOTION_DURATION_MEDIUM2(): string;
+            get MOTION_DURATION_MEDIUM3(): string;
+            get MOTION_DURATION_MEDIUM4(): string;
+            get MOTION_DURATION_LONG1(): string;
+            get MOTION_DURATION_LONG2(): string;
+            get MOTION_DURATION_LONG3(): string;
+            get MOTION_DURATION_LONG4(): string;
+            get MOTION_EASING_STANDARD(): string;
+            get MOTION_EASING_STANDARD_DECELERATE(): string;
+            get MOTION_EASING_STANDARD_ACCELERATE(): string;
+            get MOTION_EASING_EMPHASIZED(): string;
+            get MOTION_EASING_EMPHASIZED_DECELERATE(): string;
+            get MOTION_EASING_EMPHASIZED_ACCELERATE(): string;
+            get MOTION_EASING_LINEAR(): string;
+            get MOTION_THEME_TRANSITION_DURATION(): string;
+            get MOTION_THEME_TRANSITION_EASING(): string;
+            get RESPONSIVE_SCALE_MEDIUM_DISPLAY(): string;
+            get RESPONSIVE_SCALE_MEDIUM_HEADLINE(): string;
+            get RESPONSIVE_SCALE_EXPANDED_DISPLAY(): string;
+            get RESPONSIVE_SCALE_EXPANDED_HEADLINE(): string;
+            get RESPONSIVE_SCALE_EXPANDED_TITLE(): string;
+            get SPACING_0(): string;
+            get SPACING_1(): string;
+            get SPACING_2(): string;
+            get SPACING_3(): string;
+            get SPACING_4(): string;
+            get SPACING_5(): string;
+            get SPACING_6(): string;
+            get SPACING_8(): string;
+            get SPACING_10(): string;
+            get SPACING_12(): string;
+            get SPACING_14(): string;
+            get SPACING_16(): string;
+            get SPACING_20(): string;
+            get SPACING_24(): string;
+            get SPACING_32(): string;
+            get SPACING_40(): string;
+            get SPACING_48(): string;
+            get SPACING_INLINE_XS(): string;
+            get SPACING_INLINE_SM(): string;
+            get SPACING_INLINE_MD(): string;
+            get SPACING_INLINE_LG(): string;
+            get SPACING_INLINE_XL(): string;
+            get SPACING_STACK_XS(): string;
+            get SPACING_STACK_SM(): string;
+            get SPACING_STACK_MD(): string;
+            get SPACING_STACK_LG(): string;
+            get SPACING_STACK_XL(): string;
+            get SPACING_INSET_XS(): string;
+            get SPACING_INSET_SM(): string;
+            get SPACING_INSET_MD(): string;
+            get SPACING_INSET_LG(): string;
+            get SPACING_INSET_XL(): string;
+            get BORDER_WIDTH_NONE(): string;
+            get BORDER_WIDTH_THIN(): string;
+            get BORDER_WIDTH_MEDIUM(): string;
+            get BORDER_WIDTH_THICK(): string;
+            get SHADOW_ELEVATION_NONE(): string;
+            get SHADOW_ELEVATION_XS(): string;
+            get SHADOW_ELEVATION_SM(): string;
+            get SHADOW_ELEVATION_MD(): string;
+            get SHADOW_ELEVATION_LG(): string;
+            get SHADOW_ELEVATION_XL(): string;
+            get SHADOW_ELEVATION_XXL(): string;
+            get SHADOW_SUBTLE(): string;
+            get SHADOW_RAISED(): string;
+            get SHADOW_FLOATING(): string;
+            get SHADOW_OVERLAY(): string;
+            get SHADOW_DRAMATIC(): string;
+            get SHADOW_STATE_FOCUS(): string;
+            get SHADOW_STATE_ERROR(): string;
+            get SHADOW_STATE_ACTIVE(): string;
+            get SHADOW_STATE_SELECTED(): string;
+            get SHAPE_RADIUS_NONE(): string;
+            get SHAPE_RADIUS_XS(): string;
+            get SHAPE_RADIUS_SM(): string;
+            get SHAPE_RADIUS_MD(): string;
+            get SHAPE_RADIUS_LG(): string;
+            get SHAPE_RADIUS_XL(): string;
+            get SHAPE_RADIUS_XXL(): string;
+            get SHAPE_RADIUS_XXXL(): string;
+            get SHAPE_RADIUS_FULL(): string;
+            get TYPOGRAPHY_DISPLAY_EXTRA_LARGE_FONT_FAMILY(): string;
+            get TYPOGRAPHY_DISPLAY_EXTRA_LARGE_FONT_SIZE(): string;
+            get TYPOGRAPHY_DISPLAY_EXTRA_LARGE_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_EXTRA_LARGE_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_DISPLAY_EXTRA_LARGE_LETTER_SPACING(): string;
+            get TYPOGRAPHY_BODY_EXTRA_SMALL_FONT_FAMILY(): string;
+            get TYPOGRAPHY_BODY_EXTRA_SMALL_FONT_SIZE(): string;
+            get TYPOGRAPHY_BODY_EXTRA_SMALL_FONT_WEIGHT(): string;
+            get TYPOGRAPHY_BODY_EXTRA_SMALL_LINE_HEIGHT(): string;
+            get TYPOGRAPHY_BODY_EXTRA_SMALL_LETTER_SPACING(): string;
+            get MOTION_DURATION_INSTANT(): string;
+            get MOTION_DURATION_FAST(): string;
+            get MOTION_DURATION_NORMAL(): string;
+            get MOTION_DURATION_SLOW(): string;
+            get MOTION_DURATION_SLOWER(): string;
+            get MOTION_DELAY_NONE(): string;
+            get MOTION_DELAY_SHORT(): string;
+            get MOTION_EASING_BOUNCE(): string;
+            get COLOR_INTERACTIVE_HOVER(): string;
+            get COLOR_INTERACTIVE_PRESSED(): string;
+            get COLOR_INTERACTIVE_DISABLED(): string;
+            get COLOR_INTERACTIVE_FOCUS(): string;
+            get COLOR_FEEDBACK_SUCCESS(): string;
+            get COLOR_FEEDBACK_SUCCESS_CONTAINER(): string;
+            get COLOR_FEEDBACK_ON_SUCCESS(): string;
+            get COLOR_FEEDBACK_ON_SUCCESS_CONTAINER(): string;
+            get COLOR_FEEDBACK_WARNING(): string;
+            get COLOR_FEEDBACK_WARNING_CONTAINER(): string;
+            get COLOR_FEEDBACK_ON_WARNING(): string;
+            get COLOR_FEEDBACK_ON_WARNING_CONTAINER(): string;
+            get COLOR_FEEDBACK_INFO(): string;
+            get COLOR_FEEDBACK_INFO_CONTAINER(): string;
+            get COLOR_FEEDBACK_ON_INFO(): string;
+            get COLOR_FEEDBACK_ON_INFO_CONTAINER(): string;
+            get COLOR_TEXT_PRIMARY(): string;
+            get COLOR_TEXT_SECONDARY(): string;
+            get COLOR_TEXT_DISABLED(): string;
+            get COLOR_TEXT_INVERSE(): string;
+            get COLOR_BORDER_DEFAULT(): string;
+            get COLOR_BORDER_STRONG(): string;
+            get COLOR_BORDER_SUBTLE(): string;
+            get COLOR_BORDER_DISABLED(): string;
+            get PALETTE_PREFIX(): string;
+            get PALETTE_BRAND_50(): string;
+            get PALETTE_BRAND_100(): string;
+            get PALETTE_BRAND_200(): string;
+            get PALETTE_BRAND_300(): string;
+            get PALETTE_BRAND_400(): string;
+            get PALETTE_BRAND_500(): string;
+            get PALETTE_BRAND_600(): string;
+            get PALETTE_BRAND_700(): string;
+            get PALETTE_BRAND_800(): string;
+            get PALETTE_BRAND_900(): string;
+            get PALETTE_SECONDARY_50(): string;
+            get PALETTE_SECONDARY_100(): string;
+            get PALETTE_SECONDARY_200(): string;
+            get PALETTE_SECONDARY_300(): string;
+            get PALETTE_SECONDARY_400(): string;
+            get PALETTE_SECONDARY_500(): string;
+            get PALETTE_SECONDARY_600(): string;
+            get PALETTE_SECONDARY_700(): string;
+            get PALETTE_SECONDARY_800(): string;
+            get PALETTE_SECONDARY_900(): string;
+            get PALETTE_NEUTRAL_50(): string;
+            get PALETTE_NEUTRAL_100(): string;
+            get PALETTE_NEUTRAL_200(): string;
+            get PALETTE_NEUTRAL_300(): string;
+            get PALETTE_NEUTRAL_400(): string;
+            get PALETTE_NEUTRAL_500(): string;
+            get PALETTE_NEUTRAL_600(): string;
+            get PALETTE_NEUTRAL_700(): string;
+            get PALETTE_NEUTRAL_800(): string;
+            get PALETTE_NEUTRAL_900(): string;
+            get PALETTE_ERROR_50(): string;
+            get PALETTE_ERROR_100(): string;
+            get PALETTE_ERROR_200(): string;
+            get PALETTE_ERROR_300(): string;
+            get PALETTE_ERROR_400(): string;
+            get PALETTE_ERROR_500(): string;
+            get PALETTE_ERROR_600(): string;
+            get PALETTE_ERROR_700(): string;
+            get PALETTE_ERROR_800(): string;
+            get PALETTE_ERROR_900(): string;
+            get PALETTE_SUCCESS_50(): string;
+            get PALETTE_SUCCESS_100(): string;
+            get PALETTE_SUCCESS_200(): string;
+            get PALETTE_SUCCESS_300(): string;
+            get PALETTE_SUCCESS_400(): string;
+            get PALETTE_SUCCESS_500(): string;
+            get PALETTE_SUCCESS_600(): string;
+            get PALETTE_SUCCESS_700(): string;
+            get PALETTE_SUCCESS_800(): string;
+            get PALETTE_SUCCESS_900(): string;
+            get PALETTE_WARNING_50(): string;
+            get PALETTE_WARNING_100(): string;
+            get PALETTE_WARNING_200(): string;
+            get PALETTE_WARNING_300(): string;
+            get PALETTE_WARNING_400(): string;
+            get PALETTE_WARNING_500(): string;
+            get PALETTE_WARNING_600(): string;
+            get PALETTE_WARNING_700(): string;
+            get PALETTE_WARNING_800(): string;
+            get PALETTE_WARNING_900(): string;
+            get PALETTE_INFO_50(): string;
+            get PALETTE_INFO_100(): string;
+            get PALETTE_INFO_200(): string;
+            get PALETTE_INFO_300(): string;
+            get PALETTE_INFO_400(): string;
+            get PALETTE_INFO_500(): string;
+            get PALETTE_INFO_600(): string;
+            get PALETTE_INFO_700(): string;
+            get PALETTE_INFO_800(): string;
+            get PALETTE_INFO_900(): string;
+            get PALETTE_PENDING_50(): string;
+            get PALETTE_PENDING_100(): string;
+            get PALETTE_PENDING_200(): string;
+            get PALETTE_PENDING_300(): string;
+            get PALETTE_PENDING_400(): string;
+            get PALETTE_PENDING_500(): string;
+            get PALETTE_PENDING_600(): string;
+            get PALETTE_PENDING_700(): string;
+            get PALETTE_PENDING_800(): string;
+            get PALETTE_PENDING_900(): string;
+            get COMP_BUTTON_PRIMARY_BACKGROUND(): string;
+            get COMP_BUTTON_PRIMARY_FOREGROUND(): string;
+            get COMP_BUTTON_PRIMARY_BORDER(): string;
+            get COMP_BUTTON_PRIMARY_BORDER_WIDTH(): string;
+            get COMP_BUTTON_PRIMARY_RADIUS(): string;
+            get COMP_BUTTON_PRIMARY_SHADOW(): string;
+            get COMP_BUTTON_PRIMARY_PADDING_X(): string;
+            get COMP_BUTTON_PRIMARY_PADDING_Y(): string;
+            get COMP_BUTTON_SECONDARY_BACKGROUND(): string;
+            get COMP_BUTTON_SECONDARY_FOREGROUND(): string;
+            get COMP_BUTTON_SECONDARY_BORDER(): string;
+            get COMP_BUTTON_SECONDARY_BORDER_WIDTH(): string;
+            get COMP_BUTTON_SECONDARY_RADIUS(): string;
+            get COMP_BUTTON_GHOST_BACKGROUND(): string;
+            get COMP_BUTTON_GHOST_FOREGROUND(): string;
+            get COMP_TAB_BACKGROUND(): string;
+            get COMP_TAB_FOREGROUND(): string;
+            get COMP_TAB_ACTIVE_FOREGROUND(): string;
+            get COMP_TAB_ACTIVE_INDICATOR(): string;
+            get COMP_TAB_BORDER(): string;
+            get COMP_MODAL_BACKGROUND(): string;
+            get COMP_MODAL_FOREGROUND(): string;
+            get COMP_MODAL_BORDER(): string;
+            get COMP_MODAL_SHADOW(): string;
+            get COMP_MODAL_OVERLAY(): string;
+            get COMP_MODAL_RADIUS(): string;
+            get COMP_INPUT_BACKGROUND(): string;
+            get COMP_INPUT_FOREGROUND(): string;
+            get COMP_INPUT_BORDER(): string;
+            get COMP_INPUT_BORDER_FOCUS(): string;
+            get COMP_INPUT_PLACEHOLDER(): string;
+            get COMP_INPUT_RADIUS(): string;
+            get COMP_INPUT_PADDING_X(): string;
+            get COMP_INPUT_PADDING_Y(): string;
+            get COMP_CARD_BACKGROUND(): string;
+            get COMP_CARD_FOREGROUND(): string;
+            get COMP_CARD_BORDER(): string;
+            get COMP_CARD_BORDER_WIDTH(): string;
+            get COMP_CARD_RADIUS(): string;
+            get COMP_CARD_SHADOW(): string;
+            get COMP_CARD_PADDING(): string;
+            get COMP_BADGE_BACKGROUND(): string;
+            get COMP_BADGE_FOREGROUND(): string;
+            get COMP_BADGE_BORDER(): string;
+            get COMP_BADGE_BORDER_WIDTH(): string;
+            get COMP_BADGE_RADIUS(): string;
+            get COMP_BADGE_PADDING_X(): string;
+            get COMP_BADGE_PADDING_Y(): string;
+            get COMP_BADGE_ERROR_BACKGROUND(): string;
+            get COMP_BADGE_ERROR_FOREGROUND(): string;
+            get COMP_CHECKBOX_BORDER(): string;
+            get COMP_CHECKBOX_BORDER_WIDTH(): string;
+            get COMP_CHECKBOX_RADIUS(): string;
+            get COMP_CHECKBOX_CHECKED_BACKGROUND(): string;
+            get COMP_CHECKBOX_CHECKED_FOREGROUND(): string;
+            get COMP_CHECKBOX_SIZE(): string;
+            get COMP_CHECKBOX_LABEL_FOREGROUND(): string;
+            get COMP_CHECKBOX_DISABLED_BACKGROUND(): string;
+            get COMP_RADIO_BORDER(): string;
+            get COMP_RADIO_BORDER_WIDTH(): string;
+            get COMP_RADIO_SELECTED_BORDER(): string;
+            get COMP_RADIO_SELECTED_INDICATOR(): string;
+            get COMP_RADIO_SIZE(): string;
+            get COMP_RADIO_LABEL_FOREGROUND(): string;
+            get COMP_RADIO_DISABLED_BORDER(): string;
+            get COMP_SELECT_BACKGROUND(): string;
+            get COMP_SELECT_FOREGROUND(): string;
+            get COMP_SELECT_BORDER(): string;
+            get COMP_SELECT_BORDER_FOCUS(): string;
+            get COMP_SELECT_RADIUS(): string;
+            get COMP_SELECT_PADDING_X(): string;
+            get COMP_SELECT_PADDING_Y(): string;
+            get COMP_SELECT_MENU_BACKGROUND(): string;
+            get COMP_SELECT_MENU_SHADOW(): string;
+            get COMP_SELECT_MENU_RADIUS(): string;
+            get COMP_SELECT_OPTION_HOVER(): string;
+            get COMP_SELECT_PLACEHOLDER(): string;
+            get COMP_TOAST_BACKGROUND(): string;
+            get COMP_TOAST_FOREGROUND(): string;
+            get COMP_TOAST_RADIUS(): string;
+            get COMP_TOAST_SHADOW(): string;
+            get COMP_TOAST_PADDING(): string;
+            get COMP_TOAST_SUCCESS_BACKGROUND(): string;
+            get COMP_TOAST_SUCCESS_FOREGROUND(): string;
+            get COMP_TOAST_ERROR_BACKGROUND(): string;
+            get COMP_TOAST_ERROR_FOREGROUND(): string;
+            get COMP_TOAST_WARNING_BACKGROUND(): string;
+            get COMP_TOAST_WARNING_FOREGROUND(): string;
+            get COMP_TOAST_INFO_BACKGROUND(): string;
+            get COMP_TOAST_INFO_FOREGROUND(): string;
+            get COMP_TOAST_DISMISSIBLE(): string;
+            get COMP_BLOB_EXPLORER_BACKGROUND(): string;
+            get COMP_BLOB_EXPLORER_FOREGROUND(): string;
+            get COMP_BLOB_EXPLORER_BORDER(): string;
+            get COMP_BLOB_EXPLORER_RADIUS(): string;
+            get COMP_BLOB_EXPLORER_PADDING(): string;
+            get COMP_BLOB_EXPLORER_TOOLBAR_BACKGROUND(): string;
+            get COMP_BLOB_EXPLORER_TOOLBAR_BORDER(): string;
+            get COMP_BLOB_EXPLORER_SIDEBAR_BACKGROUND(): string;
+            get COMP_BLOB_EXPLORER_SIDEBAR_WIDTH(): string;
+            get COMP_BLOB_EXPLORER_SIDEBAR_BORDER(): string;
+            get COMP_BLOB_EXPLORER_ITEM_BACKGROUND(): string;
+            get COMP_BLOB_EXPLORER_ITEM_BACKGROUND_HOVER(): string;
+            get COMP_BLOB_EXPLORER_ITEM_BACKGROUND_SELECTED(): string;
+            get COMP_BLOB_EXPLORER_ITEM_FOREGROUND(): string;
+            get COMP_BLOB_EXPLORER_ITEM_FOREGROUND_SECONDARY(): string;
+            get COMP_BLOB_EXPLORER_ITEM_PADDING(): string;
+            get COMP_BLOB_EXPLORER_ITEM_RADIUS(): string;
+            get COMP_BLOB_EXPLORER_BREADCRUMB_FOREGROUND(): string;
+            get COMP_BLOB_EXPLORER_BREADCRUMB_FOREGROUND_ACTIVE(): string;
+            get COMP_BLOB_EXPLORER_BREADCRUMB_SEPARATOR(): string;
+            get COMP_BLOB_EXPLORER_DETAIL_BACKGROUND(): string;
+            get COMP_BLOB_EXPLORER_DETAIL_BORDER(): string;
+            get COMP_BLOB_EXPLORER_DETAIL_WIDTH(): string;
+            get COMP_BLOB_EXPLORER_EMPTY_FOREGROUND(): string;
+            get COMP_BLOB_EXPLORER_EMPTY_ICON_COLOR(): string;
+            private constructor();
+        }
+    }
+}
+export declare abstract class ThemeValidator {
+    static readonly getInstance: () => typeof ThemeValidator.$metadata$.type;
+    private constructor();
+}
+export declare namespace ThemeValidator {
+    /** @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();
+        }
+        namespace type {
+            class ValidationResult {
+                constructor(valid: boolean, errors?: KtList<string>);
+                get valid(): boolean;
+                get errors(): KtList<string>;
+                copy(valid?: boolean, errors?: KtList<string>): ThemeValidator.$metadata$.type.ValidationResult;
+                toString(): string;
+                hashCode(): number;
+                equals(other: Nullable<any>): boolean;
+            }
+            namespace ValidationResult {
+                /** @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 () => ValidationResult;
+                }
+            }
+        }
+        abstract class constructor {
+            validate(definition: any/* ThemeDefinition */): ThemeValidator.$metadata$.type.ValidationResult;
+            validateToken(token: any/* ThemeToken */): ThemeValidator.$metadata$.type.ValidationResult;
+            isValidHexColor(hex: string): boolean;
+            isValidTokenKey(key: string): boolean;
+            validateCustomCss(css: string, policy?: any/* CssPolicyConfig */): KtList<string>;
+            private constructor();
+        }
+    }
+}
+export declare function resolvedThemeFromJson(jsonStr: string): any/* ResolvedTheme */;
+export declare function resolvedThemeToJson(theme: any/* ResolvedTheme */): string;
+export declare function systemDefaultsLightJson(): string;
+export declare function systemDefaultsDarkJson(): string;
+export declare function systemDefaultsTokens(variant: string): KtMap<string, string>;