import { Encrypter, EventEmitter } from '../utils';
export type StorageOpts = {
    syncInMemory?: boolean;
    encryption?: Encrypter;
};
export type StoreEvents = {
    set: {
        key: string;
        value: any;
    };
    delete: {
        key: string;
    };
    clear: undefined;
};
export declare abstract class BaseStorage {
    abstract listStores(): Promise<Array<string>>;
    abstract createStore(storeName: string, opts: StorageOpts): Promise<BaseStore>;
    abstract getStore(storeName: string, opts: StorageOpts): Promise<BaseStore | null>;
    abstract createOrGetStore(storeName: string, opts: StorageOpts): Promise<BaseStore>;
    abstract deleteStore(storeName: string): Promise<void>;
    abstract deleteDatabase(): Promise<void>;
}
/**
 * Represents a wrapper object for accessing and manipulating a stored value.
 */
export type StoreValueProxy<T> = {
    /**
     * Gets the current value from the store
     */
    get(): Promise<T | undefined>;
    /**
     * Gets the current value from the store or fails if undefined.
     */
    getOrFail(): Promise<T>;
    /**
     * Sets a new value in the store
     * @param newValue The value to store
     */
    set(newValue: T): Promise<void>;
};
/**
 * Abstract base class for implementing key-value storage with event emission capabilities.
 * Extends EventEmitter to provide event handling for store operations.
 *
 * @example
 * ```typescript
 * class MyStore extends BaseStore {
 *   async keys(): Promise<Array<string>> {
 *     // Implementation
 *   }
 *
 *   async get<T>(key: string): Promise<T | undefined> {
 *     // Implementation
 *   }
 *
 *   async set<T>(key: string, value: T): Promise<void> {
 *     // Implementation
 *   }
 *
 *   async delete(key: string): Promise<void> {
 *     // Implementation
 *   }
 * }
 * ```
 */
export declare abstract class BaseStore extends EventEmitter<StoreEvents> {
    /**
     * Returns an array of all keys in the store.
     */
    abstract keys(): Promise<Array<string>>;
    /**
     * Retrieves a value from the store by its key.
     *
     * @template T The type of the value to retrieve
     * @param key The key to lookup
     */
    abstract get<T>(key: string): Promise<T | undefined>;
    /**
     * Stores a value in the store with the specified key.
     *
     * @template T The type of the value to store
     * @param key The key under which to store the value
     * @param value The value to store
     */
    abstract set<T>(key: string, value: T): Promise<void>;
    /**
     * Removes a value from the store by its key.
     *
     * @param key The key to remove
     */
    abstract delete(key: string): Promise<void>;
    /**
     * Retrieves all key-value pairs from the store.
     *
     * @template T The type of the values in the store
     */
    all<T>(): Promise<{
        [key: string]: T;
    }>;
    /**
     * Removes all key-value pairs from the store.
     */
    clear(): Promise<void>;
    /**
     * Checks if a key exists in the store.
     *
     * @param key The key to check
     */
    has(key: string): Promise<boolean>;
    /**
     * Retrieves multiple values from the store by their keys.
     * Filters out undefined values from the results.
     *
     * @template T The type of the values to retrieve
     * @param keys Array of keys to retrieve
     */
    batchGet<T>(keys: Array<string>): Promise<Map<string, T>>;
    /**
     * Stores multiple key-value pairs in the store.
     * Emits 'set' events for each key-value pair.
     *
     * @template T The type of the values to store
     * @param items Map of key-value pairs to store
     */
    batchSet<T>(items: Map<string, T>): Promise<void>;
    /**
     * Closes the store connection. Override this method in implementing classes if needed.
     */
    close(): Promise<void>;
    /**
     * Retrieves a value from the store by its key, throwing an error if the value doesn't exist.
     *
     * @template T The type of the value to retrieve
     * @param key The key to lookup
     */
    getOrFail<T>(key: string): Promise<T>;
    /**
     * Retrieves a value from the store by its key, or sets it using the provided setter function if it doesn't exist.
     *
     * @template T The type of the value to retrieve or set
     * @param key The key to lookup
     * @param setter Function to generate the value if it doesn't exist
     */
    getOrSet<T>(key: string, setter: () => T | Promise<T>): Promise<T>;
    /**
     * Creates a wrapper object that provides convenient access to a stored value.
     * The wrapper allows getting and setting the value using async property access.
     *
     * @template T The type of the value to wrap
     * @param key The key under which the value is stored
     * @returns An object with a getter and setter for the stored value
     *
     * @example
     * ```typescript
     * const numValue = store.proxy<number>('myNumber');
     * const value = await numValue.get(); // gets the stored value
     * await numValue.set(42); // sets the stored value
     * ```
     */
    proxy<T>(key: string): StoreValueProxy<T>;
}