@rs-x/core 0.4.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 robert-sanders-software-ontwikkeling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,616 @@
+import { Container, Newable, ServiceIdentifier, BindToFluentSyntax, ContainerModuleLoadOptions, ContainerModule } from 'inversify';
+export { BindToFluentSyntax, Container, ContainerModule, ContainerModuleLoadOptions, inject as Inject, injectable as Injectable, multiInject as MultiInject, Newable, preDestroy as PreDestroy, ServiceIdentifier, unmanaged as Unmanaged } from 'inversify';
+import { Observable, Subject } from 'rxjs';
+
+interface IDeepCloneValueGetter {
+    get(source: unknown): unknown;
+}
+
+interface IResolvedValueCache {
+    set(source: WeakKey, value: unknown): void;
+    get(source: WeakKey): unknown;
+    delete(source: WeakKey): void;
+}
+
+declare class DeepCloneValueGetter implements IDeepCloneValueGetter {
+    private readonly _resolvedValueCache;
+    constructor(_resolvedValueCache: IResolvedValueCache);
+    get(source: unknown): unknown;
+}
+
+declare const InjectionContainer: Container;
+
+interface IMultiInjectTokens {
+    serviceToken?: symbol;
+    multiInjectToken: symbol;
+}
+interface IMultiInjectService {
+    target: Newable<unknown>;
+    token: symbol;
+}
+type BindMethod = <T>(serviceIdentifier: ServiceIdentifier<T>) => BindToFluentSyntax<T>;
+declare function registerMultiInjectService(container: Container | ContainerModuleLoadOptions, target: Newable<unknown>, options: IMultiInjectTokens): void;
+declare function registerMultiInjectServices(container: Container | ContainerModuleLoadOptions, multiInjectToken: symbol, services: readonly IMultiInjectService[]): void;
+declare function overrideMultiInjectServices(container: Container | ContainerModuleLoadOptions, multiInjectToken: symbol, services: readonly IMultiInjectService[]): void;
+
+interface IDeepClone {
+    readonly priority: number;
+    clone(source: unknown): unknown;
+}
+
+declare function DeepClone(serviceToken?: symbol): (target: Newable<IDeepClone>) => void;
+
+declare class DefaultDeepClone implements IDeepClone {
+    private readonly _deepCloneList;
+    private readonly _deepCloneValueGetter;
+    readonly priority = 0;
+    constructor(_deepCloneList: readonly IDeepClone[], _deepCloneValueGetter: IDeepCloneValueGetter);
+    clone(source: unknown): unknown;
+}
+
+declare class LodashDeepClone implements IDeepClone {
+    readonly priority = 1;
+    clone(source: unknown): unknown;
+    private cloneExceptPredicate;
+}
+
+declare class StructuredDeepClone implements IDeepClone {
+    readonly priority = 2;
+    clone(source: unknown): unknown;
+}
+
+interface IEqualityService {
+    isEqual(a: unknown, b: unknown): boolean;
+}
+
+declare class EqualityService implements IEqualityService {
+    isEqual: <A, B>(a: A, b: B) => boolean;
+}
+
+interface IError {
+    readonly message?: string;
+    readonly code?: number;
+    readonly exception?: Error;
+    readonly context: unknown;
+    readonly fatal?: boolean;
+    readonly data?: unknown;
+}
+
+interface IErrorLog {
+    readonly error: Observable<IError>;
+    add(error: IError): void;
+    clear(): void;
+}
+
+declare class ErrorLog implements IErrorLog {
+    private readonly _error;
+    constructor();
+    get error(): Observable<IError>;
+    add(error: IError): void;
+    clear(): void;
+}
+
+declare class PrettyPrinter {
+    private readonly indent;
+    private readonly handlers;
+    constructor(indent?: number);
+    toString(value: unknown, quoteStrings?: boolean): string;
+    toLines(value: unknown, level?: number, quoteStrings?: boolean): string[];
+    private formatPrimitive;
+    private formatKey;
+    private spaces;
+    private isCustomToString;
+}
+
+declare function printValue(value: unknown): void;
+
+declare class ArgumentException extends Error {
+    constructor(message: string);
+}
+
+declare enum PropertyDescriptorType {
+    Function = "Function",
+    ReadonlyProperty = "ReadonlyProperty",
+    Property = "Property",
+    Field = "Field"
+}
+
+interface IPropertyDescriptor {
+    type: PropertyDescriptorType;
+    descriptor: PropertyDescriptor;
+}
+
+type CheckValidKey<T, U extends keyof T> = U;
+type GetFunction<T> = () => T;
+type SetFunction<T> = (value: T) => void;
+declare const emptyValue: unique symbol;
+type AnyFunction = (...args: unknown[]) => unknown;
+declare const emptyFunction: () => void;
+declare const truePredicate: () => boolean;
+declare const echo: <T = unknown>(value: T) => T;
+declare class Type {
+    static isPositiveIntegerString(value: unknown): boolean;
+    static isPositiveInteger(value: unknown): boolean;
+    static walkObjectTopToBottom(object: object, visit: (parent: object, key: string, value: unknown) => void, recursive: boolean): void;
+    static walkObjectBottomToTop(object: object, visit: (parent: object, key: string, value: unknown) => void, recursive: boolean): void;
+    static cast<T>(instance: unknown): T;
+    static isFunction(value: unknown): value is AnyFunction;
+    static isMethod(value: unknown): boolean;
+    static isArrowFunction(object: unknown): object is (...args: unknown[]) => unknown;
+    static isString(value: unknown): value is string;
+    static isNullOrUndefined(value: unknown): boolean;
+    static isEmpty(value: unknown): boolean;
+    static isPlainObject(object: unknown): boolean;
+    static hasProperty(root: unknown, name: string): boolean;
+    static hasOwnPropertyInPrototypeChain(target: unknown, key: PropertyKey): boolean;
+    static getPropertyDescriptorType(propertyDescriptor: PropertyDescriptor): PropertyDescriptorType;
+    static getPropertyDescriptor<T>(root: unknown, name: keyof T): IPropertyDescriptor;
+    static toObject(context: unknown): Record<string, unknown> | undefined;
+    static getConstructorName(value: unknown): string;
+}
+
+declare class Assertion {
+    private constructor();
+    static assertIsFunction(value: unknown, name: string | number): asserts value is AnyFunction;
+    static assertNotNullOrUndefined(value: unknown, argumentName: string): void;
+    static assertNotNullOrEmpty(value: unknown, argumentName: string): void;
+}
+
+declare class InvalidCastException extends Error {
+    constructor(message: string);
+}
+
+declare class InvalidOperationException extends Error {
+    constructor(message: string);
+}
+
+declare class NullOrEmptyException extends Error {
+    constructor(argumentName: string);
+}
+
+declare class NullOrUndefinedException extends Error {
+    constructor(argumentName: string);
+}
+
+declare class ParserException extends Error {
+    readonly expression: string;
+    readonly position?: number | undefined;
+    constructor(expression: string, message: string, position?: number | undefined);
+}
+
+declare class UnexpectedException extends Error {
+    constructor(message: string);
+}
+
+declare class UnsupportedException extends Error {
+    constructor(message: string);
+}
+
+type ConstructorType<T = unknown> = new (...args: unknown[]) => T;
+
+interface IDisposable {
+    dispose(): void;
+}
+
+interface IChainPart {
+    object: unknown;
+    id: unknown;
+}
+interface IPropertyChange {
+    chain?: IChainPart[];
+    target: unknown;
+    id?: unknown;
+    newValue?: unknown;
+    arguments?: unknown[];
+    setValue?: (value: unknown) => void;
+}
+
+declare function replaceSetItemAt<T = unknown>(set: Set<T>, oldValue: T, newValue: T): Set<T>;
+
+declare function utCDate(year: number, month?: number, date?: number, hours?: number, minutes?: number, seconds?: number, millisecond?: number): Date;
+
+interface IISequenceWithIdData {
+    sequence: readonly unknown[];
+    readonly id: string;
+}
+interface ISequenceWithId extends IISequenceWithIdData, IDisposable {
+}
+interface ISequenceIdFactory {
+    create(context: unknown, sequence: unknown[]): ISequenceWithId;
+    release(context: unknown, id: string): void;
+    get(context: unknown, sequence: unknown[]): ISequenceWithId | undefined;
+}
+
+interface ISingletonFactory<TId = unknown, TData = unknown, TInstance = unknown, TIdData = TData> extends IDisposable {
+    readonly isEmpty: boolean;
+    create(data: TData): {
+        referenceCount: number;
+        instance: TInstance;
+        id: TId;
+    };
+    release(id: TId, force?: boolean): {
+        referenceCount: number;
+        instance: TInstance | null;
+    };
+    ids(): MapIterator<TId>;
+    getOrCreate(data: TData): TInstance;
+    getFromId(id: TId): TInstance | undefined;
+    has(id: TId): boolean;
+    getFromData(data: TIdData): TInstance | undefined;
+    getId(data: TIdData): TId | undefined;
+    exists(instance: TInstance): boolean;
+}
+
+declare abstract class SingletonFactory<TId, TData extends TIdData, TInstance, TIdData = TData> implements ISingletonFactory<TId, TData, TInstance, TIdData> {
+    private readonly _instances;
+    private readonly _referenceCounts;
+    protected constructor();
+    exists(target: TInstance): boolean;
+    toLines(indent?: number, level?: number): string[];
+    toString(indent?: number, level?: number): string;
+    get isEmpty(): boolean;
+    ids(): MapIterator<TId>;
+    getFromId(id: TId): TInstance | undefined;
+    has(id: TId): boolean;
+    getFromData(data: TIdData): TInstance | undefined;
+    abstract getId(data: TIdData): TId | undefined;
+    dispose(): void;
+    getOrCreate(data: TData): TInstance;
+    create(data: TData): {
+        referenceCount: number;
+        instance: TInstance;
+        id: TId;
+    };
+    release(id: TId, force?: boolean): {
+        referenceCount: number;
+        instance: TInstance | null;
+    };
+    protected get keys(): TId[];
+    protected onDisposeInstance: (id: TId, dispose: () => void) => boolean;
+    protected abstract createInstance(data: TData, id: TId): TInstance;
+    protected abstract createId(data: TIdData): TId;
+    protected onDipose(): void;
+    protected onReleased(): void;
+    protected releaseInstance(_instance: TInstance, _id: TId): void;
+    protected onInstanceCreated(_instance: TInstance, _data: TData): void;
+    protected getOrCreateId(data: TIdData): TId;
+    protected getReferenceCount(id: TId): number;
+    protected updateReferenceCount(id: TId, change: 1 | -1, instance: TInstance, forceRelease?: boolean): number;
+    private getOrCreateInstance;
+}
+
+interface IFunctionCallIndexData {
+    readonly context: unknown;
+    readonly functionName: string;
+    readonly arguments: unknown[];
+}
+interface IFunctionCallIndex {
+    readonly context: unknown;
+    readonly functionName: string;
+    readonly argumentsId: IISequenceWithIdData;
+    readonly id: string;
+}
+interface IDisposableFunctionCallIndex extends IFunctionCallIndex, IDisposable {
+    readonly context: unknown;
+    readonly functionName: string;
+    readonly argumentsId: IISequenceWithIdData;
+    readonly id: string;
+}
+
+declare class FunctionCallIndexFactory extends SingletonFactory<IISequenceWithIdData, IFunctionCallIndexData, IDisposableFunctionCallIndex> {
+    private readonly _sequenceIdFactory;
+    constructor(_sequenceIdFactory: ISequenceIdFactory);
+    getId(data: IFunctionCallIndexData): IISequenceWithIdData;
+    protected createInstance(data: IFunctionCallIndexData, id: ISequenceWithId): IDisposableFunctionCallIndex;
+    protected createId(data: IFunctionCallIndexData): ISequenceWithId;
+    protected releaseInstance(_: IDisposableFunctionCallIndex, id: ISequenceWithId): void;
+}
+
+interface IGuidFactory {
+    create(): string;
+}
+
+interface IDisposableOwner {
+    canDispose?(): boolean;
+    release(): void;
+}
+
+interface ISingletonFactoryWithIdGeneration<TId, TData extends TIdData, TInstance, TIdData = TData> extends ISingletonFactory<TId, TData, TInstance, TIdData> {
+    isGroupRegistered(groupId: unknown): boolean;
+}
+
+declare class GuidFactory implements IGuidFactory {
+    create(): string;
+}
+
+declare abstract class SingletonFactoryWithIdGeneration<TId, TData extends TIdData, TInstance, TIdData = TData> extends SingletonFactory<TId, TData, TInstance, TIdData> implements ISingletonFactoryWithIdGeneration<TId, TData, TInstance, TIdData> {
+    private readonly _groupedData;
+    getId(data: TIdData): TId | undefined;
+    isGroupRegistered(groupId: unknown): boolean;
+    protected abstract getGroupId(data: TIdData): unknown;
+    protected abstract getGroupMemberId(data: TIdData): unknown;
+    protected abstract createUniqueId(data: TIdData): TId;
+    protected createId(data: TData): TId;
+    protected releaseInstance(_instance: TInstance, id: TId): void;
+    private findGroupMemberId;
+}
+declare abstract class SingletonFactoryWithGuid<TData extends TIdData, TInstance, TIdData = TData> extends SingletonFactoryWithIdGeneration<string, TData, TInstance, TIdData> {
+    private readonly _guidFactory;
+    protected constructor(_guidFactory: IGuidFactory);
+    protected createUniqueId(_data: TData): string;
+}
+
+declare class SequenceWithId implements ISequenceWithId {
+    readonly id: string;
+    readonly sequence: readonly unknown[];
+    private readonly _owner;
+    private _isDisposed;
+    constructor(id: string, sequence: readonly unknown[], _owner: IDisposableOwner);
+    dispose(): void;
+}
+declare class SequenceIdFactory implements ISequenceIdFactory {
+    private readonly _valueSequenceIdRegistryManager;
+    constructor(guidFactory: IGuidFactory);
+    dispose(): void;
+    create(context: unknown, sequence: unknown[]): ISequenceWithId;
+    release(context: unknown, id: string): void;
+    get(context: unknown, sequence: unknown[]): ISequenceWithId | undefined;
+    has(context: unknown, id: string): boolean;
+}
+
+type IFunctionCallIndexFactory = ISingletonFactory<IISequenceWithIdData, IFunctionCallIndexData, IDisposableFunctionCallIndex>;
+
+declare class FunctionCallIndex implements IDisposableFunctionCallIndex {
+    readonly context: unknown;
+    readonly functionName: string;
+    private readonly _sequenceWithId;
+    private readonly _owner;
+    private _isDisposed;
+    private _id;
+    constructor(context: unknown, functionName: string, _sequenceWithId: ISequenceWithId, _owner: IDisposableOwner);
+    get id(): string;
+    get argumentsId(): IISequenceWithIdData;
+    dispose(): void;
+}
+
+interface IFunctionCallResultIdInfo {
+    arguments: unknown[];
+    functionName: string;
+}
+interface IFunctionCallResult extends IFunctionCallResultIdInfo {
+    result: unknown;
+}
+interface IFunctionCallResultCache extends IDisposable {
+    readonly index: IFunctionCallIndex;
+    readonly result: unknown;
+}
+interface IFunctionCallResultCacheFactory {
+    create(context: unknown, result: IFunctionCallResult): IFunctionCallResultCache;
+    has(context: unknown, index: IFunctionCallIndex): boolean;
+    get(context: unknown, index: IFunctionCallIndex): IFunctionCallResultCache | undefined;
+}
+
+declare class FunctionCallResultCacheFactory implements IFunctionCallResultCacheFactory {
+    private readonly _functionCallResultCacheManager;
+    constructor(functionCallIndexFactory: IFunctionCallIndexFactory);
+    create(context: unknown, result: IFunctionCallResult): IFunctionCallResultCache;
+    has(context: unknown, index: IDisposableFunctionCallIndex): boolean;
+    get(context: unknown, index: IDisposableFunctionCallIndex): IFunctionCallResultCache | undefined;
+}
+
+interface IIndexValueAccessor<TContext = unknown, TIndex = unknown> {
+    readonly priority: number;
+    isAsync(context: TContext, index: TIndex): boolean;
+    getResolvedValue(context: TContext, index: TIndex): unknown;
+    hasValue(context: TContext, index: TIndex): boolean;
+    getValue(context: TContext, index: TIndex): unknown;
+    setValue(context: TContext, index: TIndex, value: unknown): void;
+    getIndexes(context: TContext, index?: TIndex): IterableIterator<TIndex>;
+    applies(context: unknown, index: TIndex): boolean;
+}
+
+type IArrayIndexAccessor = IIndexValueAccessor<unknown[], number>;
+
+declare class ArrayIndexAccessor implements IArrayIndexAccessor {
+    readonly priority = 5;
+    isAsync(): boolean;
+    getIndexes(array: unknown[]): IterableIterator<number>;
+    hasValue(array: unknown[], index: number): boolean;
+    getResolvedValue(array: unknown[], index: number): unknown;
+    getValue(array: unknown[], index: number): unknown;
+    setValue(array: unknown[], index: number, value: unknown): void;
+    applies(array: unknown): boolean;
+}
+
+type DateProperty = 'year' | 'utcYear' | 'month' | 'utcMonth' | 'date' | 'utcDate' | 'hours' | 'utcHours' | 'minutes' | 'utcMinutes' | 'seconds' | 'utcSeconds' | 'milliseconds' | 'utcMilliseconds' | 'time';
+declare const dataProperties: readonly DateProperty[];
+type IDatePropertyAccessor = IIndexValueAccessor<Date, DateProperty>;
+
+declare class DatePropertyAccessor implements IDatePropertyAccessor {
+    readonly priority = 0;
+    private readonly _setter;
+    private readonly _getters;
+    isAsync(): boolean;
+    getIndexes(): IterableIterator<DateProperty>;
+    hasValue(context: Date, index: DateProperty): boolean;
+    getResolvedValue(context: Date, index: DateProperty): unknown;
+    getValue(date: Date, index: DateProperty): unknown;
+    setValue(date: Date, index: DateProperty, value: number): void;
+    applies(context: unknown, index: DateProperty): boolean;
+}
+
+declare class IndexValueAccessor implements IIndexValueAccessor {
+    readonly priority = 0;
+    private readonly _accessors;
+    constructor(accessors: readonly IIndexValueAccessor[]);
+    getIndexes(context: unknown, index: unknown): IterableIterator<unknown>;
+    isAsync(context: unknown, index: unknown): boolean;
+    hasValue(context: unknown, index: unknown): boolean;
+    getResolvedValue(context: unknown, index: unknown): unknown;
+    getValue(context: unknown, index: unknown): unknown;
+    setValue(context: unknown, index: unknown, value: unknown): void;
+    applies(context: unknown, index: unknown): boolean;
+    private getIndexAccessor;
+}
+
+type IMapKeyAccessor = IIndexValueAccessor<Map<unknown, unknown>, unknown>;
+
+declare class MapKeyAccessor implements IMapKeyAccessor {
+    readonly priority = 4;
+    getIndexes(map: Map<unknown, unknown>): IterableIterator<unknown, unknown, unknown>;
+    isAsync(): boolean;
+    hasValue(map: Map<unknown, unknown>, key: unknown): boolean;
+    getResolvedValue(map: Map<unknown, unknown>, key: unknown): unknown;
+    getValue(map: Map<unknown, unknown>, key: unknown): unknown;
+    setValue(map: Map<unknown, unknown>, key: unknown, value: unknown): void;
+    applies(map: unknown): boolean;
+}
+
+type IMethodAccessor = IIndexValueAccessor<object, IDisposableFunctionCallIndex>;
+
+declare class MethodAccessor implements IMethodAccessor {
+    private readonly _functionCallResultCacheFactory;
+    readonly priority = 6;
+    constructor(_functionCallResultCacheFactory: IFunctionCallResultCacheFactory);
+    getIndexes(): IterableIterator<IDisposableFunctionCallIndex>;
+    isAsync(): boolean;
+    hasValue(context: object, index: IFunctionCallIndex): boolean;
+    getResolvedValue(context: object, index: IFunctionCallIndex): unknown;
+    getValue(context: unknown, index: IFunctionCallIndex): unknown;
+    setValue(_: object, index: IFunctionCallIndex): void;
+    applies(context: unknown, index: IFunctionCallIndex): boolean;
+}
+
+type LastValuObservable = Subject<unknown> | Observable<unknown>;
+interface IObservableAccessor extends IIndexValueAccessor<LastValuObservable, unknown> {
+    setLastValue(observable: LastValuObservable, value: unknown): void;
+    clearLastValue(observable: LastValuObservable): void;
+}
+
+declare class ObservableAccessor implements IObservableAccessor {
+    private readonly _resolvedValueCache;
+    readonly priority = 2;
+    constructor(_resolvedValueCache: IResolvedValueCache);
+    getIndexes(): IterableIterator<string>;
+    isAsync(): boolean;
+    getResolvedValue(context: unknown, index: string): unknown;
+    hasValue(context: unknown, index: string): boolean;
+    getValue(context: unknown, index: string): unknown;
+    setValue(context: unknown, index: string, value: unknown): void;
+    applies(context: unknown, index: string): boolean;
+    setLastValue(observable: LastValuObservable, value: unknown): void;
+    clearLastValue(observable: LastValuObservable): void;
+    private getIndexedValue;
+}
+
+declare const PENDING: unique symbol;
+
+interface IPromiseAccessor extends IIndexValueAccessor<Promise<unknown>, unknown> {
+    setLastValue(promise: Promise<unknown>, value: unknown): void;
+    clearLastValue(promise: Promise<unknown>): void;
+}
+
+declare class PromiseAccessor implements IPromiseAccessor {
+    private readonly _resolvedValueCache;
+    readonly priority = 1;
+    constructor(_resolvedValueCache: IResolvedValueCache);
+    getIndexes(): IterableIterator<string>;
+    isAsync(): boolean;
+    hasValue(context: unknown, index: string): boolean;
+    getResolvedValue(context: unknown, index: string): unknown;
+    getValue(context: unknown, index: string): unknown;
+    setValue(): void;
+    applies(context: unknown, index: string): boolean;
+    setLastValue(promise: Promise<unknown>, value: unknown): void;
+    clearLastValue(promise: Promise<unknown>): void;
+    private getIndexedValue;
+    private isCacheable;
+}
+
+type IPropertyValueAccessor = IIndexValueAccessor<object, string>;
+
+declare class PropertyValueAccessor implements IPropertyValueAccessor {
+    readonly priority = 7;
+    isAsync(): boolean;
+    getIndexes(context: unknown): IterableIterator<string>;
+    hasValue(context: unknown, index: string): boolean;
+    getResolvedValue(context: unknown, index: string): unknown;
+    getValue(context: unknown, index: string): unknown;
+    setValue(context: unknown, index: string, value: unknown): void;
+    applies(context: unknown, index: string): boolean;
+}
+
+declare class ResolvedValueCache implements IResolvedValueCache {
+    private readonly _resolvedValues;
+    set(source: WeakKey, value: unknown): void;
+    get(source: WeakKey): unknown;
+    delete(source: WeakKey): void;
+}
+
+type ISetKeyAccessor = IIndexValueAccessor<Set<unknown>, unknown>;
+
+declare class SetKeyAccessor implements ISetKeyAccessor {
+    readonly priority = 3;
+    getIndexes(set: Set<unknown>): IterableIterator<unknown>;
+    isAsync(): boolean;
+    hasValue(set: Set<unknown>, key: unknown): boolean;
+    getResolvedValue(set: Set<unknown>, key: unknown): unknown;
+    getValue(set: Set<unknown>, key: unknown): unknown;
+    setValue(set: Set<unknown>, key: unknown, value: unknown): void;
+    applies(map: unknown): boolean;
+}
+
+declare const RsXCoreInjectionTokens: {
+    IInjectionContainer: symbol;
+    IErrorLog: symbol;
+    IIndexValueAccessor: symbol;
+    IMapKeyAccessor: symbol;
+    ISetKeyAccessor: symbol;
+    IArrayIndexAccessor: symbol;
+    IPropertyValueAccessor: symbol;
+    IMethodAccessor: symbol;
+    IDatePropertyAccessor: symbol;
+    IDeepClone: symbol;
+    IEqualityService: symbol;
+    IObservableAccessor: symbol;
+    IPromiseAccessor: symbol;
+    IIndexValueAccessorList: symbol;
+    ISequenceIdFactory: symbol;
+    IFunctionCallIndexFactory: symbol;
+    IFunctionCallResultCacheFactory: symbol;
+    IGuidFactory: symbol;
+    IStructuredDeepClone: symbol;
+    ILodashDeepClone: symbol;
+    IDeepCloneList: symbol;
+    IResolvedValueCache: symbol;
+    IDeepCloneValueGetter: symbol;
+    DefaultDeepCloneValueGetter: symbol;
+};
+
+declare const defaultIndexValueAccessorList: readonly IMultiInjectService[];
+declare const defaultDeeoCloneList: readonly IMultiInjectService[];
+declare const RsXCoreModule: ContainerModule;
+
+interface WaitOptions<T extends {
+    [K in E]: Observable<R>;
+}, E extends keyof T, R> {
+    count?: number;
+    timeout?: number;
+    ignoreInitialValue?: boolean;
+}
+declare class WaitForEvent<T extends {
+    [K in E]: Observable<R>;
+}, E extends keyof T, R> {
+    private readonly _target;
+    private readonly _eventName;
+    private readonly _options;
+    constructor(_target: T, _eventName: E, options?: WaitOptions<T, E, R>);
+    wait(trigger: () => void | Promise<unknown> | Observable<unknown>): Promise<R | null>;
+    private subscribeToEvent;
+    private runTrigger;
+    private finish;
+    private cleanup;
+    private unsubscribeEvent;
+}
+
+export { type AnyFunction, ArgumentException, ArrayIndexAccessor, Assertion, type BindMethod, type CheckValidKey, type ConstructorType, type DateProperty, DatePropertyAccessor, DeepClone, DeepCloneValueGetter, DefaultDeepClone, EqualityService, ErrorLog, FunctionCallIndex, FunctionCallIndexFactory, FunctionCallResultCacheFactory, type GetFunction, GuidFactory, type IArrayIndexAccessor, type IChainPart, type IDatePropertyAccessor, type IDeepClone, type IDeepCloneValueGetter, type IDisposable, type IDisposableFunctionCallIndex, type IDisposableOwner, type IEqualityService, type IError, type IErrorLog, type IFunctionCallIndex, type IFunctionCallIndexData, type IFunctionCallIndexFactory, type IFunctionCallResult, type IFunctionCallResultCache, type IFunctionCallResultCacheFactory, type IFunctionCallResultIdInfo, type IGuidFactory, type IISequenceWithIdData, type IIndexValueAccessor, type IMapKeyAccessor, type IMethodAccessor, type IMultiInjectService, type IMultiInjectTokens, type IObservableAccessor, type IPromiseAccessor, type IPropertyChange, type IPropertyDescriptor, type IPropertyValueAccessor, type IResolvedValueCache, type ISequenceIdFactory, type ISequenceWithId, type ISetKeyAccessor, type ISingletonFactory, type ISingletonFactoryWithIdGeneration, IndexValueAccessor, InjectionContainer, InvalidCastException, InvalidOperationException, type LastValuObservable, LodashDeepClone, MapKeyAccessor, MethodAccessor, NullOrEmptyException, NullOrUndefinedException, ObservableAccessor, PENDING, ParserException, PrettyPrinter, PromiseAccessor, PropertyDescriptorType, PropertyValueAccessor, ResolvedValueCache, RsXCoreInjectionTokens, RsXCoreModule, SequenceIdFactory, SequenceWithId, type SetFunction, SetKeyAccessor, SingletonFactory, SingletonFactoryWithGuid, SingletonFactoryWithIdGeneration, StructuredDeepClone, Type, UnexpectedException, UnsupportedException, WaitForEvent, dataProperties, defaultDeeoCloneList, defaultIndexValueAccessorList, echo, emptyFunction, emptyValue, overrideMultiInjectServices, printValue, registerMultiInjectService, registerMultiInjectServices, replaceSetItemAt, truePredicate, utCDate };