import type { AgentMessage } from '@earendil-works/pi-agent-core';
import type { Api, Model } from '@earendil-works/pi-ai/compat';
import type { Config } from '../config/schema.js';
import { type CompactionConfig, type CompactionExecutionOptions, type CompactionResult } from '../agent/memory/compaction.js';
import { type WindowConfig } from '../agent/memory/window.js';
import { type SessionMetadataSeed } from '../storage/sqlite/index.js';
import type { XopcSessionTranscriptV1 } from './transcript-format.js';
import { type TranscriptStoredRow, type XopcTranscriptContextEntry } from './session-context-for-llm.js';
import type { SessionMetadata, SessionDetail, SessionListQuery, PaginatedResult, GlobalSessionStats, ExportFormat, CompactionBoundarySummary } from './types.js';
import { SessionStatus } from './types.js';
import type { Message } from './types.js';
import type { SessionTranscriptUpdate } from './transcript-events.js';
export interface SessionStoreOptions {
    config: Config;
}
export interface SessionCompactionHooks {
    before?: (event: {
        sessionKey: string;
        messageCount: number;
        tokenCount: number;
    }) => Promise<void> | void;
    after?: (event: {
        sessionKey: string;
        messageCount: number;
        tokenCount: number;
        compactedCount: number;
    }) => Promise<void> | void;
}
export type ModelFallbackPreparation = 'prompt' | 'resume' | 'unsafe';
export declare class SessionStore {
    private options;
    private window;
    private compactor;
    private compactionHooks;
    constructor(options: SessionStoreOptions, windowConfig?: Partial<WindowConfig>, compactionConfig?: Partial<CompactionConfig>);
    setCompactionHooks(hooks: SessionCompactionHooks): void;
    private runCompactionHook;
    private resolveWorkspaceCwd;
    private runStoreMutation;
    initialize(): Promise<void>;
    getSessionsRoot(): string;
    resolveTranscriptPath(sessionKey: string, options?: {
        metadata?: SessionMetadataSeed;
    }): Promise<{
        sessionId: string;
        sessionKey: string;
    }>;
    appendTranscriptMessage(sessionKey: string, message: AgentMessage, options?: {
        metadata?: SessionMetadataSeed;
    }): Promise<void>;
    getByAgent(agentId: string): Promise<SessionMetadata[]>;
    getByAccount(accountId: string): Promise<SessionMetadata[]>;
    getByPeer(peerKind: string, peerId: string): Promise<SessionMetadata[]>;
    getMainSession(channel: string, accountId: string): Promise<SessionMetadata | null>;
    refreshIndex(): Promise<void>;
    list(query?: SessionListQuery): Promise<PaginatedResult<SessionMetadata>>;
    get(key: string, options?: {
        includeTranscriptSummary?: boolean;
        includeTranscriptRows?: boolean;
    }): Promise<SessionDetail | null>;
    getMessagePage(key: string, options?: {
        offset?: number;
        limit?: number;
        before?: string;
        includeTranscriptSummary?: boolean;
        includeTranscriptRows?: boolean;
        includeContextRows?: boolean;
    }): Promise<{
        session: SessionDetail;
        pagination: {
            total: number;
            limit: number;
            offset: number;
            hasMore: boolean;
            before?: string;
            nextBeforeCursor?: string;
        };
    } | null>;
    private buildSessionDetail;
    loadTranscriptRows(key: string): Promise<TranscriptStoredRow[]>;
    loadTranscriptHistoryRows(key: string): Promise<TranscriptStoredRow[]>;
    prepareModelFallback(key: string, rowsBeforeAttempt: readonly TranscriptStoredRow[]): Promise<ModelFallbackPreparation>;
    getMetadata(key: string): Promise<SessionMetadata | null>;
    resolveKeyBySessionId(sessionId: string): Promise<string | null>;
    updateMetadata(key: string, updates: Partial<SessionMetadata>): Promise<void>;
    reset(key: string): Promise<{
        sessionId: string;
        previousSessionId: string;
    } | null>;
    delete(key: string): Promise<boolean>;
    deleteMany(keys: string[]): Promise<{
        success: string[];
        failed: string[];
    }>;
    setStatus(key: string, status: SessionStatus): Promise<void>;
    archive(key: string): Promise<void>;
    unarchive(key: string): Promise<void>;
    pin(key: string): Promise<void>;
    unpin(key: string): Promise<void>;
    loadMessages(_key: string, _options?: {
        fromArchive?: boolean;
    }): Promise<AgentMessage[]>;
    loadTranscriptDocument(key: string): Promise<XopcSessionTranscriptV1 | null>;
    syncEmbeddedTranscriptUpdate(update: SessionTranscriptUpdate): Promise<void>;
    appendTranscriptContextEntry(key: string, entry: Omit<XopcTranscriptContextEntry, 'kind'> & Partial<Pick<XopcTranscriptContextEntry, 'kind'>>): Promise<void>;
    appendTranscriptLabelEntry(key: string, entry: {
        targetId: string;
        label?: string;
    }): Promise<void>;
    appendTranscriptCustomEntry(key: string, entry: {
        customType: string;
        data?: unknown;
    }): Promise<void>;
    appendTranscriptCustomMessageEntry(key: string, entry: {
        customType: string;
        content?: string | unknown[];
        display?: boolean;
        details?: unknown;
    }): Promise<void>;
    appendTranscriptBashExecutionEntry(key: string, entry: {
        command: string;
        output?: string;
        exitCode?: number | null;
        signal?: string | null;
        excludeFromContext?: boolean;
        truncated?: boolean;
        fullOutputPath?: string;
    }): Promise<void>;
    saveMessages(key: string, messages: AgentMessage[], options?: {
        metadata?: SessionMetadataSeed;
    }): Promise<void>;
    deleteUserRound(key: string, userRoundIndex: number): Promise<{
        deleted: number;
        removedMessages: AgentMessage[];
        remainingMessages: AgentMessage[];
    } | null>;
    getWindowStats(messages: AgentMessage[]): {
        total: number;
        system: number;
        user: number;
        assistant: number;
        tool: number;
        needsTrim: boolean;
    };
    applyCompaction(key: string, messages: AgentMessage[], result: CompactionResult): Promise<AgentMessage[]>;
    compact(key: string, messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, executionOptions?: CompactionExecutionOptions): Promise<CompactionResult>;
    getCompactionStats(key: string): Promise<{
        compactionCount: number;
        totalTokensBefore: number;
        totalTokensAfter: number;
        lastCompactionAt: string;
    }>;
    listCompactionBoundaries(key: string): Promise<CompactionBoundarySummary[]>;
    restoreBeforeCompactionBoundary(key: string, compactionId: string): Promise<void>;
    deleteSession(key: string): Promise<boolean>;
    load(key: string, options?: {
        fromArchive?: boolean;
    }): Promise<AgentMessage[]>;
    estimateTokenUsage(_key: string, messages: AgentMessage[]): Promise<number>;
    searchInSession(key: string, keyword: string): Promise<Message[]>;
    exportSession(key: string, format: ExportFormat): Promise<string>;
    importSessionExport(targetKey: string, jsonContent: string): Promise<{
        sessionKey: string;
        rowCount: number;
    }>;
    forkSession(sourceKey: string, targetKey: string): Promise<{
        sessionKey: string;
        rowCount: number;
    }>;
    forkSessionRows(sourceKey: string, targetKey: string, options?: {
        throughRow?: number;
    }): Promise<{
        sessionKey: string;
        rowCount: number;
    }>;
    getStats(): Promise<GlobalSessionStats>;
    archiveOld(olderThanDays: number): Promise<number>;
    estimateTokens(messages: AgentMessage[]): number;
    private loadDisplayMessages;
    private paginateDisplayMessages;
    private messageContent;
    private extractTextContent;
    private injectPostCompactionContext;
    private convertMessages;
}