export type MemoryType = 'recently_memory' | 'agent_memory' | 'project_memory' | 'session_context';

export declare function normalizeBoundFilePath(filePath: string): string;
export interface MemoryRecord {
    id: string;
    uri: string;
    domain: string;
    path: string;
    title?: string;
    content: string;
    memory_type: MemoryType;
    createdAt: string;
    updatedAt: string;
    version: number;
    keywords?: string[];
    bound_files?: string[];
    file_md5_map?: Record<string, string>;
    updating_agent_id?: string;
    last_check_time?: string;
    expiresAt?: string;
    memory_status?: 'normal' | 'recalling' | 'updating';
    lease_expires_at?: string;
    path_prefix?: string;
    "readonly"?: boolean;
    source_agent_id?: string;
    source_display_name?: string;
    source_role_name?: string;
    source_workspace_path?: string;
}
export type TodoStatus = 'pending' | 'completed';
export interface CreateMemoryInput {
    memory_type: MemoryType;
    uri: string;
    title?: string;
    content: string;
    keywords?: string[];
    bound_files?: string[];
    file_md5_map?: Record<string, string>;
    last_check_time?: string;
    expiresAt?: string;
}
export interface UpdateMemoryInput {
    memory_type?: MemoryType;
    uri: string;
    title?: string;
    old_string?: string;
    new_string?: string;
    append?: string;
    keywords?: string[];
    bound_files?: string[];
    updating_agent_id?: string;
    file_md5_map?: Record<string, string>;
    last_check_time?: string;
    expiresAt?: string;
    memory_status?: 'normal' | 'recalling' | 'updating';
}
export interface ReadMemoryInput {
    memory_type?: MemoryType;
    uri: string;
}
export interface DeleteMemoryInput {
    memory_type?: MemoryType;
    uri: string;
}
export interface SearchMemoryInput {
    query: string;
    limit?: number;
    memory_type?: MemoryType;
    keywords?: string[];
    keyword_mode?: 'any' | 'all';
    scope?: 'own' | 'children' | 'all';
}
export interface MemoryCapacityErrorDetails {
    code: 'MEMORY_TYPE_LIMIT_REACHED' | 'MEMORY_LISTABLE_TOTAL_LIMIT_REACHED';
    memory_type: MemoryType;
    domain?: string;
    limit: number;
    current: number;
    recommended_actions: string[];
}
export declare class MemoryCapacityError extends Error {
    readonly details: MemoryCapacityErrorDetails;
    constructor(message: string, details: MemoryCapacityErrorDetails);
}
export interface MemoryTypeStats {
    count: number;
    limit: number | null;
    hardLimit: number | null;
    exceeded: boolean;
    hardExceeded: boolean;
    listable: boolean;
    domainCount: number;
    by_domain: Record<string, MemoryDomainStats>;
}
export interface MemoryDomainStats {
    count: number;
    limit: number | null;
    hardLimit: number | null;
    exceeded: boolean;
    hardExceeded: boolean;
}
export interface MemoryStats {
    total: number;
    listable: {
        count: number;
        limit: number;
        hardLimit: number;
        exceeded: boolean;
        hardExceeded: boolean;
    };
    by_type: Record<MemoryType, MemoryTypeStats>;
}
export interface ListByFileOptions {
    memory_type?: MemoryType;
    scope?: 'own' | 'children' | 'all';
}
export interface MemoryStorePort {
    getStats(): Promise<MemoryStats>;
    createMemory(input: CreateMemoryInput): Promise<MemoryRecord>;
    readMemory(input: ReadMemoryInput): Promise<MemoryRecord | null>;
    updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
    deleteMemory(input: DeleteMemoryInput): Promise<boolean>;
    searchMemory(input: SearchMemoryInput): Promise<{
        query: string;
        results: MemoryRecord[];
    }>;
    listByType(memory_type: string): Promise<MemoryRecord[]>;
    listByFile(filePath: string, memory_type?: MemoryType | ListByFileOptions): Promise<MemoryRecord[]>;
    listExpiredRecentlyMemories(): Promise<MemoryRecord[]>;
    markExpiredMemoriesRecalling(uris?: string[]): Promise<{
        marked: number;
        uris: string[];
    }>;
    clearRecallingExpiredMemories(uris?: string[]): Promise<{
        deleted: number;
        uris: string[];
    }>;
    claimMemoryUpdate(uris: string[], leaseMinutes: number, memoryType?: string): Promise<{
        claimed_uris: string[];
    }>;
    renewMemoryLease(leaseMinutes: number): Promise<{
        renewed: number;
    }>;
    releaseMemoryClaim(uri: string): Promise<{
        released: boolean;
    }>;
    releaseAllMemoryClaims(): Promise<{
        released: number;
    }>;
    getMyClaimedUris(): Promise<string[]>;
}
export declare class MemoryStore implements MemoryStorePort {
    private readonly storePath;
    constructor(storePath: string);
    private nowIso;
    private normalizeUri;
    private normalizeMemoryType;
    private ensureTypeMatch;
    
    private ensureStoreDir;
    
    private loadMemoryFile;
    
    private loadData;
    private writeJsonAtomically;
    
    private saveData;
    private createEmptyStats;
    
    private calculateStats;
    private generateId;
    
    private ensureListableMemoryCapacity;
    
    private ensureSessionContextCapacity;
    getStats(): Promise<MemoryStats>;
    
    private static calcAgentMemoryExpiresAt;
    
    static isExpirableType(memoryType: string | undefined): boolean;
    createMemory(input: CreateMemoryInput): Promise<MemoryRecord>;
    readMemory(input: ReadMemoryInput): Promise<MemoryRecord | null>;
    updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
    deleteMemory(input: DeleteMemoryInput): Promise<boolean>;
    
    listExpiredRecentlyMemories(): Promise<MemoryRecord[]>;
    
    searchMemory(input: SearchMemoryInput): Promise<{
        query: string;
        results: MemoryRecord[];
    }>;
    listByType(memory_type: string): Promise<MemoryRecord[]>;
    
    listByFile(filePath: string, memory_type?: MemoryType | ListByFileOptions): Promise<MemoryRecord[]>;
    
    markExpiredMemoriesRecalling(uris?: string[]): Promise<{
        marked: number;
        uris: string[];
    }>;
    
    clearRecallingExpiredMemories(uris?: string[]): Promise<{
        deleted: number;
        uris: string[];
    }>;
    claimMemoryUpdate(_uris: string[], _leaseMinutes: number, _memoryType?: string): Promise<{
        claimed_uris: string[];
    }>;
    renewMemoryLease(_leaseMinutes: number): Promise<{
        renewed: number;
    }>;
    releaseMemoryClaim(_uri: string): Promise<{
        released: boolean;
    }>;
    releaseAllMemoryClaims(): Promise<{
        released: number;
    }>;
    getMyClaimedUris(): Promise<string[]>;
}