/// <reference types="node" />
import { UnwrapPromise } from '../../utils/types';
import { IDatabaseTransaction } from './transaction';
import { DatabaseIteratorOptions, DatabaseKeyRange, DatabaseSchema, IDatabaseEncoding, SchemaKey, SchemaValue } from './types';
export type IDatabaseStoreOptions<Schema extends DatabaseSchema> = {
    /** The unique name of the store inside of the database */
    name: string;
    /** The encoding used to encode and decode keys in the database */
    keyEncoding: IDatabaseEncoding<SchemaKey<Schema>>;
    /** The encoding used to encode and decode values in the database */
    valueEncoding: IDatabaseEncoding<SchemaValue<Schema>>;
};
/**
 * A collection of keys with associated values that exist within a {@link IDatabase}
 * you can have many of these inside of a database. All the values inside the store
 * have a consistent type specified by the <Schema> generic parameter.
 *
 * Use [[`IDatabase.addStore`]] before you open the database to create an [[`IDatabaseStore`]]
 *
 * You can operate on one or more stores atomically using {@link IDatabase.transaction}
 */
export interface IDatabaseStore<Schema extends DatabaseSchema> {
    /** The unique name of the store inside of the database */
    name: string;
    /** The [[`IDatabaseEncoding`]] used to serialize keys to store in the database */
    keyEncoding: IDatabaseEncoding<SchemaKey<Schema>>;
    /** The [[`IDatabaseEncoding`]] used to serialize values to store in the database */
    valueEncoding: IDatabaseEncoding<SchemaValue<Schema>>;
    encode(key: Readonly<SchemaKey<Schema>>): [Buffer];
    /**
     * Used to serialize the key and value for the database
     *
     * @returns An array with the serialized key and value as Buffers
     */
    encode(key: Readonly<SchemaKey<Schema>>, value: SchemaValue<Schema>): [Buffer, Buffer];
    getAll(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): Promise<Array<[SchemaKey<Schema>, SchemaValue<Schema>]>>;
    getAllIter(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): AsyncGenerator<[SchemaKey<Schema>, SchemaValue<Schema>]>;
    getAllValuesIter(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): AsyncGenerator<SchemaValue<Schema>>;
    getAllValues(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): Promise<Array<SchemaValue<Schema>>>;
    getAllKeysIter(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): AsyncGenerator<SchemaKey<Schema>>;
    getAllKeys(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): Promise<Array<SchemaKey<Schema>>>;
    /**
     * Delete every key in the {@link IDatastore}
     *
     * @returns resolves when all keys have been deleted
     */
    clear(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange): Promise<void>;
    /**
     * Used to get a value from the store at a given key
  
    * @param key - The key to fetch
    * @param transaction - If provided, the operation will use the transaction.
    *
    * @returns resolves with the value if found, or undefined if not found.
    */
    get(key: Readonly<SchemaKey<Schema>>, transaction?: IDatabaseTransaction): Promise<SchemaValue<Schema> | undefined>;
    /**
     * Used to check if the database has a given key
  
    * @param key - The key to check
    * @param transaction - If provided, the operation will use the transaction.
    *
    * @returns resolves with true if the key is in the database, or false if it is missing.
    */
    has(key: Readonly<SchemaKey<Schema>>, transaction?: IDatabaseTransaction): Promise<boolean>;
    /**
     * Put a value into the store with the given key.
  
    * @param key - The key to insert
    * @param value - The value to insert
    * @param transaction - If provided, the operation will be executed atomically when the transaction is {@link IDatabaseTransaction.commit | committed}.
    *
    * @returns A promise that resolves when the operation has been either executed, or added to the transaction.
    */
    put(key: Readonly<SchemaKey<Schema>>, value: SchemaValue<Schema>, transaction?: IDatabaseTransaction): Promise<void>;
    /**
     * Add a value to the database with the given key.
     *
     * If the key already exists, an {@link DuplicateKeyError} will be thrown. If you do not want to throw an error on insert, use {@link IDatabaseStore.put}
  
    * @param key - The key to insert
    * @param value - The value to insert
    * @param transaction - If provided, the operation will be executed atomically when the transaction is {@link IDatabaseTransaction.commit | committed}.
    *
    * @returns A promise that resolves when the operation has been either executed, or added to the transaction.
    * @throws {@link DuplicateKeyError} if the key already exists in the transaction or database
    */
    add(key: Readonly<SchemaKey<Schema>>, value: SchemaValue<Schema>, transaction?: IDatabaseTransaction): Promise<void>;
    /**
     * Delete a value with the given key.
     *
     * @param key - The key stored in the database to delete
     * @param transaction - If provided, the operation will be executed atomically when the transaction is {@link IDatabaseTransaction.commit | committed}.
     *
     * @returns A promise that resolves when the operation has been either executed, or added to the transaction.
     */
    del(key: Readonly<SchemaKey<Schema>>, transaction?: IDatabaseTransaction): Promise<void>;
}
export declare abstract class DatabaseStore<Schema extends DatabaseSchema> implements IDatabaseStore<Schema> {
    name: string;
    keyEncoding: IDatabaseEncoding<SchemaKey<Schema>>;
    valueEncoding: IDatabaseEncoding<SchemaValue<Schema>>;
    constructor(options: IDatabaseStoreOptions<Schema>);
    abstract encode(key: Readonly<SchemaKey<Schema>>): [Buffer];
    abstract encode(key: Readonly<SchemaKey<Schema>>, value: SchemaValue<Schema>): [Buffer, Buffer];
    abstract get(key: Readonly<SchemaKey<Schema>>, transaction?: IDatabaseTransaction): Promise<SchemaValue<Schema> | undefined>;
    abstract getAllIter(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): AsyncGenerator<[SchemaKey<Schema>, SchemaValue<Schema>]>;
    abstract getAll(transaction?: IDatabaseTransaction, keyRange?: DatabaseKeyRange, iteratorOptions?: DatabaseIteratorOptions): Promise<Array<[SchemaKey<Schema>, SchemaValue<Schema>]>>;
    abstract getAllValuesIter(transaction?: IDatabaseTransaction): AsyncGenerator<SchemaValue<Schema>>;
    abstract getAllValues(transaction?: IDatabaseTransaction): Promise<Array<SchemaValue<Schema>>>;
    abstract getAllKeysIter(transaction?: IDatabaseTransaction): AsyncGenerator<SchemaKey<Schema>>;
    abstract getAllKeys(transaction?: IDatabaseTransaction): Promise<Array<SchemaKey<Schema>>>;
    abstract clear(): Promise<void>;
    abstract has(key: Readonly<SchemaKey<Schema>>, transaction?: IDatabaseTransaction): Promise<boolean>;
    abstract put(key: Readonly<SchemaKey<Schema>>, value: SchemaValue<Schema>, transaction?: IDatabaseTransaction): Promise<void>;
    abstract add(key: Readonly<SchemaKey<Schema>>, value: SchemaValue<Schema>, transaction?: IDatabaseTransaction): Promise<void>;
    abstract del(key: Readonly<SchemaKey<Schema>>, transaction?: IDatabaseTransaction): Promise<void>;
}
export type DatabaseStoreValue<TStore> = TStore extends IDatabaseStore<infer _A> ? Exclude<UnwrapPromise<ReturnType<TStore['get']>>, undefined> : never;
export type DatabaseStoreKey<TStore> = TStore extends IDatabaseStore<infer _A> ? Parameters<TStore['get']>[0] : never;
//# sourceMappingURL=store.d.ts.map