import { type KeyState } from '@kokuin/controller';
import { type DIDMethodResolver } from '@kokuin/token';
import type { StoreProvider } from '@kubun/db';
import { type Logger } from '@kubun/logger';
import { type ControllerHead } from './controller-head.js';
import type { EngineEvents } from './engine-events.js';
import type { EngineEventBus } from './events.js';
import type { ConsultOptions, Provider } from './providers.js';
export declare const DEFAULT_CONTROLLER_LOG_TTL_MS = 300000;
export declare class ControllerLogPrefetchRequired extends Error {
    #private;
    constructor(dids: ReadonlyArray<string>, reason?: 'unavailable');
    get code(): string;
    get dids(): ReadonlyArray<string>;
    get extensions(): {
        code: string;
        dids: ReadonlyArray<string>;
    };
}
export declare function controllerLogPrefetchError(error: unknown): ControllerLogPrefetchRequired | undefined;
export type ControllerResolverView = DIDMethodResolver & {
    frozen?: () => DIDMethodResolver;
};
export declare function rootOnlyResolver(resolver: ControllerResolverView): ControllerResolverView;
export type ControllerLogResolverParams = {
    eventBus: EngineEventBus<EngineEvents>;
    head: ControllerHead;
    logger?: Logger;
    /** The base provider background pulls ingest through, never a transaction. */
    stores: StoreProvider;
    ttlMs: number;
    consultProviders: <Impl extends Record<string, unknown>, R>(kind: string, invoke: (provider: Provider<Impl>) => Promise<R | undefined>, opts?: ConsultOptions) => Promise<R | undefined>;
};
export type ControllerHeadOnlineResult = {
    status: 'none';
} | {
    status: 'head';
    fetchedAt: number;
    head: {
        generation: number;
        sequence: number;
        digest: string;
    };
};
export declare class ControllerLogResolver {
    #private;
    constructor(params: ControllerLogResolverParams);
    /** Network confirmation excludes local and direct providers. Prefetch on a base provider. */
    fetchControllerHeadOnline(did: string, provider: StoreProvider): Promise<ControllerHeadOnlineResult>;
    /** Stops starting pulls and waits for the ones in flight. */
    dispose(): Promise<void>;
    /** Reads through the caller's provider so apply transactions see their own controller writes. */
    resolverFor(provider: StoreProvider, opts?: {
        localOnly?: boolean;
    }): DIDMethodResolver & {
        resolveHead?: (did: string) => Promise<KeyState>;
    };
}