/** @public */
export declare abstract class Data {
    [key: string]: any;
    static assign(vo: Data, values: ValuesObject): Data;
    set(key: string, value: any): void;
    fromObject(object: ValuesObject): void;
    toObject(exclude?: string[]): Record<string, any>;
    abstract uniqKey(): string;
}

/** @public */
export declare abstract class Entity<T extends Data> {
    abstract _getRepo(storage: Storage_2): Repo<Entity<T>>;
    abstract _getVO(): T;
    protected _data: T;
    private __id;
    get data(): T;
    get _id(): string;
    set _id(value: string);
    constructor(data?: T);
    getUniqKey(): any;
    isPersisted(): boolean;
    toString(): any;
}

/** @public */
export declare type EntityConstructor<T extends Data> = new (data?: T) => Entity<T>;

/** @public */
export declare class EntityManager {
    private readonly _storage;
    private _saveMap;
    private _removeMap;
    constructor(storage: Storage_2);
    persist(entity: Entity<any>): this;
    persistMany(entities: Entity<any>[]): this;
    remove(entity: Entity<any>): this;
    forget(): this;
    flush(): Promise<this>;
    refresh(entity: Entity<any>): Promise<Entity<any>>;
}

/** @public */
export declare class ErrEntityHasNoUniqKeyValue extends Error {
}

/** @public */
export declare class ErrEntityNotFound extends Error {
}

/** @public */
export declare class ErrFoundNotUniqEntity extends Error {
}

/** @public */
export declare class ErrNoSession extends ErrStorage {
}

/** @public */
export declare class ErrStorage extends Error {
}

/** @public */
export declare abstract class Repo<T extends Entity<any>> {
    protected _storage: Storage_2;
    protected _entity: T;
    protected _limit: number;
    protected _offset: number;
    /**
     * Возвращает объект соотв. сущности, например new App()
     */
    abstract Entity(): T;
    /**
     * Возвращает название коллекции/таблицы/... хранящей записи соотв. сущностей
     */
    abstract Name(): string;
    _transformer: (object: any) => any;
    constructor(storage: Storage_2);
    resetTransformer(): void;
    get storage(): Storage_2;
    save(entity: T): Promise<this>;
    findById(id: string): Promise<T | null>;
    /**
     *
     * @protected
     */
    _findByParams(parameters: Record<string, any>, limit?: number, order?: Record<string, any>): Promise<T[]>;
    findMany(parameters: Record<string, any>, order?: Record<string, any>): Promise<T[]>;
    shift(limit?: number, offset?: number): this;
    count(query?: Record<string, any>): Promise<number>;
    remove(entity: T, silent?: boolean): Promise<this>;
}

/** @public */
declare abstract class Storage_2 {
    protected _dsn: string;
    constructor(dsn: string);
    abstract find(name: string, query: Record<string, any>): Promise<StorageCursor>;
    abstract save(name: string, uniqKey: string, data: Record<string, any>): Promise<string>;
    abstract createSession(): StorageSession;
    abstract count(name: string, query?: Record<string, any>): Promise<number>;
    abstract remove(collectionName: string, uniqKeyName: string, uniqKey: string): Promise<boolean>;
}
export { Storage_2 as Storage }

/** @public */
export declare interface StorageCursor {
    limit(number_: number): StorageCursor;
    sort(parameters: Record<string, any>): StorageCursor;
    skip(offset: number): StorageCursor;
    toArray(): Promise<any[]>;
}

/** @public */
export declare abstract class StorageSession {
    abstract start(options?: Record<string, any>): Promise<void>;
    abstract commit(fn: () => any, options?: Record<string, any>): Promise<void>;
}

/** @public */
export declare type ValuesObject = Record<string, any>;

export { }