import type { AgentTool } from '@earendil-works/pi-agent-core';
import type { MemoryRuntime } from '../../agent-runtime/memory-runtime.js';
import type { MemoryProvider, MemoryProviderInitOptions } from './provider.js';
import type { UnderstandingCandidate } from './understanding/types.js';
import type { MemoryDeleteRequest, MemoryListRequest, MemoryReadRequest, MemoryReadResult, MemorySearchRequest, MemorySearchResult, MemoryUpdateRequest, MemoryWriteRequest, MemoryWriteResult, MemoryRecord, MemorySignal, MemoryKind } from './types.js';
export type MemorySearchStrategy = 'local-first' | 'external-first' | 'fanout' | 'local-only' | 'external-only';
export type MemoryWriteStrategy = 'local-first' | 'external-first' | 'write-through' | 'local-only' | 'external-only';
export interface MemoryRoutingOptions {
    searchStrategy?: MemorySearchStrategy;
    writeStrategy?: MemoryWriteStrategy;
    replicateTo?: string[];
}
export interface MemoryManagerOptions extends MemoryRoutingOptions {
    loadProviders?: () => Promise<MemoryProvider[]>;
    writePolicy?: MemoryWritePolicy;
    memoryRuntime?: MemoryRuntime;
}
export interface MemoryWritePolicy {
    allowExternalWrites?: boolean;
    allowedProviderIds?: string[];
    autoWriteKinds?: MemoryKind[];
}
export declare class MemoryManager {
    private providers;
    private toolToProvider;
    private readonly routing;
    private readonly loadProviders?;
    private readonly writePolicy;
    private pluginProvidersLoaded;
    private readonly understanding;
    private readonly memoryRuntime?;
    private readonly lastTurnSourceItem;
    private readonly sessionContexts;
    constructor(options?: MemoryManagerOptions);
    addProvider(provider: MemoryProvider): void;
    get providersList(): MemoryProvider[];
    /** Static instructions contributed by external memory providers. */
    buildExternalSystemPrompt(): string;
    queuePrefetchAll(query: string, options?: {
        sessionId?: string;
    }): void;
    syncAll(userContent: string, assistantContent: string, options?: {
        sessionId?: string;
    }): Promise<void>;
    captureTurnUnderstanding(userContent: string, assistantContent: string, options?: {
        agentId?: string;
        sessionId?: string;
        turnId?: string;
        workspaceId?: string;
        projectId?: string;
        correctionTargetRecordIds?: string[];
    }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
    syncProvidersForTurn(userContent: string, assistantContent: string, options?: {
        sessionId?: string;
    }): Promise<void>;
    applyUnderstandingCandidates(candidates: UnderstandingCandidate[], context?: {
        agentId?: string;
        sessionKey?: string;
        workspaceId?: string;
        projectId?: string;
        sourceItemId?: string;
        sourceItemIds?: string[];
        sourceText?: string;
        source?: MemoryRecord['source'];
        reviewSource?: 'turn' | 'background';
    }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
    getExternalToolEntries(): Array<{
        providerId: string;
        tool: AgentTool;
    }>;
    handleToolCall(toolName: string, args: Record<string, unknown>): Promise<string>;
    search(request: MemorySearchRequest): Promise<MemorySearchResult[]>;
    read(request: MemoryReadRequest): Promise<MemoryReadResult | null>;
    get(id: string): Promise<MemoryRecord | null>;
    list(request: MemoryListRequest): Promise<MemoryRecord[]>;
    write(request: MemoryWriteRequest): Promise<MemoryWriteResult>;
    update(request: MemoryUpdateRequest): Promise<MemoryWriteResult>;
    delete(request: MemoryDeleteRequest): Promise<MemoryWriteResult>;
    private canReadRecord;
    recordSignal(signal: MemorySignal): void;
    initializeAll(sessionId: string, options?: MemoryProviderInitOptions): Promise<void>;
    private loadPluginProvidersOnce;
    shutdownAll(): Promise<void>;
    private providersForSearch;
    private providersForWrite;
    private writeWithStrategy;
    private providerAllowedForWrite;
    private trace;
}