import { CompoundKey } from '@paradoxical-io/types';
import { KeyValueList, KeyValueTable } from '../keyTable';
import { KeyCount, KeyValueCounter } from '../keyValueCounter';
import { PartitionedKeys } from '../partitionedKeys';
import { PartitionedKeyValueTable } from '../partitionedKeyTable';
import { PartitionedKeyValueCounter } from '../partitionedKeyValueCounter';
/**
 * An in memory kv table that uses a map. Used for testing and stubbing
 */
export declare class InMemoryKvTable extends KeyValueTable {
    private readonly store;
    constructor();
    delete(id: string): Promise<void>;
    get<T>(id: string): Promise<T | undefined>;
    getBatch<T>(id: string[]): Promise<T[]>;
    listAll<K, V>(): Promise<KeyValueList<[K, V]> | undefined>;
    set<T>(id: string, data: T): Promise<void>;
}
export declare class InMemoryPartitionedKvTable extends PartitionedKeyValueTable {
    private kvTable;
    constructor();
    clear<P extends string>(partition: P): Promise<void>;
    delete<P extends string>(key: CompoundKey<P, unknown>): Promise<void>;
    exists<T, P extends string>(key: CompoundKey<P, T>): Promise<boolean>;
    get<T, P extends string>(key: CompoundKey<P, T>): Promise<T | undefined>;
    protected getRaw<T, P extends string>(key: CompoundKey<P, T>): Promise<{
        data: T;
        md5?: string;
    } | undefined>;
    listAll(partition: string): AsyncGenerator<Array<{
        key: string;
        value: string;
    }>>;
    set<T, P extends string>(key: CompoundKey<P, T>, data: T): Promise<void>;
    setIfNotExists<T, P extends string>(key: CompoundKey<P, T>, data: T): Promise<boolean>;
    protected setIfMd5Matches<T, P extends string>(key: CompoundKey<P, T>, data: T): Promise<boolean>;
    private key;
}
/**
 * An in memory key count table that uses a map. Used for testing and stubbing
 */
export declare class InMemoryPartitionedKeyCountTable extends PartitionedKeyValueCounter {
    private readonly store;
    constructor();
    delete<P extends string = string>(id: CompoundKey<P, number>): Promise<void>;
    get<P extends string>(id: CompoundKey<P, number>): Promise<number | undefined>;
    incr<P extends string = string>(id: CompoundKey<P, number>, by?: number): Promise<number>;
}
export declare class InMemoryPartitionedKeys extends PartitionedKeys {
    constructor();
}
/**
 * An in memory key count table that uses a map. Used for testing and stubbing
 */
export declare class InMemoryKeyCountTable extends KeyValueCounter {
    private readonly store;
    constructor();
    delete<K extends string = string>(id: K): Promise<void>;
    get<K extends string = string>(ids: K[]): Promise<Array<KeyCount<K>>>;
    incr<K extends string = string>(id: K, by?: number): Promise<number>;
}
//# sourceMappingURL=inMemoryKvTable.d.ts.map