import { type SessionRef } from "./discovery.js";
import { type EntryRange, type MemoryIndexOptions, type SourceState, type TieredIndexBundle } from "./index.js";
import { type MemoryBranches, type SessionLineage } from "./lineage.js";
import { type NormalizationCoverage, type NormalizedEntry } from "./normalize.js";
import type { MemorySourceAction, MemorySourceRecord, MemorySourceSessionMetadata, PortableMemorySource } from "./portable.js";
import { type SourceObservation } from "./source-observation.js";
import { type MemoryProviderContext } from "./request-context.js";
export interface HostSnapshot {
    sourceId: string;
    sessionKey: string;
    displayKey: string;
    sessionId: string;
    revision: string;
    metadata: MemorySourceSessionMetadata;
    records: readonly MemorySourceRecord[];
    coverageReasons: string[];
    selectedLeafId?: string | null;
}
export declare const resolveRegisteredSource: (registry: {
    get(id: string): PortableMemorySource | undefined;
} | undefined, sourceId: string) => PortableMemorySource;
export declare const memorySourceFailure: (error: unknown) => {
    code: string;
    message: string;
} | null;
export declare const checkAbort: (signal: AbortSignal | undefined) => void;
export declare const listHostSnapshots: (source: PortableMemorySource, limit: number, action: MemorySourceAction, signal?: AbortSignal) => Promise<{
    snapshots: HostSnapshot[];
    coverageReasons: string[];
}>;
/** In-memory tiered index for host sources: identical tiers, budgets, and
 *  coverage semantics as the filesystem index, with no disk cache writes. */
export declare const loadHostTieredIndex: (snapshots: readonly HostSnapshot[], options: MemoryIndexOptions, hydrate?: boolean, entryRange?: EntryRange, extraReasons?: readonly string[]) => TieredIndexBundle;
/** Source-resolution strategy shared by filesystem and host-backed calls. */
export interface RecallSourcePlan {
    refs: SessionRef[];
    sessionKey: string | null;
    observeAll(branches: MemoryBranches): readonly SourceObservation[] | null;
    stateFor(ref: SessionRef): SourceState | null;
    lineageFor(ref: SessionRef, branches: MemoryBranches): SessionLineage;
    loadIndex(options: MemoryIndexOptions, hydrate: boolean, entryRange?: EntryRange): TieredIndexBundle;
}
export declare const fileRecallPlan: (refs: SessionRef[], context: MemoryProviderContext) => RecallSourcePlan;
export declare const hostRecallPlan: (source: PortableMemorySource, sourceId: string, sessionKey: string | null, context: MemoryProviderContext, signal?: AbortSignal) => Promise<RecallSourcePlan>;
export interface ExpansionAccess {
    ref: SessionRef;
    state(): SourceState | null;
    lineage(branches: MemoryBranches): SessionLineage;
    observe(branches: MemoryBranches): SourceObservation | null;
    normalizeFull(branches: MemoryBranches, policy: {
        indexThinking: boolean;
        indexToolOutput: boolean;
    }, lineage?: SessionLineage): {
        entries: NormalizedEntry[];
        indexCoverage: NormalizationCoverage;
    } | null;
}
export declare const fileExpansionAccess: (session: string, context: MemoryProviderContext) => ExpansionAccess | null;
export declare const hostExpansionAccess: (sourceId: string, session: string, context: MemoryProviderContext, signal?: AbortSignal) => Promise<ExpansionAccess>;
//# sourceMappingURL=host-source.d.ts.map