type Query = Record<string, unknown>;
/**
 * A minimal document store interface. Any datastore implementing this shape
 * can be used to back a {@link BridgeStore}.
 */
export interface Datastore {
    insert(newDocs: any[]): Promise<any[]>;
    update(query: any, updateQuery: any, options?: UpdateOptions): Promise<number>;
    remove(query: any, options: RemoveOptions): Promise<number>;
    findOne(query: any): Promise<any>;
    find(query: any): Promise<any[]>;
    ensureIndex(options: EnsureIndexOptions): Promise<void>;
}
export interface UpdateOptions {
    multi?: boolean;
    upsert?: boolean;
}
export interface RemoveOptions {
    multi?: boolean;
}
export interface EnsureIndexOptions {
    fieldName: string;
    unique?: boolean;
    sparse?: boolean;
}
/**
 * Base class for bridge stores.
 */
export declare class BridgeStore {
    readonly db: Datastore;
    constructor(db: Datastore);
    /**
     * INSERT a multiple documents.
     */
    insert(objects: unknown): Promise<any[]>;
    /**
     * UPSERT a single document
     */
    upsert<T>(query: Query, updateVals: T): Promise<number>;
    /**
     * INSERT IF NOT EXISTS a single document
     */
    insertIfNotExists(query: Query, insertObj: Record<string, unknown>): Promise<void>;
    /**
     * UPDATE a single document. If the document already exists, this will NOT update
     * it.
     */
    update(query: Query, updateVals: Record<string, unknown>): Promise<number>;
    /**
     * DELETE multiple documents.
     */
    delete(query: Query): Promise<number>;
    /**
     * SELECT a single document.
     */
    selectOne<T, O>(query: Query, transformFn?: (input: T) => O): Promise<O | null>;
    /**
     * SELECT a number of documents.
     * @param query
     * @param transformFn
     * @param defer
     */
    select<T, O>(query: Query, transformFn?: (input: T) => O): Promise<O[]>;
    /**
     * Set a UNIQUE key constraint on the given field.
     * @param fieldName The field name. Use dot notation for nested objects.
     * @param sparse Allow sparse entries (undefined won't cause a key
     * violation).
     */
    setUnique(fieldName: string, sparse?: boolean): Promise<void>;
    /**
     * Convenience method to convert a document to something.
     * @param func The function which will be called with a single document
     * object. Guaranteed not to be null.
     * @return A `transformFn` function to pass to the standard
     * select/delete/upsert/etc methods.
     */
    convertTo<T, O>(func: (input: T) => O): (doc: T) => O;
}
export {};