/**
 * @license
 * Copyright 2026 Alibaba Group Holding Limited
 * Copyright 2026 Qwen
 * SPDX-License-Identifier: Apache-2.0
 * Adapted to TypeScript from qwen-omni-realtime-agent; modified for Qwen Live Harness.
 */
import type { DatabaseSync } from 'node:sqlite';
import type { MemoryConfig, MemoryConnection, MemoryLogger } from './config.js';
export { UPDATER_PROMPT } from './prompts.js';
export declare const UPDATER_FIELD_ORDER: readonly ["name", "occupation_or_role", "preferences", "routines", "interests", "long_term_goals", "relationships", "appearance"];
export type ConsolidationStatus = 'applied' | 'empty' | 'failed' | 'skipped';
export interface UpdaterInput {
    ltmValues: Record<string, string[]>;
    stmRows: ReadonlyArray<Record<string, unknown>>;
    wmEntries: readonly string[];
    now: Date;
}
export declare function formatUpdaterInput(input: UpdaterInput): string;
export declare function parsePatch(text: unknown): Record<string, unknown> | undefined;
export declare function isEmptyPatch(patch: Record<string, unknown>): boolean;
export declare function normalizeDate(value: unknown): string | null;
export interface ApplyReport {
    ltm: {
        set: number;
        added: number;
        removed: number;
        removeMissed: number;
    };
    stm: {
        added: number;
        updated: number;
        removed: number;
        unknownIds: number;
        staleText: number;
    };
    unknownFields: string[];
    rejected: string[];
}
export declare function applyPatch(database: DatabaseSync, patch: Record<string, unknown>, sessionId: string, now?: Date, log?: MemoryLogger): ApplyReport;
export interface UpdaterClientOptions {
    config: MemoryConfig['updater'];
    connection: MemoryConnection;
    log?: MemoryLogger;
    fetch?: typeof fetch;
    transport?: (prompt: string, message: string, signal?: AbortSignal) => Promise<string>;
}
export declare class UpdaterClient {
    private readonly options;
    readonly model: string;
    private readonly connection;
    constructor(options: UpdaterClientOptions);
    get available(): boolean;
    get unavailableReason(): string;
    consolidate(input: UpdaterInput, signal?: AbortSignal): Promise<Record<string, unknown> | undefined>;
}
export interface ConsolidationSnapshot {
    libraryId: string;
    sessionId: string;
    wmSeq: number;
    wmEntries: readonly string[];
    database: DatabaseSync;
    config: MemoryConfig;
    client: UpdaterClient;
    log?: MemoryLogger;
}
export declare function consolidateSnapshot(snapshot: ConsolidationSnapshot, signal?: AbortSignal): Promise<ConsolidationStatus>;
export interface ConsolidatableMemorySession {
    consolidationSnapshot(): ConsolidationSnapshot;
}
export declare class MemoryConsolidationQueue {
    private readonly tails;
    private readonly pending;
    private readonly controller;
    submit(session: ConsolidatableMemorySession): Promise<ConsolidationStatus>;
    drain(timeoutMs: number): Promise<boolean>;
    close(): void;
}