/**
 * @module common
 */
/** End Typedoc Module Declaration */
import { identifier, ModelStatic, AbstractModel } from '../models/model';
import { Injector } from '@angular/core';
import { Collection } from '../models/collection';
import { ValidatorOptions, Validator } from '../validation';
export interface Query {
}
/**
 * The abstract store should be the root calls for *all* stores, it provides common methods
 * for entity validation and storage.
 */
export declare abstract class AbstractStore<T extends AbstractModel> {
    protected modelStatic: ModelStatic<T>;
    protected injector: Injector;
    /**
     * class-validator Validator instance
     * @see https://github.com/pleerock/class-validator
     */
    protected validator: Validator;
    constructor(modelStatic: ModelStatic<T>, injector: Injector);
    /**
     * Promise that store is initialized.
     * Override this function for stores that have async initialization like Database stores that
     * require a connection etc.
     * @returns {Promise<AbstractStore>}
     */
    initialized(): Promise<this>;
    /**
     * Find one instance by id
     * @param id
     * @returns {Promise<T>}
     */
    abstract findOne(id: identifier): Promise<T>;
    /**
     * Save the model. Depending on the implementation, this may be a partial save when the model
     * is known to exist in the store destination and only an update is needed
     * @param model
     * @returns {Promise<T>}
     */
    abstract saveOne(model: T): Promise<T>;
    /**
     * Check if a model exists in the database
     * @param model
     */
    abstract hasOne(model: T): Promise<boolean>;
    /**
     * Delete the model from the store.
     * @param model
     */
    abstract deleteOne(model: T): Promise<T>;
    /**
     * Find multiple entities using a query for constraints
     * @param query
     * @returns {Promise<Collection<T>>}
     */
    abstract findMany(query?: Query): Promise<Collection<T>>;
    /**
     * Check the entity passed is valid, if not throw ValidationException with the errors
     * @param model
     * @param validatorOptions
     * @returns {Promise<T>}
     */
    validate(model: T, validatorOptions?: ValidatorOptions): Promise<T> | never;
    /**
     * Build the entity from data
     * @param modelData
     * @returns {Promise<T>}
     */
    hydrate(modelData: any): Promise<T>;
}