import { Entity, ValueObject, Model } from './model';
import { Class, ObjectType, Options } from './common-types';
import { DataSource } from './datasource';
import { Filter, Where } from './query';
export interface Repository<T extends Model> {
}
/**
 * Basic CRUD operations for ValueObject and Entity. No ID is required.
 */
export interface CrudRepository<T extends (ValueObject | Entity)> extends Repository<T> {
    /**
     * Create a new record
     * @param dataObject
     * @param options
     * @promise resolves a T
     */
    create(dataObject: ObjectType<T>, options?: Options): Promise<T>;
    /**
     * Create all records
     * @param entities
     * @param options
     * @promise resolves an array of created records
     */
    createAll(entities: ObjectType<T>[], options?: Options): Promise<T[]>;
    /**
     * Find matching records
     * @param filter
     * @param options
     * @promise resolves an array retrieved matching records
     */
    find(filter?: Filter, options?: Options): Promise<T[]>;
    /**
     * Updating matching records with attributes from the data object
     * @param dataObject
     * @param where
     * @param options
     * @promise resolves the count of updated records
     */
    updateAll(dataObject: ObjectType<T>, where?: Where, options?: Options): Promise<number>;
    /**
     * Delete matching records
     * @param where
     * @param options
     * @promise resolves the count of deleted records
     */
    deleteAll(where?: Where, options?: Options): Promise<number>;
    /**
     * Count matching records
     * @param where
     * @param options
     * @promise resolves the count of matching records
     */
    count(where?: Where, options?: Options): Promise<number>;
}
/**
 * Base interface for a repository of entities
 */
export interface EntityRepository<T extends Entity, ID> extends Repository<T> {
}
/**
 * CRUD operations for a repository of entities
 */
export interface EntityCrudRepository<T extends Entity, ID> extends EntityRepository<T, ID>, CrudRepository<T> {
    /**
     * Save an entity. If no id is present, create a new entity
     * @param entity
     * @param options
     * @promise resolves the saved entity
     */
    save(entity: ObjectType<T>, options?: Options): Promise<T>;
    /**
     * Update an entity
     * @param entity
     * @param options
     * @promise resolves a boolean represents update succeeds(true)
     * or fails(false)
     */
    update(entity: ObjectType<T>, options?: Options): Promise<boolean>;
    /**
     * Delete an entity
     * @param entity
     * @param options
     * @promise resolves a boolean represents delete succeeds(true)
     * or fails(false)
     */
    delete(entity: ObjectType<T>, options?: Options): Promise<boolean>;
    /**
     * Find an entity by id
     * @param id
     * @param options
     * @promise resolves the returned entity
     */
    findById(id: ID, filter?: Filter, options?: Options): Promise<T>;
    /**
     * Update an entity by id with property/value pairs in the data object
     * @param data
     * @param id
     * @param options
     * @promise resolves a boolean represents update succeeds(true)
     * or fails(false)
     */
    updateById(id: ID, data: ObjectType<T>, options?: Options): Promise<boolean>;
    /**
     * Replace an entity by id
     * @param data
     * @param id
     * @param options
     * @promise resolves a boolean represents replace succeeds(true)
     * or fails(false)
     */
    replaceById(id: ID, data: ObjectType<T>, options?: Options): Promise<boolean>;
    /**
     * Delete an entity by id
     * @param id
     * @param options
     * @promise resolves a boolean represents delete succeeds(true)
     * or fails(false)
     */
    deleteById(id: ID, options?: Options): Promise<boolean>;
    /**
     * Check if an entity exists for the given id
     * @param id
     * @param options
     * @promise resolves a boolean represents entity exists(true)
     * or not(false)
     */
    exists(id: ID, options?: Options): Promise<boolean>;
}
/**
 * Repository implementation
 *
 * Example:
 *
 * User can import `CrudRepositoryImpl` and call its functions like:
 * `CrudRepositoryImpl.find(somefilters, someoptions)`
 *
 * Or extend class `CrudRepositoryImpl` and override its functions:
 * ```ts
 * export class TestRepository extends CrudRepositoryImpl<Test> {
 *   constructor(dataSource: DataSource, model: Test) {
 *     super(dataSource, Customer);
 *   }
 *
 *   // Override `deleteAll` to disable the operation
 *   deleteAll(where?: Where, options?: Options) {
 *     return Promise.reject(new Error('deleteAll is disabled'));
 *   }
 * }
 * ```
 */
export declare class CrudRepositoryImpl<T extends Entity, ID> implements EntityCrudRepository<T, ID> {
    dataSource: DataSource;
    model: Class<T>;
    private connector;
    constructor(dataSource: DataSource, model: Class<T>);
    create(entity: ObjectType<T>, options?: Options): Promise<T>;
    createAll(entities: ObjectType<T>[], options?: Options): Promise<T[]>;
    save(entity: ObjectType<T>, options?: Options): Promise<T>;
    find(filter?: Filter, options?: Options): Promise<T[]>;
    findById(id: ID, options?: Options): Promise<T>;
    update(entity: ObjectType<T>, options?: Options): Promise<boolean>;
    delete(entity: ObjectType<T>, options?: Options): Promise<boolean>;
    updateAll(data: ObjectType<T>, where?: Where, options?: Options): Promise<number>;
    updateById(id: ID, data: ObjectType<T>, options?: Options): Promise<boolean>;
    replaceById(id: ID, data: ObjectType<T>, options?: Options): Promise<boolean>;
    deleteAll(where?: Where, options?: Options): Promise<number>;
    deleteById(id: ID, options?: Options): Promise<boolean>;
    count(where?: Where, options?: Options): Promise<number>;
    exists(id: ID, options?: Options): Promise<boolean>;
}