export declare type AwaitIterable<T> = Iterable<T> | AsyncIterable<T>;
export declare type Await<T> = Promise<T> | T;
export interface Pair<Key, Value> {
    key: Key;
    value: Value;
}
/**
 * Options for async operations.
 */
export interface Options {
    signal?: AbortSignal;
}
export interface Batch<Key, Value> {
    put: (key: Key, value: Value) => void;
    delete: (key: Key) => void;
    commit: (options?: Options) => Promise<void>;
}
export interface Store<Key, Value> {
    open: () => Promise<void>;
    close: () => Promise<void>;
    /**
     * Store the passed value under the passed key
     *
     * @example
     *
     * ```js
     * await store.put([{ key: new Key('awesome'), value: new Uint8Array([0, 1, 2, 3]) }])
     * ```
     */
    put: (key: Key, val: Value, options?: Options) => Promise<void>;
    /**
     * Retrieve the value stored under the given key
     *
     * @example
     * ```js
     * const value = await store.get(new Key('awesome'))
     * console.log('got content: %s', value.toString('utf8'))
     * // => got content: datastore
     * ```
     */
    get: (key: Key, options?: Options) => Promise<Value>;
    /**
     * Check for the existence of a value for the passed key
     *
     * @example
     * ```js
     *const exists = await store.has(new Key('awesome'))
     *
     *if (exists) {
     *  console.log('it is there')
     *} else {
     *  console.log('it is not there')
     *}
     *```
     */
    has: (key: Key, options?: Options) => Promise<boolean>;
    /**
     * Remove the record for the passed key
     *
     * @example
     *
     * ```js
     * await store.delete(new Key('awesome'))
     * console.log('deleted awesome content :(')
     * ```
     */
    delete: (key: Key, options?: Options) => Promise<void>;
    /**
     * Store the given key/value pairs
     *
     * @example
     * ```js
     * const source = [{ key: new Key('awesome'), value: new Uint8Array([0, 1, 2, 3]) }]
     *
     * for await (const { key, value } of store.putMany(source)) {
     *   console.info(`put content for key ${key}`)
     * }
     * ```
     */
    putMany: (source: AwaitIterable<Pair<Key, Value>>, options?: Options) => AsyncIterable<Pair<Key, Value>>;
    /**
     * Retrieve values for the passed keys
     *
     * @example
     * ```js
     * for await (const value of store.getMany([new Key('awesome')])) {
     *   console.log('got content:', new TextDecoder('utf8').decode(value))
     *   // => got content: datastore
     * }
     * ```
     */
    getMany: (source: AwaitIterable<Key>, options?: Options) => AsyncIterable<Value>;
    /**
     * Remove values for the passed keys
     *
     * @example
     *
     * ```js
     * const source = [new Key('awesome')]
     *
     * for await (const key of store.deleteMany(source)) {
     *   console.log(`deleted content with key ${key}`)
     * }
     * ```
     */
    deleteMany: (source: AwaitIterable<Key>, options?: Options) => AsyncIterable<Key>;
    /**
     * This will return an object with which you can chain multiple operations together, with them only being executed on calling `commit`.
     *
     * @example
     * ```js
     * const b = store.batch()
     *
     * for (let i = 0; i < 100; i++) {
     *   b.put(new Key(`hello${i}`), new TextEncoder('utf8').encode(`hello world ${i}`))
     * }
     *
     * await b.commit()
     * console.log('put 100 values')
     * ```
     */
    batch: () => Batch<Key, Value>;
    /**
     * Query the store.
     *
     * @example
     * ```js
     * // retrieve __all__ key/value pairs from the store
     * let list = []
     * for await (const { key, value } of store.query({})) {
     *   list.push(value)
     * }
     * console.log('ALL THE VALUES', list)
     * ```
     */
    query: (query: Query<Key, Value>, options?: Options) => AsyncIterable<Pair<Key, Value>>;
    /**
     * Query the store.
     *
     * @example
     * ```js
     * // retrieve __all__ keys from the store
     * let list = []
     * for await (const key of store.queryKeys({})) {
     *   list.push(key)
     * }
     * console.log('ALL THE KEYS', key)
     * ```
     */
    queryKeys: (query: KeyQuery<Key>, options?: Options) => AsyncIterable<Key>;
}
export interface QueryFilter<Key, Value> {
    (item: Pair<Key, Value>): boolean;
}
export interface QueryOrder<Key, Value> {
    (a: Pair<Key, Value>, b: Pair<Key, Value>): -1 | 0 | 1;
}
export interface Query<Key, Value> {
    prefix?: string;
    filters?: Array<QueryFilter<Key, Value>>;
    orders?: Array<QueryOrder<Key, Value>>;
    limit?: number;
    offset?: number;
}
export interface KeyQueryFilter<Key> {
    (item: Key): boolean;
}
export interface KeyQueryOrder<Key> {
    (a: Key, b: Key): -1 | 0 | 1;
}
export interface KeyQuery<Key> {
    prefix?: string;
    filters?: Array<KeyQueryFilter<Key>>;
    orders?: Array<KeyQueryOrder<Key>>;
    limit?: number;
    offset?: number;
}
//# sourceMappingURL=index.d.ts.map