import { Store, OrArray, StoreValue } from '@ngneat/elf';
import { EntitiesState, getIdType, EntitiesRef, getEntityType, DefaultEntitiesRef } from '@ngneat/elf-entities';
export interface EntitiesTimelineOptions {
    showIfEmpty: boolean;
}
export interface EntitiesStateHistoryOptions<T extends Store<any, StoreValue<any> & EntitiesState<E>>, E extends EntitiesRef, S extends StoreValue<T> = StoreValue<T>> {
    maxAge: number;
    entitiesRef?: E;
    entityIds?: OrArray<getIdType<EntitiesState<E>, E>>;
    comparatorFn: (prevState: getEntityType<S, E>, currentState: getEntityType<S, E>) => boolean;
}
declare type EntityHistory<E extends EntitiesRef> = {
    past: Array<getEntityType<EntitiesState<E>, E>>;
    present: getEntityType<EntitiesState<E>, E> | null;
    future: Array<getEntityType<EntitiesState<E>, E>>;
};
export declare class EntitiesStateHistory<T extends Store<any, StoreValue<any> & EntitiesState<E>>, E extends EntitiesRef, S extends StoreValue<T> = StoreValue<T>> {
    protected store: T;
    private options;
    private entitiesHistory;
    private entitiesChanges;
    private pausedEntitiesChanges;
    private skipUpdate;
    private subscription;
    private mergedOptions;
    constructor(store: T, options?: Partial<EntitiesStateHistoryOptions<T, E, S>>);
    activate(): void;
    hasPast(id: getIdType<S, E>): boolean;
    hasFuture(id: getIdType<S, E>): boolean;
    getEntitiesPast(options?: EntitiesTimelineOptions): Record<getIdType<EntitiesState<E>, E>, Array<getEntityType<EntitiesState<E>, E>>>;
    getEntitiesFuture(options?: EntitiesTimelineOptions): Record<getIdType<EntitiesState<E>, E>, Array<getEntityType<EntitiesState<E>, E>>>;
    undo(ids?: OrArray<getIdType<S, E>>): void;
    redo(ids?: OrArray<getIdType<S, E>>): void;
    jumpToPast(index: number, ids?: OrArray<getIdType<S, E>>): void;
    jumpToFuture(index: number, ids?: OrArray<getIdType<S, E>>): void;
    /**
     *
     * Clear the past history.
     * It's different from clear method since it doesn't remove present state
     *
     * @param ids Entities ids which past history will be erased
     *
     * @example
     *
     * stateHistory.clearPast([1, 2]);
     */
    clearPast(ids?: OrArray<getIdType<S, E>>): void;
    /**
     *
     * Clear the future history
     * It's different from clear method since it doesn't remove present state
     *
     * @param ids Entities ids which future history will be erased
     *
     * @example
     *
     * stateHistory.clearFuture([1, 2]);
     */
    clearFuture(ids?: OrArray<getIdType<S, E>>): void;
    /**
     *
     * Clear the history
     *
     * @param ids Entities ids which history will be erased
     *
     * @param customUpdateFn Update function to update history manually
     *
     * @example
     *
     * stateHistory.clear([1, 2]);
     */
    clear(ids?: OrArray<getIdType<S, E>>, customUpdateFn?: (history: EntityHistory<E>) => EntityHistory<E>): void;
    destroy({ clearHistory }?: {
        clearHistory?: boolean;
    }): void;
    pause(ids?: OrArray<getIdType<S, E>>): void;
    resume(ids?: OrArray<getIdType<S, E>>): void;
    private get entitiesRef();
    private update;
    private subscribeToEntityChanges;
    private unsubscribeFromEntityChanges;
    private getEntitiesIds;
    private getDefaultHistory;
}
declare type WithEntitiesState<S extends StoreValue<Store>, E extends EntitiesRef> = S extends EntitiesState<E> & infer R ? EntitiesState<E> & R : S extends EntitiesState<E> ? EntitiesState<E> : never;
export declare function entitiesStateHistory<T extends Store<any, WithEntitiesState<StoreValue<T>, E>>, E extends EntitiesRef = DefaultEntitiesRef>(store: T, options?: Partial<EntitiesStateHistoryOptions<T, E>>): EntitiesStateHistory<T, E, ReturnType<T["getValue"]>>;
export {};