@rs-x/core 0.4.10 → 0.4.12

package/dist/index.d.ts

@@ -2,8 +2,9 @@ import { Container, Newable, ServiceIdentifier, BindToFluentSyntax, ContainerMod
 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 IDeepCloneExcept {
-    except(source: unknown): unknown;
+interface IDeepClone {
+    readonly priority: number;
+    clone(source: unknown): unknown;
 }
 
 interface IResolvedValueCache {
@@ -12,17 +13,16 @@ interface IResolvedValueCache {
     delete(source: WeakKey): void;
 }
 
+interface IDeepCloneExcept {
+    except(source: unknown): unknown;
+}
+
 declare class DeepCloneValueExcept implements IDeepCloneExcept {
     private readonly _resolvedValueCache;
     constructor(_resolvedValueCache: IResolvedValueCache);
     except(source: unknown): unknown;
 }
 
-interface IDeepClone {
-    readonly priority: number;
-    clone(source: unknown): unknown;
-}
-
 declare class DefaultDeepClone implements IDeepClone {
     private readonly _deepCloneList;
     readonly priority = 0;
@@ -103,7 +103,15 @@ declare class PrettyPrinter {
 
 declare function printValue(value: unknown): void;
 
-declare class ArgumentException extends Error {
+declare class CustomError extends Error {
+    constructor(message: string, name?: string);
+}
+
+declare class ArgumentException extends CustomError {
+    constructor(message: string);
+}
+
+declare class AssertionError extends CustomError {
     constructor(message: string);
 }
 
@@ -151,73 +159,52 @@ declare class Type {
 declare class Assertion {
     private constructor();
     static assertIsFunction(value: unknown, name: string | number): asserts value is AnyFunction;
+    static assert(predicate: () => boolean, messsage: string): void;
     static assertNotNullOrUndefined(value: unknown, argumentName: string): void;
     static assertNotNullOrEmpty(value: unknown, argumentName: string): void;
 }
 
-declare class InvalidCastException extends Error {
+declare class InvalidCastException extends CustomError {
     constructor(message: string);
 }
 
-declare class InvalidOperationException extends Error {
+declare class InvalidOperationException extends CustomError {
     constructor(message: string);
 }
 
-declare class NullOrEmptyException extends Error {
+declare class NullOrEmptyException extends CustomError {
     constructor(argumentName: string);
 }
 
-declare class NullOrUndefinedException extends Error {
+declare class NullOrUndefinedException extends CustomError {
     constructor(argumentName: string);
 }
 
-declare class ParserException extends Error {
+declare class ParserException extends CustomError {
     readonly expression: string;
     readonly position?: number | undefined;
     constructor(expression: string, message: string, position?: number | undefined);
 }
 
-declare class UnexpectedException extends Error {
+declare class UnexpectedException extends CustomError {
     constructor(message: string);
 }
 
-declare class UnsupportedException extends Error {
+declare class UnsupportedException extends CustomError {
     constructor(message: string);
 }
 
-type ConstructorType<T = unknown> = new (...args: unknown[]) => T;
-
-interface IDisposable {
-    dispose(): void;
+interface IGuidFactory {
+    create(): string;
 }
 
-interface IChainPart {
-    object: unknown;
-    id: unknown;
-}
-interface IPropertyChange {
-    chain?: IChainPart[];
-    target: unknown;
-    id?: unknown;
-    newValue?: unknown;
-    arguments?: unknown[];
-    setValue?: (value: unknown) => void;
+interface IDisposableOwner {
+    canDispose?(): boolean;
+    release(): 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 IDisposable {
+    dispose(): void;
 }
 
 interface ISingletonFactory<TId = unknown, TData = unknown, TInstance = unknown, TIdData = TData> extends IDisposable {
@@ -237,6 +224,7 @@ interface ISingletonFactory<TId = unknown, TData = unknown, TInstance = unknown,
     has(id: TId): boolean;
     getFromData(data: TIdData): TInstance | undefined;
     getId(data: TIdData): TId | undefined;
+    getReferenceCount(id: TId): number;
     exists(instance: TInstance): boolean;
 }
 
@@ -264,7 +252,10 @@ declare abstract class SingletonFactory<TId, TData extends TIdData, TInstance, T
         referenceCount: number;
         instance: TInstance | null;
     };
-    protected get keys(): TId[];
+    getReferenceCount(id: TId): number;
+    protected get keys(): MapIterator<TId>;
+    protected get instances(): MapIterator<TInstance>;
+    protected replaceKey(oldKey: TId, newKey: TId): void;
     protected onDisposeInstance: (id: TId, dispose: () => void) => boolean;
     protected abstract createInstance(data: TData, id: TId): TInstance;
     protected abstract createId(data: TIdData): TId;
@@ -273,62 +264,35 @@ declare abstract class SingletonFactory<TId, TData extends TIdData, TInstance, T
     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 {
+declare class GuidFactory implements IGuidFactory {
     create(): string;
 }
 
-interface IDisposableOwner {
-    canDispose?(): boolean;
-    release(): void;
-}
-
+type IInstanceGroupInfo<TId, TInstance> = {
+    groupId: unknown;
+    groupMemberId: unknown;
+    id: TId;
+    instance: TInstance;
+};
 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;
+    instanceGroupInfoEntries(): IterableIterator<IInstanceGroupInfo<TId, TInstance>>;
 }
 
 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;
+    instanceGroupInfoEntries(): IterableIterator<IInstanceGroupInfo<TId, TInstance>>;
     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 get groupIds(): MapIterator<unknown>;
+    protected getGroup<T>(groupId: unknown): Map<T, TId> | undefined;
     protected createId(data: TData): TId;
     protected releaseInstance(_instance: TInstance, id: TId): void;
     private findGroupMemberId;
@@ -339,6 +303,37 @@ declare abstract class SingletonFactoryWithGuid<TData extends TIdData, TInstance
     protected createUniqueId(_data: TData): string;
 }
 
+type ConstructorType<T = unknown> = new (...args: unknown[]) => T;
+
+interface IChainPart {
+    context: unknown;
+    index: unknown;
+}
+interface IPropertyChange {
+    chain?: IChainPart[];
+    target: unknown;
+    index?: 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;
+}
+
 declare class SequenceWithId implements ISequenceWithId {
     readonly id: string;
     readonly sequence: readonly unknown[];
@@ -357,7 +352,23 @@ declare class SequenceIdFactory implements ISequenceIdFactory {
     has(context: unknown, id: string): boolean;
 }
 
-type IFunctionCallIndexFactory = ISingletonFactory<IISequenceWithIdData, IFunctionCallIndexData, IDisposableFunctionCallIndex>;
+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 FunctionCallIndex implements IDisposableFunctionCallIndex {
     readonly context: unknown;
@@ -372,6 +383,17 @@ declare class FunctionCallIndex implements IDisposableFunctionCallIndex {
     dispose(): void;
 }
 
+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;
+}
+
+type IFunctionCallIndexFactory = ISingletonFactory<IISequenceWithIdData, IFunctionCallIndexData, IDisposableFunctionCallIndex>;
+
 interface IFunctionCallResultIdInfo {
     arguments: unknown[];
     functionName: string;
@@ -399,7 +421,6 @@ declare class FunctionCallResultCacheFactory implements IFunctionCallResultCache
 
 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;
@@ -412,7 +433,6 @@ 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;
@@ -429,7 +449,6 @@ 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;
@@ -443,7 +462,6 @@ declare class IndexValueAccessor implements IIndexValueAccessor {
     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;
@@ -457,7 +475,6 @@ 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;
@@ -472,7 +489,6 @@ declare class MethodAccessor implements IMethodAccessor {
     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;
@@ -491,7 +507,6 @@ declare class ObservableAccessor implements IObservableAccessor {
     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;
@@ -514,7 +529,6 @@ declare class PromiseAccessor implements IPromiseAccessor {
     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;
@@ -530,7 +544,6 @@ 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;
@@ -551,7 +564,6 @@ 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;
@@ -584,12 +596,88 @@ declare const RsXCoreInjectionTokens: {
     IResolvedValueCache: symbol;
     IDeepCloneExcept: symbol;
     DefaultDeepCloneExcept: symbol;
+    IValueMetadataList: symbol;
+    ArrayMetadata: symbol;
+    DateMetadata: symbol;
+    DummyMetadata: symbol;
+    MapMetadata: symbol;
+    ObservableMetadata: symbol;
+    PromiseMetadata: symbol;
+    SetMetadata: symbol;
+    IValueMetadata: symbol;
 };
 
 declare const defaultIndexValueAccessorList: readonly IMultiInjectService[];
 declare const defaultDeeoCloneList: readonly IMultiInjectService[];
+declare const defaultValueMetadataList: readonly IMultiInjectService[];
 declare const RsXCoreModule: ContainerModule;
 
+interface IValueMetadata {
+    readonly priority: number;
+    isAsync(value: unknown): boolean;
+    needsProxy(value: unknown): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class ArrayMetadata implements IValueMetadata {
+    readonly priority = 8;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class DateMetadata implements IValueMetadata {
+    readonly priority = 7;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class DummyMetadata implements IValueMetadata {
+    readonly priority = -1000;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(): boolean;
+}
+
+declare class MapMetadata implements IValueMetadata {
+    readonly priority = 6;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class ObservableMetadata implements IValueMetadata {
+    readonly priority = 5;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class PromiseMetadata implements IValueMetadata {
+    readonly priority = 4;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class SetMetadata implements IValueMetadata {
+    readonly priority = 3;
+    isAsync(): boolean;
+    needsProxy(): boolean;
+    applies(value: unknown): boolean;
+}
+
+declare class ValueMetadata implements IValueMetadata {
+    readonly priority = 11;
+    private readonly _valueMetadataList;
+    constructor(valueMetadataList: readonly IValueMetadata[]);
+    isAsync(value: unknown): boolean;
+    needsProxy(value: unknown): boolean;
+    applies(value: unknown): boolean;
+    private getValueMetadata;
+}
+
 interface WaitOptions<T extends {
     [K in E]: Observable<R>;
 }, E extends keyof T, R> {
@@ -612,4 +700,4 @@ declare class WaitForEvent<T extends {
     private unsubscribeEvent;
 }
 
-export { type AnyFunction, ArgumentException, ArrayIndexAccessor, Assertion, type BindMethod, type CheckValidKey, type ConstructorType, type DateProperty, DatePropertyAccessor, DeepCloneValueExcept, DefaultDeepClone, EqualityService, ErrorLog, FunctionCallIndex, FunctionCallIndexFactory, FunctionCallResultCacheFactory, type GetFunction, GuidFactory, type IArrayIndexAccessor, type IChainPart, type IDatePropertyAccessor, type IDeepClone, type IDeepCloneExcept, 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 };
+export { type AnyFunction, ArgumentException, ArrayIndexAccessor, ArrayMetadata, Assertion, AssertionError, type BindMethod, type CheckValidKey, type ConstructorType, CustomError, DateMetadata, type DateProperty, DatePropertyAccessor, DeepCloneValueExcept, DefaultDeepClone, DummyMetadata, EqualityService, ErrorLog, FunctionCallIndex, FunctionCallIndexFactory, FunctionCallResultCacheFactory, type GetFunction, GuidFactory, type IArrayIndexAccessor, type IChainPart, type IDatePropertyAccessor, type IDeepClone, type IDeepCloneExcept, 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 IInstanceGroupInfo, 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, type IValueMetadata, IndexValueAccessor, InjectionContainer, InvalidCastException, InvalidOperationException, type LastValuObservable, LodashDeepClone, MapKeyAccessor, MapMetadata, MethodAccessor, NullOrEmptyException, NullOrUndefinedException, ObservableAccessor, ObservableMetadata, PENDING, ParserException, PrettyPrinter, PromiseAccessor, PromiseMetadata, PropertyDescriptorType, PropertyValueAccessor, ResolvedValueCache, RsXCoreInjectionTokens, RsXCoreModule, SequenceIdFactory, SequenceWithId, type SetFunction, SetKeyAccessor, SetMetadata, SingletonFactory, SingletonFactoryWithGuid, SingletonFactoryWithIdGeneration, StructuredDeepClone, Type, UnexpectedException, UnsupportedException, ValueMetadata, WaitForEvent, dataProperties, defaultDeeoCloneList, defaultIndexValueAccessorList, defaultValueMetadataList, echo, emptyFunction, emptyValue, overrideMultiInjectServices, printValue, registerMultiInjectService, registerMultiInjectServices, replaceSetItemAt, truePredicate, utCDate };