import { M as Message, f as MaybePromise, D as DataRegion } from './message-CyXbT7Zj.cjs';

interface RetrievedDocument {
    id: string;
    content: string;
    source?: string;
    score?: number;
    metadata?: Record<string, unknown>;
}
interface RetrieverRequest {
    query: string;
    messages: Message[];
}
interface Retriever {
    retrieve: (request: RetrieverRequest) => MaybePromise<RetrievedDocument[]>;
}

interface ChatMemory {
    /** Data-residency region for this memory backend, when known. */
    region?: DataRegion;
    load: (options?: MemoryOperationOptions) => MaybePromise<Message[]>;
    save: (messages: Message[], options?: MemoryOperationOptions) => MaybePromise<void>;
    clear?: (options?: MemoryOperationOptions) => MaybePromise<void>;
}
interface MemoryOperationOptions {
    signal?: AbortSignal;
}
interface VectorDocument {
    id: string;
    content: string;
    embedding: number[];
    metadata?: Record<string, unknown>;
}
/**
 * Normalized metadata-filter shape (v1). Every vector backend translates
 * this into its own native filter language; callers stay portable.
 *
 * - Object form is field → predicate (implicit AND across fields).
 * - Predicate is either a primitive (shorthand for `{ $eq: ... }`) or one
 *   of the operator objects below.
 * - `$and` / `$or` compose nested filters.
 *
 * Example:
 *   { tags: { $in: ['docs', 'rag'] }, version: { $gte: 2 } }
 *   { $or: [{ author: 'alice' }, { author: 'bob' }] }
 */
type VectorFilterPrimitive = string | number | boolean | null;
type VectorFilterOperator = {
    $eq: VectorFilterPrimitive;
} | {
    $ne: VectorFilterPrimitive;
} | {
    $in: VectorFilterPrimitive[];
} | {
    $nin: VectorFilterPrimitive[];
} | {
    $gt: number | string;
} | {
    $gte: number | string;
} | {
    $lt: number | string;
} | {
    $lte: number | string;
} | {
    $exists: boolean;
};
type VectorFilterPredicate = VectorFilterPrimitive | VectorFilterOperator;
interface VectorFilterCompound {
    $and?: VectorFilter[];
    $or?: VectorFilter[];
}
type VectorFilter = VectorFilterCompound | {
    [field: string]: VectorFilterPredicate;
};
interface VectorSearchOptions {
    topK?: number;
    threshold?: number;
    /** Metadata filter applied to candidates before / during similarity search. */
    filter?: VectorFilter;
}
interface VectorMemory {
    /** Data-residency region for this vector backend, when known. */
    region?: DataRegion;
    store: (docs: VectorDocument[]) => MaybePromise<void>;
    search: (embedding: number[], options?: VectorSearchOptions) => MaybePromise<RetrievedDocument[]>;
    delete?: (ids: string[]) => MaybePromise<void>;
}
type EmbedFn = (text: string) => Promise<number[]>;

export type { ChatMemory as C, EmbedFn as E, RetrievedDocument as R, VectorDocument as V, Retriever as a, RetrieverRequest as b, VectorFilter as c, VectorFilterCompound as d, VectorFilterOperator as e, VectorFilterPredicate as f, VectorFilterPrimitive as g, VectorMemory as h, VectorSearchOptions as i };