import { Dispatcher } from './dispatcher.js';
import { StreamID, CommitID, StreamRef } from '@dustil/streamid';
import { IpfsTopology } from '@dustil/ipfs-topology';
import { CreateOpts, Stream, StreamHandler, Context, LoadOpts, AnchorService, CeramicApi, CeramicCommit, IpfsApi, PinApi, MultiQuery, PinningBackendStatic, LoggerProvider, Networks, UpdateOpts, SyncOptions, AnchorValidator, AnchorStatus, StreamState, AdminApi } from '@dustil/common';
import { DID } from 'dids';
import { PinStoreFactory } from './store/pin-store-factory.js';
import { Repository } from './state-management/repository.js';
import { HandlersMap } from './handlers-map.js';
import { LocalIndexApi } from './indexing/local-index-api.js';
import { ShutdownSignal } from './shutdown-signal.js';
import { IndexingConfig } from './indexing/build-indexing.js';
export declare const DEFAULT_STATE_STORE_DIRECTORY: string;
export interface CeramicConfig {
    ethereumRpcUrl?: string;
    anchorServiceUrl?: string;
    stateStoreDirectory?: string;
    ipfsPinningEndpoints?: string[];
    pinningBackends?: PinningBackendStatic[];
    loggerProvider?: LoggerProvider;
    gateway?: boolean;
    indexing?: IndexingConfig;
    networkName?: string;
    pubsubTopic?: string;
    streamCacheLimit?: number;
    concurrentRequestsLimit?: number;
    useCentralizedPeerDiscovery?: boolean;
    syncOverride?: SyncOptions;
    [index: string]: any;
}
export interface CeramicModules {
    anchorService: AnchorService | null;
    anchorValidator: AnchorValidator;
    dispatcher: Dispatcher;
    ipfs: IpfsApi;
    ipfsTopology: IpfsTopology;
    loggerProvider: LoggerProvider;
    pinStoreFactory: PinStoreFactory;
    repository: Repository;
    shutdownSignal: ShutdownSignal;
}
export interface CeramicParameters {
    gateway: boolean;
    stateStoreDirectory?: string;
    indexingConfig: IndexingConfig;
    networkOptions: CeramicNetworkOptions;
    loadOptsOverride: LoadOpts;
}
interface CeramicNetworkOptions {
    name: Networks;
    pubsubTopic: string;
}
export declare class Ceramic implements CeramicApi {
    readonly context: Context;
    readonly dispatcher: Dispatcher;
    readonly loggerProvider: LoggerProvider;
    readonly pin: PinApi;
    readonly admin: AdminApi;
    readonly repository: Repository;
    readonly _streamHandlers: HandlersMap;
    private readonly _anchorValidator;
    private readonly _gateway;
    private readonly _ipfsTopology;
    private readonly _logger;
    private readonly _networkOptions;
    private _supportedChains;
    private readonly _loadOptsOverride;
    private readonly _shutdownSignal;
    private readonly _levelStore;
    constructor(modules: CeramicModules, params: CeramicParameters);
    get index(): LocalIndexApi;
    get ipfs(): IpfsApi;
    get did(): DID | undefined;
    set did(did: DID);
    private _buildPinApi;
    private static _generateNetworkOptions;
    private _loadSupportedChains;
    static _processConfig(ipfs: IpfsApi, config: CeramicConfig): [CeramicModules, CeramicParameters];
    static create(ipfs: IpfsApi, config?: CeramicConfig): Promise<Ceramic>;
    _init(doPeerDiscovery: boolean): Promise<void>;
    _startupChecks(): Promise<void>;
    _checkIPFSPersistence(): Promise<void>;
    setDID(did: DID): Promise<void>;
    addStreamHandler<T extends Stream>(streamHandler: StreamHandler<T>): void;
    applyCommit<T extends Stream>(streamId: string | StreamID, commit: CeramicCommit, opts?: CreateOpts | UpdateOpts): Promise<T>;
    requestAnchor(streamId: string | StreamID, opts?: LoadOpts): Promise<AnchorStatus>;
    createStreamFromGenesis<T extends Stream>(type: number, genesis: any, opts?: CreateOpts): Promise<T>;
    loadStream<T extends Stream>(streamId: StreamID | CommitID | string, opts?: LoadOpts): Promise<T>;
    _ensureGenesis(genesis: CeramicCommit, streamRef: StreamRef): Promise<void>;
    _loadLinkedStreams(query: MultiQuery, timeout: number): Promise<Record<string, Stream>>;
    multiQuery(queries: Array<MultiQuery>, timeout?: number): Promise<Record<string, Stream>>;
    loadStreamCommits(streamId: string | StreamID): Promise<Record<string, any>[]>;
    getSupportedChains(): Promise<Array<string>>;
    buildStreamFromState<T extends Stream = Stream>(state: StreamState): T;
    close(): Promise<void>;
}
export {};
//# sourceMappingURL=ceramic.d.ts.map