/**
 * Prisma-backed memory store (PostgreSQL).
 * Import from '@hazeljs/memory/prisma' when you want DB persistence with Prisma.
 */
/** Minimal Prisma client shape for memory (avoids importing generated client in this file). */
export interface MemoryPrismaClient {
    memoryItem: {
        upsert(args: {
            where: {
                id: string;
            };
            create: object;
            update: object;
        }): Promise<unknown>;
        findUnique(args: {
            where: {
                id: string;
            };
        }): Promise<unknown>;
        findMany(args: {
            where?: object;
            orderBy?: object;
            take?: number;
            skip?: number;
        }): Promise<unknown[]>;
        update(args: {
            where: {
                id: string;
            };
            data: object;
        }): Promise<unknown>;
        delete(args: {
            where: {
                id: string;
            };
        }): Promise<unknown>;
        deleteMany(args: {
            where: object;
        }): Promise<{
            count: number;
        }>;
        groupBy(args: {
            by: string[];
            where?: object;
            _count?: object;
        }): Promise<unknown[]>;
        aggregate(args: {
            where?: object;
            _min?: object;
            _max?: object;
        }): Promise<{
            _min: {
                updatedAt: Date | null;
            };
            _max: {
                updatedAt: Date | null;
            };
        }>;
    };
    $connect(): Promise<void>;
    $disconnect(): Promise<void>;
}
import { MemoryItem } from '../../types/memory-item.types';
import { MemoryQuery, MemoryStats, PruneOptions } from '../../types/store.types';
import { MemoryStore } from '../memory-store.interface';
export interface PrismaMemoryStoreOptions {
    /** Prisma client (with memory schema applied). */
    prisma: MemoryPrismaClient;
}
/**
 * PostgreSQL-backed memory store using Prisma (same pattern as @hazeljs/flow).
 * Run migrations with: pnpm prisma migrate dev (from packages/memory).
 */
export declare class PrismaMemoryStore implements MemoryStore {
    private readonly prisma;
    constructor(prisma: MemoryPrismaClient);
    initialize(): Promise<void>;
    save(item: MemoryItem): Promise<string>;
    saveBatch(items: MemoryItem[]): Promise<string[]>;
    get(id: string): Promise<MemoryItem | null>;
    update(id: string, updates: Partial<MemoryItem>): Promise<void>;
    delete(id: string): Promise<void>;
    deleteBatch(ids: string[]): Promise<void>;
    query(options: MemoryQuery): Promise<MemoryItem[]>;
    getStats(userId?: string): Promise<MemoryStats>;
    prune(options?: PruneOptions): Promise<number>;
}
//# sourceMappingURL=prisma.store.d.ts.map