import { DatabaseAdapter } from "../database";
import type { Agent, Component, Entity, Log, LogBody, Memory, MemoryMetadata, PairingAllowlistEntry, PairingChannel, PairingRequest, Participant, Relationship, Room, Task, UUID, World } from "../types";
/**
 * In-memory database adapter intended for:
 * - Benchmarks
 * - Tests
 * - Serverless / ephemeral runs
 *
 * It implements the full `IDatabaseAdapter` surface with safe no-op defaults.
 * Persistence is process-local.
 */
export declare class InMemoryDatabaseAdapter extends DatabaseAdapter<Record<string, never>> {
    db: Record<string, never>;
    private ready;
    private agents;
    private entities;
    private rooms;
    private worlds;
    private tasks;
    private logs;
    private memoriesById;
    private memoriesByRoom;
    private cache;
    private participantsByRoom;
    private roomsByParticipant;
    private participantUserState;
    private pairingRequests;
    private pairingAllowlist;
    initialize(_config?: Record<string, string | number | boolean | null>): Promise<void>;
    init(): Promise<void>;
    runPluginMigrations(): Promise<void>;
    runMigrations(): Promise<void>;
    isReady(): Promise<boolean>;
    close(): Promise<void>;
    getConnection(): Promise<Record<string, never>>;
    getAgent(agentId: UUID): Promise<Agent | null>;
    getAgents(): Promise<Partial<Agent>[]>;
    createAgent(agent: Partial<Agent>): Promise<boolean>;
    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
    deleteAgent(agentId: UUID): Promise<boolean>;
    ensureEmbeddingDimension(_dimension: number): Promise<void>;
    getEntitiesByIds(entityIds: UUID[]): Promise<Entity[] | null>;
    getEntitiesForRoom(_roomId: UUID): Promise<Entity[]>;
    createEntities(entities: Entity[]): Promise<boolean>;
    updateEntity(entity: Entity): Promise<void>;
    getComponent(_entityId: UUID, _type: string, _worldId?: UUID, _sourceEntityId?: UUID): Promise<Component | null>;
    getComponents(_entityId: UUID, _worldId?: UUID, _sourceEntityId?: UUID): Promise<Component[]>;
    createComponent(_component: Component): Promise<boolean>;
    updateComponent(_component: Component): Promise<void>;
    deleteComponent(_componentId: UUID): Promise<void>;
    getMemories(params: {
        entityId?: UUID;
        agentId?: UUID;
        count?: number;
        offset?: number;
        unique?: boolean;
        tableName: string;
        start?: number;
        end?: number;
        roomId?: UUID;
        worldId?: UUID;
    }): Promise<Memory[]>;
    getMemoryById(id: UUID): Promise<Memory | null>;
    getMemoriesByIds(ids: UUID[]): Promise<Memory[]>;
    getMemoriesByRoomIds(params: {
        tableName: string;
        roomIds: UUID[];
        limit?: number;
    }): Promise<Memory[]>;
    getCachedEmbeddings(): Promise<{
        embedding: number[];
        levenshtein_score: number;
    }[]>;
    log(params: {
        body: LogBody;
        entityId: UUID;
        roomId: UUID;
        type: string;
    }): Promise<void>;
    getLogs(): Promise<Log[]>;
    deleteLog(logId: UUID): Promise<void>;
    searchMemories(): Promise<Memory[]>;
    createMemory(memory: Memory, tableName: string): Promise<UUID>;
    updateMemory(memory: Partial<Memory> & {
        id: UUID;
        metadata?: MemoryMetadata;
    }): Promise<boolean>;
    deleteMemory(memoryId: UUID): Promise<void>;
    deleteManyMemories(memoryIds: UUID[]): Promise<void>;
    deleteAllMemories(roomId: UUID): Promise<void>;
    countMemories(roomId: UUID): Promise<number>;
    createWorld(world: World): Promise<UUID>;
    getWorld(id: UUID): Promise<World | null>;
    removeWorld(id: UUID): Promise<void>;
    getAllWorlds(): Promise<World[]>;
    updateWorld(world: World): Promise<void>;
    createRoom(room: Room): Promise<UUID>;
    getRoom(id: UUID): Promise<Room | null>;
    deleteRoom(id: UUID): Promise<void>;
    updateRoom(room: Room): Promise<void>;
    getRoomsByIds(roomIds: UUID[]): Promise<Room[] | null>;
    createRooms(rooms: Room[]): Promise<UUID[]>;
    getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
    getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
    getRoomsByWorld(worldId: UUID): Promise<Room[]>;
    getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
    getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
    addParticipantsRoom(entityIds: UUID[], roomId: UUID): Promise<boolean>;
    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
    isRoomParticipant(roomId: UUID, entityId: UUID): Promise<boolean>;
    getParticipantUserState(roomId: UUID, entityId: UUID): Promise<"FOLLOWED" | "MUTED" | null>;
    setParticipantUserState(roomId: UUID, entityId: UUID, state: "FOLLOWED" | "MUTED" | null): Promise<void>;
    createRelationship(): Promise<boolean>;
    updateRelationship(): Promise<void>;
    getRelationship(): Promise<Relationship | null>;
    getRelationships(): Promise<Relationship[]>;
    getCache<T>(key: string): Promise<T | undefined>;
    setCache<T>(key: string, value: T): Promise<boolean>;
    deleteCache(key: string): Promise<boolean>;
    createTask(task: Task): Promise<UUID>;
    getTasks(params: {
        roomId?: UUID;
        tags?: string[];
        entityId?: UUID;
    }): Promise<Task[]>;
    getTask(taskId: UUID): Promise<Task | null>;
    getTasksByName(name: string): Promise<Task[]>;
    updateTask(taskId: UUID, task: Partial<Task>): Promise<void>;
    deleteTask(taskId: UUID): Promise<void>;
    getMemoriesByWorldId(params: {
        worldId: UUID;
        count?: number;
        tableName?: string;
    }): Promise<Memory[]>;
    deleteRoomsByWorldId(worldId: UUID): Promise<void>;
    getPairingRequests(channel: PairingChannel, agentId: UUID): Promise<PairingRequest[]>;
    createPairingRequest(request: PairingRequest): Promise<UUID>;
    updatePairingRequest(request: PairingRequest): Promise<void>;
    deletePairingRequest(id: UUID): Promise<void>;
    getPairingAllowlist(channel: PairingChannel, agentId: UUID): Promise<PairingAllowlistEntry[]>;
    createPairingAllowlistEntry(entry: PairingAllowlistEntry): Promise<UUID>;
    deletePairingAllowlistEntry(id: UUID): Promise<void>;
}
//# sourceMappingURL=inMemoryAdapter.d.ts.map