import * as i0 from '@angular/core';
import { InjectionToken, Injector, Signal } from '@angular/core';
import { Type, BaseResolver } from '@nx-ddd/common/domain';
import * as rxjs from 'rxjs';
import { Observable, ReplaySubject, Subject } from 'rxjs';
import * as _ngrx_entity from '@ngrx/entity';
import { EntityState, EntityAdapter } from '@ngrx/entity';
import { ComponentStore } from '@ngrx/component-store';

declare class ProxyIdService {
    proxyMap: Map<string, string>;
    isProxyId(id: string | null): boolean;
    proxyId(_id: string): string;
    update(proxyId: string, id: string): void;
    resolve(proxyIdOrId: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProxyIdService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProxyIdService>;
}

type Entity = {
    id: string;
};
interface BaseTask {
    type: 'create' | 'update' | 'delete' | 'noop';
    timestamp: number;
}
interface CreateAction<T extends Entity> extends BaseTask {
    type: 'create';
    payload: T;
}
interface UpdateAction<T extends Entity> extends BaseTask {
    type: 'update';
    payload: Partial<T> & Entity;
}
interface DeleteAction extends BaseTask {
    type: 'delete';
    payload: Entity;
}
interface NoopAction extends BaseTask {
    type: 'noop';
    payload: {};
}
type Task<T extends Entity> = CreateAction<T> | UpdateAction<T> | DeleteAction | NoopAction;
declare function pushMap<T>(map: Map<string, T[]>, id: string, item: T): Map<string, T[]>;
declare class TaskComposerService {
    readonly proxyId: ProxyIdService;
    composeTasks<T extends Entity>(tasks: Task<T>[]): Task<T>[];
    compose<T extends Entity>(tasks: Task<T>[]): Task<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskComposerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TaskComposerService>;
}

declare class EntityStoreAdapter<E extends Entity> {
    list?(): Observable<E[]>;
    create?(entity: E): Promise<E>;
    update?(entity: Partial<E> & Pick<E, 'id'>): Promise<void>;
    delete?(entity: Pick<E, 'id'>): Promise<void>;
    save?(entity: E): Promise<E>;
}
declare const ENTITY_STORE_ADAPTER: InjectionToken<{
    entity: Type<Entity>;
    adapter: EntityStoreAdapter<Entity>;
}[]>;
declare function provideEntityStoreAdapter<E extends Entity>(entity: Type<E>, adapterFactory: (injector: Injector) => EntityStoreAdapter<E>): {
    provide: InjectionToken<{
        entity: Type<Entity>;
        adapter: EntityStoreAdapter<Entity>;
    }[]>;
    multi: boolean;
    useFactory: (injector: Injector) => {
        entity: Type<E>;
        adapter: EntityStoreAdapter<E>;
    };
    deps: (typeof Injector)[];
};
declare function injectEntityStoreAdapter<E extends Entity>(entity: Type<E>): EntityStoreAdapter<E>;

declare const distinctUntilChangedArray: <T>() => rxjs.MonoTypeOperatorFunction<T>;
declare class BaseEntityStore<E extends Entity> extends ComponentStore<EntityState<E>> {
    protected entity: Type<E>;
    protected entityAdapter: EntityAdapter<E>;
    protected adapter: EntityStoreAdapter<E>;
    protected readonly refresh$: ReplaySubject<void>;
    protected get selectors(): {
        selectIds: (state: EntityState<E>) => string[] | number[];
        selectEntities: (state: EntityState<E>) => _ngrx_entity.Dictionary<E>;
        selectAll: (state: EntityState<E>) => E[];
        selectTotal: (state: EntityState<E>) => number;
    };
    readonly all$: Observable<E[]>;
    readonly all: i0.Signal<E[] | undefined>;
    readonly total$: Observable<number>;
    readonly total: i0.Signal<number | undefined>;
    readonly entities$: Observable<E[]>;
    readonly entities: i0.Signal<E[] | undefined>;
    readonly size$: Observable<number>;
    readonly addOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => rxjs.Subscription;
    readonly addMany: (observableOrValue: E[] | Observable<E[]>) => rxjs.Subscription;
    readonly updateOne: (observableOrValue: {
        id: string;
        changes: Partial<E>;
    } | Observable<{
        id: string;
        changes: Partial<E>;
    }>) => rxjs.Subscription;
    readonly updateMany: (observableOrValue: {
        id: string;
        changes: Partial<E>;
    }[] | Observable<{
        id: string;
        changes: Partial<E>;
    }[]>) => rxjs.Subscription;
    readonly upsertOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => rxjs.Subscription;
    readonly upsertMany: (observableOrValue: E[] | Observable<E[]>) => rxjs.Subscription;
    readonly removeOne: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly removeMany: (observableOrValue: string[] | Observable<string[]>) => rxjs.Subscription;
    readonly removeAll: () => void;
    readonly setOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => rxjs.Subscription;
    readonly setAll: (observableOrValue: E[] | Observable<E[]>) => rxjs.Subscription;
    constructor(entity: Type<E>, entityAdapter?: EntityAdapter<E>);
    protected getEntities: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
    refresh(): void;
    mapToOne(valueOrObs: string | Observable<string>): Observable<E>;
}
declare class EntityStore<E extends Entity> extends BaseEntityStore<E> {
    protected entity: Type<E>;
    protected entityAdapter: EntityAdapter<E>;
    protected proxyId: ProxyIdService;
    protected composer: TaskComposerService;
    protected taskSubject$: Subject<Task<E>>;
    protected task$: Observable<Task<E>>;
    protected composedTasks$: Observable<Task<E>[]>;
    constructor(entity: Type<E>, entityAdapter?: EntityAdapter<E>);
    dispatch(action: Task<E>): void;
    protected runTask(task: Task<E>): Promise<any>;
    protected runComposedTasks(tasks: Task<E>[]): Promise<void>;
    protected onSyncFailed(): void;
    protected onSyncSucceeded(): void;
    create(payload: E): Promise<E>;
    update(payload: Pick<E, 'id'> & Partial<E>): Promise<void>;
    delete(payload: Pick<E, 'id'>): Promise<void>;
    save(payload: E): Promise<E>;
}

type OneProps<V> = {
    id: V;
    [key: string]: V;
};
type AllProps<V> = {
    [key: string]: V;
};
declare function injectOne$<T extends Entity>(Entity: Type<T>, params: OneProps<Observable<any>>, resolverType?: Type<BaseResolver<T>>): Observable<T>;
declare function injectOne<T extends Entity>(Entity: Type<T>, params: OneProps<Signal<any>>, resolverType?: Type<BaseResolver<T>>): Signal<T | undefined>;
declare function injectAll$<T extends Entity>(Entity: Type<T>, params?: Record<string, Observable<any>>, resolverType?: Type<BaseResolver<T>>): Observable<any[]>;
declare const callSignalMap: <T extends Record<string, Signal<any>>>(map: T) => Signal<T>;
declare function injectAll<T extends Entity>(Entity: Type<T>, params?: AllProps<Signal<any>>, resolverType?: Type<BaseResolver<T>>): Signal<T[]>;
type ValueOrObservable<T> = T | Observable<T>;
declare function mapToOne$<T extends {
    id: string;
}>(storeType: new () => EntityStore<T>, keyOrKey$: ValueOrObservable<string>): Observable<T>;

declare class EntityStoreService {
    protected storeMap: Map<Type<Entity>, EntityStore<Entity>>;
    get<E extends Entity>(Entity: Type<E>): EntityStore<E>;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityStoreService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EntityStoreService>;
}
declare function injectEntityStore<E extends Entity>(Entity: Type<E>): EntityStore<E>;

export { BaseEntityStore, ENTITY_STORE_ADAPTER, EntityStore, EntityStoreAdapter, EntityStoreService, ProxyIdService, TaskComposerService, callSignalMap, distinctUntilChangedArray, injectAll, injectAll$, injectEntityStore, injectEntityStoreAdapter, injectOne, injectOne$, mapToOne$, provideEntityStoreAdapter, pushMap };
export type { Entity, Task, ValueOrObservable };