import { StreamID, CommitID } from '@dustil/streamid';
import { AnchorService, Context, CreateOpts, LoadOpts, PinningOpts, PublishOpts, StreamState, UpdateOpts } from '@dustil/common';
import { PinStore } from '../store/pin-store.js';
import { DiagnosticsLogger } from '@dustil/common';
import { ExecutionQueue } from './execution-queue.js';
import { RunningState } from './running-state.js';
import { StateManager } from './state-manager.js';
import type { Dispatcher } from '../dispatcher.js';
import type { ConflictResolution } from '../conflict-resolution.js';
import type { HandlersMap } from '../handlers-map.js';
import { Observable } from 'rxjs';
import { StateCache } from './state-cache.js';
import { SnapshotState } from './snapshot-state.js';
import { LocalIndexApi } from '../indexing/local-index-api.js';
import { IKVStore } from '../store/ikv-store.js';
import { AnchorRequestStore } from '../store/anchor-request-store.js';
export declare type RepositoryDependencies = {
    dispatcher: Dispatcher;
    pinStore: PinStore;
    stateStore: IKVStore;
    anchorRequestStore: AnchorRequestStore;
    context: Context;
    handlers: HandlersMap;
    anchorService: AnchorService;
    conflictResolution: ConflictResolution;
    indexing: LocalIndexApi;
};
export declare class Repository {
    #private;
    private readonly logger;
    readonly loadingQ: ExecutionQueue;
    readonly executionQ: ExecutionQueue;
    readonly inmemory: StateCache<RunningState>;
    stateManager: StateManager;
    constructor(cacheLimit: number, concurrencyLimit: number, logger: DiagnosticsLogger);
    injectStateStore(stateStore: IKVStore): Promise<void>;
    init(): Promise<void>;
    get pinStore(): PinStore;
    get anchorRequestStore(): AnchorRequestStore;
    get index(): LocalIndexApi;
    setDeps(deps: RepositoryDependencies): void;
    private fromMemory;
    private fromStateStore;
    private fromNetwork;
    _loadGenesis(streamId: StreamID): Promise<[RunningState, boolean]>;
    load(streamId: StreamID, opts: LoadOpts): Promise<RunningState>;
    loadAtCommit(commitId: CommitID, opts: LoadOpts): Promise<SnapshotState>;
    loadAtTime(streamId: StreamID, opts: LoadOpts): Promise<SnapshotState>;
    applyCommit(streamId: StreamID, commit: any, opts: CreateOpts | UpdateOpts): Promise<RunningState>;
    applyWriteOpts(state$: RunningState, opts: CreateOpts | UpdateOpts): Promise<void>;
    handlePinOpts(state$: RunningState, opts: PinningOpts): Promise<void>;
    applyCreateOpts(streamId: StreamID, opts: CreateOpts): Promise<RunningState>;
    fromMemoryOrStore(streamId: StreamID): Promise<RunningState | undefined>;
    streamState(streamId: StreamID): Promise<StreamState | undefined>;
    add(state$: RunningState): void;
    pin(state$: RunningState, force?: boolean): Promise<void>;
    unpin(state$: RunningState, opts?: PublishOpts): Promise<void>;
    listPinned(streamId?: StreamID): Promise<string[]>;
    randomPinnedStreamState(): Promise<StreamState | null>;
    indexStreamIfNeeded(state$: RunningState): Promise<void>;
    updates$(init: StreamState): Observable<StreamState>;
    close(): Promise<void>;
}
//# sourceMappingURL=repository.d.ts.map