export type Namespace = string[];
export type StoreKey = string;
export interface StoreItem<T = unknown> {
    namespace: Namespace;
    key: StoreKey;
    value: T;
    createdAt: number;
    updatedAt: number;
    /** TTL in ms — item expires after this many ms from updatedAt */
    ttl?: number;
}
export interface SearchResult<T = unknown> {
    item: StoreItem<T>;
    score?: number;
}
export type EmbedFn = (text: string) => Promise<number[]>;
export declare abstract class BaseStore {
    abstract get<T = unknown>(namespace: Namespace, key: StoreKey): Promise<StoreItem<T> | null>;
    abstract put<T = unknown>(namespace: Namespace, key: StoreKey, value: T, opts?: {
        ttl?: number;
    }): Promise<void>;
    abstract delete(namespace: Namespace, key: StoreKey): Promise<void>;
    abstract list(namespace: Namespace): Promise<StoreItem[]>;
    abstract search<T = unknown>(namespace: Namespace, query: string, opts?: {
        limit?: number;
        filter?: Record<string, unknown>;
    }): Promise<SearchResult<T>[]>;
    abstract listNamespaces(opts?: {
        prefix?: Namespace;
        maxDepth?: number;
    }): Promise<Namespace[]>;
    /** Namespaced helper — returns a scoped accessor */
    namespace(ns: Namespace): NamespacedStore;
}
export declare class InMemoryStore extends BaseStore {
    private data;
    private readonly embedFn?;
    private vectors;
    private readonly maxItems;
    constructor(opts?: {
        embedFn?: EmbedFn;
        maxItems?: number;
    });
    private key;
    private isExpired;
    get<T = unknown>(namespace: Namespace, key: StoreKey): Promise<StoreItem<T> | null>;
    put<T = unknown>(namespace: Namespace, key: StoreKey, value: T, opts?: {
        ttl?: number;
    }): Promise<void>;
    delete(namespace: Namespace, key: StoreKey): Promise<void>;
    list(namespace: Namespace): Promise<StoreItem[]>;
    search<T = unknown>(namespace: Namespace, query: string, opts?: {
        limit?: number;
        filter?: Record<string, unknown>;
    }): Promise<SearchResult<T>[]>;
    listNamespaces(opts?: {
        prefix?: Namespace;
        maxDepth?: number;
    }): Promise<Namespace[]>;
    /** Alias for put() — common Map-like convention */
    set<T = unknown>(namespace: Namespace, key: StoreKey, value: T, opts?: {
        ttl?: number;
    }): Promise<void>;
    /** Number of non-expired items — also purges expired entries from memory */
    size(): number;
    clear(): void;
    private evictExpired;
}
export declare class NamespacedStore {
    private readonly store;
    private readonly ns;
    constructor(store: BaseStore, ns: Namespace);
    get<T>(key: StoreKey): Promise<StoreItem<T> | null>;
    put<T>(key: StoreKey, value: T, opts?: {
        ttl?: number;
    }): Promise<void>;
    delete(key: StoreKey): Promise<void>;
    list(): Promise<StoreItem[]>;
    search<T>(query: string, opts?: {
        limit?: number;
        filter?: Record<string, unknown>;
    }): Promise<SearchResult<T>[]>;
    listNamespaces(opts?: {
        prefix?: Namespace;
        maxDepth?: number;
    }): Promise<Namespace[]>;
    /** Alias for put() — common Map-like convention */
    set<T>(key: StoreKey, value: T, opts?: {
        ttl?: number;
    }): Promise<void>;
    /** Sub-namespace: users.namespace(["cj"]) → users/cj scope */
    namespace(sub: Namespace): NamespacedStore;
}
export declare class AgentMemoryStore {
    private store;
    constructor(baseStore: BaseStore, agentId: string);
    remember(key: string, value: unknown, ttl?: number): Promise<void>;
    recall<T = unknown>(key: string): Promise<T | null>;
    forget(key: string): Promise<void>;
    recallAll(): Promise<StoreItem[]>;
    search<T = unknown>(query: string, limit?: number): Promise<T[]>;
}
//# sourceMappingURL=index.d.ts.map