@rs-x/state-manager 0.4.4

package/dist/index.d.ts

@@ -0,0 +1,683 @@
+import { IDisposable, IPropertyChange, IDisposableOwner, ISingletonFactory, SingletonFactoryWithGuid, IErrorLog, IGuidFactory, IIndexValueAccessor, IArrayIndexAccessor, IMapKeyAccessor, IPropertyValueAccessor, ISetKeyAccessor, SingletonFactory, IEqualityService, DateProperty, IDatePropertyAccessor, IObservableAccessor, IPromiseAccessor, IMultiInjectService, ContainerModule, IDeepClone, ISingletonFactoryWithIdGeneration } from '@rs-x/core';
+import { Observable, Subject, Subscription } from 'rxjs';
+
+interface IObserver<T = unknown> extends IDisposable {
+    target: T | undefined;
+    id?: unknown;
+    readonly changed: Observable<IPropertyChange>;
+    readonly value: unknown;
+    init(): void;
+}
+
+declare abstract class AbstractObserver<TTarget = unknown, TValue = unknown, TId = unknown> implements IObserver<TTarget> {
+    private readonly _owner;
+    private _target;
+    private _value;
+    readonly id?: TId | undefined;
+    private _isDisposed;
+    private readonly _changed;
+    protected constructor(_owner: IDisposableOwner | undefined, _target: TTarget, _value: TValue | undefined, changed?: Subject<IPropertyChange>, id?: TId | undefined);
+    get value(): TValue | undefined;
+    protected set value(value: TValue | undefined);
+    get target(): TTarget;
+    protected set target(value: TTarget);
+    get changed(): Observable<IPropertyChange>;
+    init(): void;
+    dispose(): void;
+    protected get isDisposed(): boolean;
+    protected disposeInternal(): void;
+    protected emitChange(change: IPropertyChange): void;
+}
+
+interface ISubscriptionWithData<TSubscriptionData> {
+    subscription: Subscription;
+    data: TSubscriptionData;
+}
+interface IChangeSubscriptionsCreateMethods {
+    onChanged: (change: IPropertyChange) => void;
+    init?: (observer: IObserver) => void;
+}
+interface IGroupedChangeSubscriptionsForContextManager<TSubsriptionData, TData, TIdData = TData> extends ISingletonFactory<string, TData, IObserver, TIdData> {
+    getSubsriptionData(id: string): TSubsriptionData | undefined;
+}
+declare abstract class GroupedChangeSubscriptionsForContextManager<TSubsriptionData, TData extends TIdData & IChangeSubscriptionsCreateMethods, TIdData = TData> extends SingletonFactoryWithGuid<TData, IObserver> implements IGroupedChangeSubscriptionsForContextManager<TSubsriptionData, TData, TIdData> {
+    protected readonly _context: unknown;
+    private readonly releaseContext;
+    protected readonly _errorLog: IErrorLog;
+    private readonly _subscriptions;
+    constructor(_context: unknown, releaseContext: () => void, _errorLog: IErrorLog, guidFactory: IGuidFactory);
+    getSubsriptionData(id: string): TSubsriptionData | undefined;
+    protected createInstance(data: TData, id: string): IObserver;
+    protected onInstanceCreated(observer: IObserver<unknown>, data: TData): void;
+    protected abstract createObserver(context: unknown, data: TData, id: string): {
+        subscriptionData: TSubsriptionData;
+        observer: IObserver;
+    };
+    protected releaseInstance(observer: IObserver, id: string): void;
+    protected onReleased(): void;
+}
+
+interface IObjectChange {
+    root: object;
+    mutation: IPropertyChange;
+}
+
+interface IObserverProxyPair<TProxy = unknown> {
+    observer: IObserver;
+    proxy?: TProxy;
+    proxyTarget?: TProxy;
+}
+type MustProxify = (index: unknown, target?: unknown) => boolean;
+interface IPropertyIdInfo {
+    key: unknown;
+    mustProxify?: MustProxify;
+}
+interface IPropertyInfo extends IPropertyIdInfo {
+    value?: unknown;
+    owner?: IDisposableOwner;
+    setValue?: (value: unknown) => boolean;
+    initializeManually?: boolean;
+}
+type IPropertyObserverProxyPairManager = ISingletonFactory<unknown, IPropertyInfo, IObserverProxyPair, IPropertyIdInfo>;
+type IObjectPropertyObserverProxyPairManager = ISingletonFactory<unknown, unknown, IPropertyObserverProxyPairManager>;
+
+declare class ObserverGroup extends AbstractObserver {
+    private readonly _errorLog;
+    private readonly getRootObserver?;
+    private readonly _observeRootObserver?;
+    private readonly _subscriptions;
+    private _rootChangeSubscription;
+    private readonly _observers;
+    private readonly mustHandleChange;
+    private _rootObserver;
+    private _isInitialized;
+    protected _parent: ObserverGroup | undefined;
+    constructor(owner: IDisposableOwner | undefined, target: unknown, initialValue: unknown, mustHandleChange: ((change: IPropertyChange) => boolean) | undefined, _errorLog: IErrorLog, id?: unknown, getRootObserver?: (() => IObserver | undefined) | undefined, _observeRootObserver?: boolean | undefined);
+    get rootObserver(): IObserver | undefined;
+    init(): void;
+    addObservers(observers: IObserver[]): ObserverGroup;
+    replaceObservers(observers: IObserver[]): void;
+    emitValue(newValue: unknown): void;
+    removeObserver(target: unknown, id: unknown): void;
+    protected disposeInternal(): void;
+    protected emitChange: (change: IPropertyChange) => void;
+    private unsubscribeToObservers;
+}
+
+interface IProxyTarget<TTarget> {
+    initializeManually?: boolean;
+    target: TTarget;
+    mustProxify?: MustProxify;
+}
+type IObjectObserverProxyPairManager<TTarget = unknown> = ISingletonFactory<unknown, IProxyTarget<TTarget>, IObserverProxyPair<TTarget>>;
+
+interface IObjectObserverProxyPairFactory<TTarget = unknown> {
+    readonly priority: number;
+    create(owner: IDisposableOwner, proxyTarget: IProxyTarget<TTarget>): IObserverProxyPair<TTarget>;
+    applies(object: unknown): boolean;
+}
+
+declare abstract class AbstractObjectObserverProxyPairFactory<TTarget, TData extends IProxyTarget<TTarget> = IProxyTarget<TTarget>> implements IObjectObserverProxyPairFactory<TTarget> {
+    readonly priority: number;
+    private readonly _observerRootObserver;
+    protected readonly _errorLog: IErrorLog;
+    protected readonly _indexAccessor: IIndexValueAccessor;
+    protected readonly _objectPropertyObserverProxyPairManager: IObjectPropertyObserverProxyPairManager;
+    protected constructor(priority: number, _observerRootObserver: boolean, _errorLog: IErrorLog, _indexAccessor: IIndexValueAccessor, _objectPropertyObserverProxyPairManager: IObjectPropertyObserverProxyPairManager);
+    abstract applies(object: object): boolean;
+    create(owner: IDisposableOwner, data: TData): IObserverProxyPair<TTarget>;
+    protected createDisposableOwner(owner: IDisposableOwner, _data: TData): IDisposableOwner;
+    protected abstract createRootObserver(data: TData): IObserverProxyPair<TTarget> | undefined;
+    protected onObserverGroupCreate(target: TTarget, observerGroup: ObserverGroup, mustProxify: MustProxify | undefined): void;
+}
+
+interface IArrayProxyIdData {
+    array: unknown[];
+}
+interface IArrayProxyData extends IArrayProxyIdData {
+    owner?: IDisposableOwner;
+}
+type IArrayObserverProxyPair = IObserverProxyPair<unknown[]>;
+type IArrayProxyFactory = ISingletonFactory<unknown, IArrayProxyData, IArrayObserverProxyPair, IArrayProxyIdData>;
+
+type IArrayObserverProxyPairFactory = IObjectObserverProxyPairFactory<unknown[]>;
+
+declare class ArrayObserverProxyPairFactory extends AbstractObjectObserverProxyPairFactory<unknown[]> implements IArrayObserverProxyPairFactory {
+    private readonly _arrayProxyFactory;
+    constructor(_arrayProxyFactory: IArrayProxyFactory, errorLog: IErrorLog, arrayIndexAccessor: IArrayIndexAccessor, objectPropertyObserverProxyPairManager: IObjectPropertyObserverProxyPairManager);
+    applies(object: unknown): boolean;
+    protected createRootObserver(data: IProxyTarget<unknown[]>): IArrayObserverProxyPair;
+}
+
+interface IDateProxyIdData {
+    date: Date;
+    mustProxify?: MustProxify;
+}
+interface IDateProxyData extends IDateProxyIdData {
+    owner?: IDisposableOwner;
+}
+type IDateObserverProxyPair = IObserverProxyPair<Date>;
+type IDateProxyFactory = ISingletonFactory<string, IDateProxyData, IDateObserverProxyPair>;
+
+type IDateOserverProxyPair = IObserverProxyPair<Date>;
+type IDateObserverProxyPairFactory = IObjectObserverProxyPairFactory<Date>;
+
+declare class DateObserverProxyPairFactory implements IDateObserverProxyPairFactory {
+    private readonly _dateProxyFactory;
+    readonly priority = 6;
+    constructor(_dateProxyFactory: IDateProxyFactory);
+    create(owner: IDisposableOwner, proxyTarget: IProxyTarget<Date>): IDateOserverProxyPair;
+    applies(object: object): boolean;
+}
+
+interface IMapProxifyIdData {
+    map: Map<unknown, unknown>;
+}
+interface IMapProxifyData extends IMapProxifyIdData {
+    owner?: IDisposableOwner;
+}
+type IMapObserverProxyPair = IObserverProxyPair<Map<unknown, unknown>>;
+type IMapProxyFactory = ISingletonFactory<Map<unknown, unknown>, IMapProxifyData, IMapObserverProxyPair>;
+
+type IMapObserverProxyPairFactory = IObjectObserverProxyPairFactory<Map<unknown, unknown>>;
+
+declare class MapObserverProxyPairFactory extends AbstractObjectObserverProxyPairFactory<Map<unknown, unknown>> implements IMapObserverProxyPairFactory {
+    private readonly _mapProxyFactory;
+    constructor(_mapProxyFactory: IMapProxyFactory, errorLog: IErrorLog, mapKeyAccessor: IMapKeyAccessor, objectPropertyObserverProxyPairManager: IObjectPropertyObserverProxyPairManager);
+    applies(object: unknown): boolean;
+    protected createRootObserver(data: IProxyTarget<Map<unknown, unknown>>): IMapObserverProxyPair;
+}
+
+interface IObservableProxyData {
+    owner?: IDisposableOwner;
+    observable: Observable<unknown>;
+}
+type IObservableObserverProxyPair = IObserverProxyPair<Observable<unknown>>;
+type IObservableProxyFactory = ISingletonFactory<Observable<unknown>, IObservableProxyData, IObservableObserverProxyPair>;
+
+declare class ObservableObserverProxyPairFactory implements IObjectObserverProxyPairFactory<Observable<unknown>> {
+    private readonly _observableProxyFactory;
+    readonly priority = 3;
+    constructor(_observableProxyFactory: IObservableProxyFactory);
+    create(owner: IDisposableOwner, objectObserverInfo: IProxyTarget<Observable<unknown>>): IObservableObserverProxyPair;
+    applies(object: unknown): boolean;
+}
+
+type IPlainObjectObserverProxyPairFactory = IObjectObserverProxyPairFactory<Record<string, unknown>>;
+
+declare class PlainObjectObserverProxyPairFactory extends AbstractObjectObserverProxyPairFactory<Record<string, unknown>> implements IPlainObjectObserverProxyPairFactory {
+    constructor(errorLog: IErrorLog, propertyValueAccessor: IPropertyValueAccessor, objectPropertyObserverProxyPairManager: IObjectPropertyObserverProxyPairManager);
+    applies(object: object): boolean;
+    protected createRootObserver(data: IProxyTarget<Record<string, unknown>>): IObserverProxyPair<Record<string, unknown>> | undefined;
+}
+
+interface IPromiseProxyData {
+    owner?: IDisposableOwner;
+    promise: Promise<unknown>;
+}
+type IPromiseObserverProxyPair = IObserverProxyPair<Promise<unknown>>;
+type IPromiseProxyFactory = ISingletonFactory<Promise<unknown>, IPromiseProxyData, IPromiseObserverProxyPair>;
+
+declare class PromiseObserverProxyPairFactory implements IObjectObserverProxyPairFactory<Promise<unknown>> {
+    private readonly _promiseProxyFactory;
+    readonly priority = 4;
+    constructor(_promiseProxyFactory: IPromiseProxyFactory);
+    create(owner: IDisposableOwner, proxyTarget: IProxyTarget<Promise<unknown>>): IPromiseObserverProxyPair;
+    applies(object: unknown): boolean;
+}
+
+interface ISetProxifyIdData {
+    set: Set<unknown>;
+}
+interface ISetProxifyData extends ISetProxifyIdData {
+    owner?: IDisposableOwner;
+}
+type ISetObserverProxyPair = IObserverProxyPair<Set<unknown>>;
+type ISetProxyFactory = ISingletonFactory<Set<unknown>, ISetProxifyData, ISetObserverProxyPair, ISetProxifyIdData>;
+
+type ISetObserverProxyPairFactory = IObjectObserverProxyPairFactory<Set<unknown>>;
+
+declare class SetObserverProxyPairFactory extends AbstractObjectObserverProxyPairFactory<Set<unknown>> implements ISetObserverProxyPairFactory {
+    private readonly _setProxyFactory;
+    constructor(_setProxyFactory: ISetProxyFactory, errorLog: IErrorLog, setKeyAccessor: ISetKeyAccessor, objectPropertyObserverProxyPairManager: IObjectPropertyObserverProxyPairManager);
+    applies(object: unknown): boolean;
+    protected createRootObserver(data: IProxyTarget<Set<unknown>>): ISetObserverProxyPair;
+}
+
+interface IObjectObserverProxyPairFactoryProvider {
+    factories: readonly IObjectObserverProxyPairFactory[];
+}
+
+declare class ObjectObserverProxyPairFactoryProvider implements IObjectObserverProxyPairFactoryProvider {
+    readonly factories: readonly IObjectObserverProxyPairFactory[];
+    constructor(factories: readonly IObjectObserverProxyPairFactory[]);
+}
+
+interface IProxyRegistry {
+    getProxyTarget<T>(proxyToFind: unknown): T;
+    getProxy<T>(proxyTarget: unknown): T;
+    register(proxyTarget: unknown, proxy: unknown): void;
+    unregister(proxyTarget: unknown): void;
+    isProxy(object: unknown): boolean;
+}
+
+declare class ObjectObserverProxyPairManager extends SingletonFactoryWithGuid<IProxyTarget<unknown>, IObserverProxyPair> implements IObjectObserverProxyPairManager {
+    private readonly getObserverFactoryProvider;
+    private readonly _proxyRegistry;
+    constructor(getObserverFactoryProvider: () => IObjectObserverProxyPairFactoryProvider, _proxyRegistry: IProxyRegistry, guidFactory: IGuidFactory);
+    protected getGroupId(data: IProxyTarget<unknown>): unknown;
+    protected getGroupMemberId(data: IProxyTarget<unknown>): unknown;
+    create(data: IProxyTarget<unknown>): {
+        referenceCount: number;
+        instance: IObserverProxyPair<unknown>;
+        id: string;
+    };
+    protected createInstance(objectObserverInfo: IProxyTarget<unknown>, id: string): IObserverProxyPair;
+    protected releaseInstance(observerProxyPair: IObserverProxyPair): void;
+}
+
+interface IIndexObserverProxyPairFactory<TProxy = unknown> extends IDisposable {
+    create(owner: IDisposableOwner, object: unknown, data: IPropertyInfo): IObserverProxyPair<TProxy>;
+    applies(object: unknown, propertyInfo: IPropertyInfo): boolean;
+}
+
+declare class ObjectPropertyObserverProxyPairManager extends SingletonFactory<unknown, unknown, IPropertyObserverProxyPairManager> implements IObjectPropertyObserverProxyPairManager {
+    private readonly _factories;
+    private readonly _guidFactory;
+    constructor(_factories: IIndexObserverProxyPairFactory[], _guidFactory: IGuidFactory);
+    getId(context: unknown): unknown;
+    protected createId(context: unknown): unknown;
+    protected createInstance(context: unknown): IPropertyObserverProxyPairManager;
+}
+
+interface IIndexObserverIdInfo<TIndex = unknown> {
+    index: TIndex;
+}
+interface IIndexObserverInfo<TIndex = unknown> extends IIndexObserverIdInfo<TIndex> {
+    initialValue?: unknown;
+}
+
+type Collection = Map<unknown, unknown> | Array<unknown> | Set<unknown>;
+type ICollectionIdexObserverIdInfo = IIndexObserverIdInfo<unknown>;
+type ICollectionIndexObserverManager = ISingletonFactory<unknown, IIndexObserverInfo, IObserver>;
+type ICollectionItemObserverManager = ISingletonFactory<Collection, Collection, ICollectionIndexObserverManager>;
+
+declare class CollectionItemObserverManager extends SingletonFactory<Collection, Collection, ICollectionIndexObserverManager> implements ICollectionItemObserverManager {
+    private readonly _errorLog;
+    private readonly _equalityService;
+    private readonly _indexValueAccessor;
+    private readonly _objectObserverProxyPairManager;
+    constructor(_errorLog: IErrorLog, _equalityService: IEqualityService, _indexValueAccessor: IIndexValueAccessor, _objectObserverProxyPairManager: IObjectObserverProxyPairManager);
+    getId(collection: Collection): Collection;
+    protected createId(collection: Collection): Collection;
+    protected createInstance(collection: Collection): ICollectionIndexObserverManager;
+    protected releaseInstance(collectionIndexObserverManager: ICollectionIndexObserverManager): void;
+}
+
+interface ISubscriptionIdInfo<TIndex> {
+    index: TIndex;
+    mustProxify?: MustProxify;
+}
+interface ISubscriptionInfo<TIndex> extends ISubscriptionIdInfo<TIndex>, IChangeSubscriptionsCreateMethods {
+    initialValue?: unknown;
+    indexValueObserver?: IObserver;
+    owner: IDisposableOwner;
+    initializeManually?: boolean;
+    mustHandleChange?: (change: IPropertyChange) => boolean;
+}
+interface IndexChangeSubscriptionForContext<TIndex> {
+    context: unknown;
+    index: TIndex;
+}
+type IIndexSetObserverManager<TIndex> = ISingletonFactory<unknown, unknown, ISingletonFactory<MustProxify | TIndex, IIndexObserverInfo<TIndex>, IObserver, ISubscriptionIdInfo<TIndex>>>;
+type IIndexChangeSubscriptionsForContextManager<TIndex> = IGroupedChangeSubscriptionsForContextManager<ObserverGroup, ISubscriptionInfo<TIndex>, ISubscriptionIdInfo<TIndex>>;
+declare class IndexChangeSubscriptionManager<TIndex> extends SingletonFactory<unknown, unknown, IIndexChangeSubscriptionsForContextManager<TIndex>> {
+    private readonly _indexSetObserverManager;
+    private readonly _errorLog;
+    private readonly _guidFactory;
+    constructor(_indexSetObserverManager: IIndexSetObserverManager<unknown>, _errorLog: IErrorLog, _guidFactory: IGuidFactory);
+    getId(context: unknown): unknown;
+    protected createId(context: unknown): unknown;
+    protected createInstance(context: unknown): IIndexChangeSubscriptionsForContextManager<TIndex>;
+    protected releaseInstance(instance: IIndexChangeSubscriptionsForContextManager<TIndex>, id: string): void;
+}
+
+declare abstract class IndexObserverProxyPairFactory<TContext, TIndex> implements IIndexObserverProxyPairFactory<TContext> {
+    private readonly _objectObserveryManager;
+    protected readonly _indexValueAccessor: IIndexValueAccessor;
+    private readonly _proxyRegister;
+    private readonly mustHandleChange?;
+    private readonly _indexChangeSubscriptionManager;
+    protected constructor(_objectObserveryManager: IObjectObserverProxyPairManager, indexSetObserverManager: IIndexSetObserverManager<TIndex>, errorLog: IErrorLog, guidFactory: IGuidFactory, _indexValueAccessor: IIndexValueAccessor, _proxyRegister: IProxyRegistry, mustHandleChange?: ((change: IPropertyChange) => boolean) | undefined);
+    dispose(): void;
+    abstract applies(object: unknown, propertyInfo: IPropertyInfo): boolean;
+    create(owner: IDisposableOwner, object: TContext, propertyInfo: IPropertyInfo): IObserverProxyPair<TContext>;
+    private getMustProxifyHandler;
+    private createIndexValueProxy;
+    private createGroupObserver;
+    private onIndexSet;
+    private getNestedObservers;
+    private proxifyIndexValue;
+}
+
+declare class CollectionItemObserverProxyPairFactory extends IndexObserverProxyPairFactory<Collection, unknown> {
+    constructor(objectObserverManager: IObjectObserverProxyPairManager, collectionItemObserverManager: ICollectionItemObserverManager, errorLog: IErrorLog, guidFactory: IGuidFactory, indexValueAccessor: IIndexValueAccessor, proxyRegister: IProxyRegistry);
+    applies(object: unknown): boolean;
+}
+
+type ICollectionItemObserverProxyPairFactory = IIndexObserverProxyPairFactory<Collection>;
+
+type IMustProxifyItemHandlerFactory = ISingletonFactory<unknown, unknown, MustProxify>;
+
+type IDatePropertyObserverIdInfo = IIndexObserverIdInfo<DateProperty>;
+type IDatePropertyObserverInfo = IIndexObserverInfo<DateProperty>;
+type IProperForDataObserverManager = ISingletonFactory<DateProperty, IDatePropertyObserverInfo, IObserver>;
+type IDatePropertyObserverManager = ISingletonFactory<Date, Date, IProperForDataObserverManager>;
+
+declare class DatePropertyObserverManager extends SingletonFactory<Date, Date, IProperForDataObserverManager> implements IDatePropertyObserverManager {
+    private readonly _dateProxyFactory;
+    private readonly _errorLog;
+    private readonly _datePropertyAccessor;
+    private readonly _mustProxifyItemHandlerFactory;
+    constructor(_dateProxyFactory: IDateProxyFactory, _errorLog: IErrorLog, _datePropertyAccessor: IDatePropertyAccessor, _mustProxifyItemHandlerFactory: IMustProxifyItemHandlerFactory);
+    getId(date: Date): Date;
+    createId(date: Date): Date;
+    protected createInstance(date: Date): IProperForDataObserverManager;
+    protected releaseInstance(properForDataObserverManager: IProperForDataObserverManager): void;
+}
+
+type IDatePropertyObserverProxyPairFactory = IIndexObserverProxyPairFactory<Date>;
+
+declare class DatePropertyObserverProxyPairFactory extends IndexObserverProxyPairFactory<Date, DateProperty> implements IDatePropertyObserverProxyPairFactory {
+    constructor(objectObserverManager: IObjectObserverProxyPairManager, datePropertyObserverManager: IDatePropertyObserverManager, errorLog: IErrorLog, guidFactory: IGuidFactory, datePropertyAccessor: IIndexValueAccessor, proxyRegister: IProxyRegistry);
+    applies(object: unknown): boolean;
+}
+
+type IPropertyObserverIdInfo = IIndexObserverIdInfo<string>;
+type IPropertyObserverInfo = IIndexObserverInfo<string>;
+type IPropertyObserverManager = ISingletonFactory<string, IPropertyObserverInfo, IObserver>;
+type IObjectPropertyObserverManager = ISingletonFactory<object, object, IPropertyObserverManager>;
+
+declare class NonIterableObjectPropertyObserverProxyPairFactory extends IndexObserverProxyPairFactory<object, string> {
+    constructor(objectObserveryManager: IObjectObserverProxyPairManager, objectPropertyObserverManager: IObjectPropertyObserverManager, errorLog: IErrorLog, guidFactory: IGuidFactory, indexValueAccessor: IIndexValueAccessor, proxyRegister: IProxyRegistry);
+    applies(object: unknown, propertyInfo: IPropertyInfo): boolean;
+    protected setIndexValue(object: Record<string, unknown>, key: string, value: unknown): void;
+}
+
+declare class ObjectPropertyObserverManager extends SingletonFactory<object, object, IPropertyObserverManager> implements IObjectPropertyObserverManager {
+    private readonly _proxyRegister;
+    constructor(_proxyRegister: IProxyRegistry);
+    getId(context: object): object;
+    protected createId(context: object): object;
+    protected createInstance(context: object): IPropertyObserverManager;
+    protected releaseInstance(propertyObserverManager: IPropertyObserverManager): void;
+}
+
+declare class MustProxifyItemHandlerFactory extends SingletonFactory<unknown, unknown, MustProxify> implements IMustProxifyItemHandlerFactory {
+    constructor();
+    getId(index: unknown): unknown;
+    protected createInstance(_: unknown, id: unknown): MustProxify;
+    protected createId(index: unknown): unknown;
+}
+
+declare class ArrayProxyFactory extends SingletonFactory<unknown[], IArrayProxyData, IArrayObserverProxyPair, IArrayProxyIdData> implements IArrayProxyFactory {
+    private readonly _proxyRegistry;
+    constructor(_proxyRegistry: IProxyRegistry);
+    getId(data: IArrayProxyIdData): unknown[];
+    protected createId(data: IArrayProxyIdData): unknown[];
+    protected createInstance(data: IArrayProxyData, id: unknown[]): IArrayObserverProxyPair;
+    protected releaseInstance(arrayObserverWithProxy: IArrayObserverProxyPair, id: unknown[]): void;
+}
+
+declare class DateProxyFactory extends SingletonFactoryWithGuid<IDateProxyData, IDateObserverProxyPair, IDateProxyIdData> implements IDateProxyFactory {
+    private readonly _proxyRegistry;
+    constructor(guidFactory: IGuidFactory, _proxyRegistry: IProxyRegistry);
+    protected getGroupId(data: IDateProxyIdData): Date;
+    protected getGroupMemberId(data: IDateProxyIdData): MustProxify | undefined;
+    protected createInstance(dateProxyData: IDateProxyData, id: string): IDateObserverProxyPair;
+}
+
+declare class MapProxy extends AbstractObserver<Map<unknown, unknown>, Map<unknown, unknown>, undefined> {
+    private readonly _proxyRegistry;
+    private readonly updateMap;
+    constructor(owner: IDisposableOwner, map: Map<unknown, unknown>, _proxyRegistry: IProxyRegistry);
+    get(originalMap: Map<unknown, unknown>, property: PropertyKey): unknown;
+    protected disposeInternal(): void;
+    private isUpdateMapKey;
+    private clearMap;
+    private setMap;
+    private deleteMap;
+    private deleteItem;
+    private emitSet;
+}
+declare class MapProxyFactory extends SingletonFactory<Map<unknown, unknown>, IMapProxifyData, IMapObserverProxyPair> implements IMapProxyFactory {
+    private readonly _proxyRegistry;
+    constructor(_proxyRegistry: IProxyRegistry);
+    getId(data: IMapProxifyData): Map<unknown, unknown>;
+    protected createId(data: IMapProxifyData): Map<unknown, unknown>;
+    protected createInstance(data: IMapProxifyData, id: Map<unknown, unknown>): IMapObserverProxyPair;
+    protected releaseInstance(mapObserverWithProxy: IMapObserverProxyPair): void;
+}
+
+declare class ObservableProxyFactory extends SingletonFactory<Observable<unknown>, IObservableProxyData, IObservableObserverProxyPair> implements IObservableProxyFactory {
+    private readonly _observableAccessor;
+    constructor(_observableAccessor: IObservableAccessor);
+    getId(data: IObservableProxyData): Observable<unknown>;
+    protected createId(data: IObservableProxyData): Observable<unknown>;
+    protected createInstance(data: IObservableProxyData, id: Observable<unknown>): IObservableObserverProxyPair;
+    protected releaseInstance(observableObserverWithProxy: IObservableObserverProxyPair): void;
+}
+
+declare class PromiseProxyFactory extends SingletonFactory<Promise<unknown>, IPromiseProxyData, IPromiseObserverProxyPair> implements IPromiseProxyFactory {
+    private readonly _promiseAccessor;
+    constructor(_promiseAccessor: IPromiseAccessor);
+    getId(data: IPromiseProxyData): Promise<unknown>;
+    protected createId(data: IPromiseProxyData): Promise<unknown>;
+    protected createInstance(data: IPromiseProxyData, id: Promise<unknown>): IPromiseObserverProxyPair;
+    protected releaseInstance(promiseObserverWithProxy: IPromiseObserverProxyPair): void;
+}
+
+declare class ProxyRegistry implements IProxyRegistry {
+    private readonly _proxies;
+    getProxyTarget<T>(proxyToFind: unknown): T;
+    getProxy<T>(proxyTarget: unknown): T;
+    register(proxyTarget: unknown, proxy: unknown): void;
+    unregister(proxyTarget: unknown): void;
+    isProxy(object: unknown): boolean;
+}
+
+declare class SetProxy extends AbstractObserver<Set<unknown>, Set<unknown>, undefined> {
+    private readonly _proxyRegistry;
+    private readonly updateSet;
+    constructor(owner: IDisposableOwner, initialValue: Set<unknown>, _proxyRegistry: IProxyRegistry);
+    get(originalSet: Set<unknown>, property: PropertyKey): unknown;
+    protected disposeInternal(): void;
+    private clearSet;
+    private addSet;
+    private deleteSet;
+    private hasSet;
+    private emitValueChange;
+}
+declare class SetProxyFactory extends SingletonFactory<Set<unknown>, ISetProxifyData, ISetObserverProxyPair, ISetProxifyIdData> implements ISetProxyFactory {
+    private readonly _proxyRegistry;
+    constructor(_proxyRegistry: IProxyRegistry);
+    getId(data: ISetProxifyIdData): Set<unknown>;
+    protected createId(data: ISetProxifyIdData): Set<unknown>;
+    protected createInstance(data: ISetProxifyData, id: Set<unknown>): ISetObserverProxyPair;
+    protected releaseInstance(setObserverWithProxy: ISetObserverProxyPair): void;
+}
+
+declare const RsXStateManagerInjectionTokens: {
+    IArrayProxyFactory: symbol;
+    IMapProxyFactory: symbol;
+    ISetProxyFactory: symbol;
+    IDateProxyFactory: symbol;
+    IProxyRegistry: symbol;
+    IPromiseProxyFactory: symbol;
+    IObservableProxyFactory: symbol;
+    IObjectPropertyObserverProxyPairManager: symbol;
+    IPlainObjectObserverProxyPairFactory: symbol;
+    IDateObserverProxyPairFactory: symbol;
+    IArrayObserverProxyPairFactory: symbol;
+    PromiseObserverProxyPairFactory: symbol;
+    ObservableObserverProxyPairFactory: symbol;
+    IMapObserverProxyPairFactory: symbol;
+    ISetObserverProxyPairFactory: symbol;
+    IDatePropertyObserverProxyPairFactory: symbol;
+    IObjectObserverProxyPairFactoryList: symbol;
+    IObjectObserverProxyPairFactoryProvider: symbol;
+    IObjectObserverProxyPairManager: symbol;
+    IObjectPropertyObserverManager: symbol;
+    ICollectionItemObserverManager: symbol;
+    ISetItemObserverManager: symbol;
+    IDatePropertyObserverManager: symbol;
+    IPropertyObserverProxyPairFactoryList: symbol;
+    NonIterableObjectPropertyObserverProxyPairFactory: symbol;
+    ICollectionItemObserverProxyPairFactory: symbol;
+    IMustProxifyItemHandlerFactory: symbol;
+    IObjectStateManager: symbol;
+    IPropertyObserverProxyPairFactoryProvider: symbol;
+    IPropertyObserverProxyPairFactoryProviderFactory: symbol;
+    IObjectObserverProxyPairFactoryProviderFactory: symbol;
+    IStateManager: symbol;
+};
+
+declare const defaultObjectObserverProxyPairFactoryList: readonly IMultiInjectService[];
+declare const defaultPropertyObserverProxyPairFactoryList: readonly IMultiInjectService[];
+declare const RsXStateManagerModule: ContainerModule;
+declare function unloadRsXStateManagerModule(): Promise<void>;
+
+interface IState {
+    value: unknown;
+    valueCopy: unknown;
+    watched: boolean;
+}
+interface IValueKey {
+    key: unknown;
+}
+interface IValueWithKey extends IValueKey {
+    value: unknown;
+    watched: boolean;
+}
+interface IStateForObjectManager extends ISingletonFactory<unknown, IValueWithKey, IState, IValueKey> {
+    set(key: unknown, value: unknown, watched: boolean): void;
+}
+interface IObjectStateManager extends ISingletonFactory<unknown, unknown, IStateForObjectManager> {
+    replaceState(key: unknown, newContext: unknown, newValue: unknown, oldContext: unknown, watched: boolean): void;
+    isRegistered(context: unknown, key: unknown): boolean;
+}
+
+declare class StateForObjectManager extends SingletonFactory<unknown, IValueWithKey, IState, IValueKey> implements IStateForObjectManager {
+    private readonly _deepClone;
+    private readonly releaseContext;
+    constructor(_deepClone: IDeepClone, releaseContext: VoidFunction);
+    getId(data: IValueKey): unknown;
+    set(key: unknown, value: unknown, watched: boolean): void;
+    protected createId(data: IValueKey): unknown;
+    private deepClone;
+    protected createInstance(data: IValueWithKey): IState;
+    protected onReleased(): void;
+}
+declare class ObjectStateManager extends SingletonFactory<unknown, unknown, IStateForObjectManager> implements IObjectStateManager {
+    private readonly _deepClone;
+    constructor(_deepClone: IDeepClone);
+    getId(object: unknown): unknown;
+    isRegistered(context: unknown, key: unknown): boolean;
+    replaceState(key: unknown, newContext: unknown, newValue: unknown, oldContext: unknown, watched: boolean): void;
+    protected createId(object: unknown): unknown;
+    protected createInstance(context: unknown): IStateForObjectManager;
+}
+
+interface IStateChangeObserverInfo {
+    readonly observer: IObserver;
+    readonly subscription: Subscription;
+}
+interface IStateChangeSubscriptionIdInfo {
+    key: unknown;
+    mustProxify?: MustProxify;
+}
+interface IStateChangeSubscriptionInfo extends IStateChangeSubscriptionIdInfo {
+    onChanged: (change: IPropertyChange) => void;
+    init?: (observer: IObserver) => void;
+}
+type IStateChangeSubscriptionsForContextManager = ISingletonFactoryWithIdGeneration<string, IStateChangeSubscriptionInfo, IObserver, IStateChangeSubscriptionIdInfo>;
+interface IStateChangeSubscriptionManager extends ISingletonFactory<unknown, unknown, IStateChangeSubscriptionsForContextManager> {
+    isRegistered(context: unknown, key: unknown): boolean;
+}
+
+declare class StateChangeSubscriptionManager extends SingletonFactory<unknown, unknown, IStateChangeSubscriptionsForContextManager> implements IStateChangeSubscriptionManager {
+    private readonly _objectObserverManager;
+    private readonly _errorLog;
+    private readonly _guidFactory;
+    constructor(_objectObserverManager: IObjectPropertyObserverProxyPairManager, _errorLog: IErrorLog, _guidFactory: IGuidFactory);
+    getId(context: unknown): unknown;
+    isRegistered(context: unknown, key: unknown): boolean;
+    protected createId(context: unknown): unknown;
+    protected createInstance(context: unknown, id: unknown): IStateChangeSubscriptionsForContextManager;
+    protected releaseInstance(instance: IStateChangeSubscriptionsForContextManager, id: unknown): void;
+}
+
+interface IContextChanged {
+    oldContext: unknown;
+    context: unknown;
+    key: unknown;
+}
+interface IStateChange extends IContextChanged {
+    oldValue: unknown;
+    newValue?: unknown;
+    watched?: boolean;
+}
+interface IStateManager {
+    readonly changed: Observable<IStateChange>;
+    readonly contextChanged: Observable<IContextChanged>;
+    readonly startChangeCycle: Observable<void>;
+    readonly endChangeCycle: Observable<void>;
+    isWatched(context: unknown, index: unknown, mustProxify?: MustProxify): boolean;
+    watchState(context: unknown, index: unknown, mustProxify?: MustProxify): unknown;
+    releaseState(oontext: unknown, index: unknown, mustProxify?: MustProxify): void;
+    getState<T>(context: unknown, index: unknown): T;
+    setState<T>(context: unknown, index: unknown, value: T): void;
+    clear(): void;
+}
+
+declare class StateManager implements IStateManager {
+    private readonly _objectStateManager;
+    private readonly _indexValueAccessor;
+    private readonly _equalityService;
+    private readonly _changed;
+    private readonly _contextChanged;
+    private readonly _startChangeCycle;
+    private readonly _endChangeCycle;
+    private readonly _stateChangeSubscriptionManager;
+    private readonly _pending;
+    constructor(objectObserverManager: IObjectPropertyObserverProxyPairManager, _objectStateManager: IObjectStateManager, errorLog: IErrorLog, guidFactory: IGuidFactory, _indexValueAccessor: IIndexValueAccessor, _equalityService: IEqualityService);
+    get changed(): Observable<IStateChange>;
+    get contextChanged(): Observable<IContextChanged>;
+    get startChangeCycle(): Observable<void>;
+    get endChangeCycle(): Observable<void>;
+    toString(): string;
+    isWatched(context: unknown, index: unknown, mustProxify?: MustProxify): boolean;
+    watchState(context: unknown, index: unknown, mustProxify?: MustProxify): unknown;
+    releaseState(context: unknown, index: unknown, mustProxify: MustProxify): void;
+    clear(): void;
+    getState<T>(context: unknown, index: unknown): T;
+    setState<T>(context: unknown, index: unknown, value: T): void;
+    private internalSetState;
+    private getOldValue;
+    private unnsubscribeToObserverEvents;
+    private internalUnregister;
+    private emitChange;
+    private updateState;
+    private canReleaseState;
+    private increaseStateReferenceCount;
+    private tryToSubscribeToChange;
+    private getValue;
+    private getStateChanges;
+    private tryRebindingNestedState;
+    private setInitialValue;
+    private getChainChanges;
+    private getCurrentValue;
+    private onChange;
+}
+
+export { AbstractObjectObserverProxyPairFactory, AbstractObserver, ArrayObserverProxyPairFactory, ArrayProxyFactory, type Collection, CollectionItemObserverManager, CollectionItemObserverProxyPairFactory, DateObserverProxyPairFactory, DatePropertyObserverManager, DatePropertyObserverProxyPairFactory, DateProxyFactory, GroupedChangeSubscriptionsForContextManager, type IArrayObserverProxyPair, type IArrayObserverProxyPairFactory, type IArrayProxyData, type IArrayProxyFactory, type IArrayProxyIdData, type IChangeSubscriptionsCreateMethods, type ICollectionIdexObserverIdInfo, type ICollectionIndexObserverManager, type ICollectionItemObserverManager, type ICollectionItemObserverProxyPairFactory, type IContextChanged, type IDateObserverProxyPair, type IDateObserverProxyPairFactory, type IDateOserverProxyPair, type IDatePropertyObserverIdInfo, type IDatePropertyObserverInfo, type IDatePropertyObserverManager, type IDatePropertyObserverProxyPairFactory, type IDateProxyData, type IDateProxyFactory, type IDateProxyIdData, type IGroupedChangeSubscriptionsForContextManager, type IIndexChangeSubscriptionsForContextManager, type IIndexObserverIdInfo, type IIndexObserverInfo, type IIndexObserverProxyPairFactory, type IIndexSetObserverManager, type IMapObserverProxyPair, type IMapObserverProxyPairFactory, type IMapProxifyData, type IMapProxifyIdData, type IMapProxyFactory, type IMustProxifyItemHandlerFactory, type IObjectChange, type IObjectObserverProxyPairFactory, type IObjectObserverProxyPairFactoryProvider, type IObjectObserverProxyPairManager, type IObjectPropertyObserverManager, type IObjectPropertyObserverProxyPairManager, type IObjectStateManager, type IObservableObserverProxyPair, type IObservableProxyData, type IObservableProxyFactory, type IObserver, type IObserverProxyPair, type IPlainObjectObserverProxyPairFactory, type IPromiseObserverProxyPair, type IPromiseProxyData, type IPromiseProxyFactory, type IProperForDataObserverManager, type IPropertyIdInfo, type IPropertyInfo, type IPropertyObserverIdInfo, type IPropertyObserverInfo, type IPropertyObserverManager, type IPropertyObserverProxyPairManager, type IProxyRegistry, type IProxyTarget, type ISetObserverProxyPair, type ISetObserverProxyPairFactory, type ISetProxifyData, type ISetProxifyIdData, type ISetProxyFactory, type IState, type IStateChange, type IStateChangeObserverInfo, type IStateChangeSubscriptionIdInfo, type IStateChangeSubscriptionInfo, type IStateChangeSubscriptionManager, type IStateChangeSubscriptionsForContextManager, type IStateForObjectManager, type IStateManager, type ISubscriptionIdInfo, type ISubscriptionInfo, type ISubscriptionWithData, type IValueKey, type IValueWithKey, type IndexChangeSubscriptionForContext, IndexChangeSubscriptionManager, IndexObserverProxyPairFactory, MapObserverProxyPairFactory, MapProxy, MapProxyFactory, type MustProxify, MustProxifyItemHandlerFactory, NonIterableObjectPropertyObserverProxyPairFactory, ObjectObserverProxyPairFactoryProvider, ObjectObserverProxyPairManager, ObjectPropertyObserverManager, ObjectPropertyObserverProxyPairManager, ObjectStateManager, ObservableObserverProxyPairFactory, ObservableProxyFactory, ObserverGroup, PlainObjectObserverProxyPairFactory, PromiseObserverProxyPairFactory, PromiseProxyFactory, ProxyRegistry, RsXStateManagerInjectionTokens, RsXStateManagerModule, SetObserverProxyPairFactory, SetProxy, SetProxyFactory, StateChangeSubscriptionManager, StateForObjectManager, StateManager, defaultObjectObserverProxyPairFactoryList, defaultPropertyObserverProxyPairFactoryList, unloadRsXStateManagerModule };