import "../Extensions/ArrayItemTypeExtension";
import { IObjectType, GenericType, DbType, IsolationLevel, DeleteMode, FlatObjectLike } from "../Common/Type";
import { DbSet } from "./DbSet";
import { IQueryResultParser } from "../Query/IQueryResultParser";
import { IQueryCacheManager } from "../Cache/IQueryCacheManager";
import { IQueryResult } from "../Query/IQueryResult";
import { IDBEventListener } from "./Event/IDBEventListener";
import { IDriver } from "../Connection/IDriver";
import { IQuery } from "../Query/IQuery";
import { EntityEntry } from "./EntityEntry";
import { DeferredQuery } from "../Query/DeferredQuery";
import { RelationEntry } from "./RelationEntry";
import { IRelationMetaData } from "../MetaData/Interface/IRelationMetaData";
import { EmbeddedEntityEntry } from "./EmbeddedEntityEntry";
import { IConnectionManager } from "../Connection/IConnectionManager";
import { IConnection } from "../Connection/IConnection";
import { IEntityMetaData } from "../MetaData/Interface/IEntityMetaData";
import { IDeleteEventParam } from "../MetaData/Interface/IDeleteEventParam";
import { ISaveEventParam } from "../MetaData/Interface/ISaveEventParam";
import { IQueryExpression } from "../Queryable/QueryExpression/IQueryExpression";
import { NamingStrategy } from "../Query/NamingStrategy";
import { QueryTranslator } from "../Query/QueryTranslator";
import { IResultCacheManager } from "../Cache/IResultCacheManager";
import { IQueryBuilder } from "../Query/IQueryBuilder";
import { ISchemaBuilder } from "../Query/ISchemaBuilder";
import { IQueryVisitor } from "../Query/IQueryVisitor";
import { IQueryOption } from "../Query/IQueryOption";
import { IEnumerable } from "../Enumerable/IEnumerable";
export declare type IChangeEntryMap<T extends string, TKey, TValue> = {
    [K in T]: Map<TKey, TValue[]>;
};
export declare abstract class DbContext<T extends DbType = any> implements IDBEventListener<any> {
    abstract readonly entityTypes: Array<IObjectType<any>>;
    protected abstract readonly queryBuilderType: IObjectType<IQueryBuilder>;
    protected abstract readonly queryVisitorType: IObjectType<IQueryVisitor>;
    protected abstract readonly schemaBuilderType: IObjectType<ISchemaBuilder>;
    protected abstract readonly queryResultParserType: IObjectType<IQueryResultParser>;
    protected abstract readonly namingStrategy: NamingStrategy;
    protected abstract readonly translator: QueryTranslator;
    abstract readonly dbType: T;
    protected readonly queryCacheManagerFactory?: () => IQueryCacheManager;
    protected readonly resultCacheManagerFactory?: () => IResultCacheManager;
    readonly queryBuilder: IQueryBuilder;
    readonly queryVisitor: IQueryVisitor;
    getQueryResultParser(command: IQueryExpression, queryBuilder: IQueryBuilder): IQueryResultParser;
    deferredQueries: DeferredQuery[];
    private _queryCacheManager;
    readonly queryCacheManager: IQueryCacheManager;
    private _resultCacheManager;
    readonly resultCacheManager: IResultCacheManager;
    private _connectionManager;
    readonly connectionManager: IConnectionManager;
    connection?: IConnection;
    getConnection(writable?: boolean): Promise<IConnection>;
    closeConnection(con?: IConnection): Promise<void>;
    private _cachedDbSets;
    protected readonly factory: () => IConnectionManager | IDriver<T>;
    constructor(factory?: () => IConnectionManager | IDriver<T>);
    set<T>(type: IObjectType<T>, isClearCache?: boolean): DbSet<T>;
    entry<T>(entity: T): EntityEntry<T>;
    attach<T>(entity: T, all?: boolean): EntityEntry<T>;
    add<T>(entity: T): EntityEntry<T>;
    delete<T>(entity: T): EntityEntry<T>;
    update<T>(entity: T, originalValues?: FlatObjectLike<T>): EntityEntry<T>;
    entityEntries: IChangeEntryMap<"add" | "update" | "delete", IEntityMetaData, EntityEntry>;
    relationEntries: IChangeEntryMap<"add" | "delete", IRelationMetaData, RelationEntry>;
    modifiedEmbeddedEntries: Map<IEntityMetaData<any>, Array<EmbeddedEntityEntry>>;
    clear(): void;
    relationEntry(entry: EntityEntry, propertyName: string, childEntry: EntityEntry): RelationEntry<any, any, any>;
    executeQueries(...queries: IQuery[]): Promise<IQueryResult[]>;
    transaction(transactionBody: () => Promise<void>): Promise<void>;
    transaction(isolationLevel: IsolationLevel, transactionBody: () => Promise<void>): Promise<void>;
    executeDeferred(deferredQueries?: IEnumerable<DeferredQuery>): Promise<void>;
    syncSchema(): Promise<void>;
    getUpdateSchemaQueries(entityTypes: IObjectType[]): Promise<import("../Query/ISchemaQuery").ISchemaQuery>;
    deferredFromSql<T>(type: GenericType<T>, rawQuery: string, parameters?: {
        [key: string]: any;
    }): Promise<DeferredQuery<T[]>>;
    fromSql<T>(type: GenericType<T>, rawQuery: string, parameters?: {
        [key: string]: any;
    }): Promise<T[]>;
    beforeSave?: <T>(entity: T, param: ISaveEventParam) => boolean;
    beforeDelete?: <T>(entity: T, param: IDeleteEventParam) => boolean;
    afterLoad?: <T>(entity: T) => void;
    afterSave?: <T>(entity: T, param: ISaveEventParam) => void;
    afterDelete?: <T>(entity: T, param: IDeleteEventParam) => void;
    saveChanges(options?: IQueryOption): Promise<number>;
    protected getUpdateQueries<T>(entityMetaData: IEntityMetaData<T>, entries: IEnumerable<EntityEntry<T>>, visitor?: IQueryVisitor, option?: IQueryOption): DeferredQuery<IQueryResult>[];
    protected getDeleteQueries<T>(entityMeta: IEntityMetaData<T>, entries: IEnumerable<EntityEntry<T>>, visitor?: IQueryVisitor, deleteMode?: DeleteMode, option?: IQueryOption): DeferredQuery<IQueryResult>[];
    protected getInsertQueries<T>(entityMeta: IEntityMetaData<T>, entries: IEnumerable<EntityEntry<T>>, visitor?: IQueryVisitor, option?: IQueryOption): DeferredQuery<IQueryResult>[];
    protected getUpsertQueries<T>(entityMeta: IEntityMetaData<T>, entries: IEnumerable<EntityEntry<T>>, visitor?: IQueryVisitor, param?: IQueryOption): DeferredQuery<IQueryResult>[];
    protected getRelationAddQueries<T, T2, TData>(slaveRelationMetaData: IRelationMetaData<T, T2>, relationEntries: IEnumerable<RelationEntry<T, T2, TData>>, visitor?: IQueryVisitor, param?: IQueryOption): DeferredQuery<IQueryResult>[];
    protected getRelationDeleteQueries<T, T2, TData>(slaveRelationMetaData: IRelationMetaData<T, T2>, relationEntries: IEnumerable<RelationEntry<T, T2, TData>>, visitor?: IQueryVisitor, param?: IQueryOption): DeferredQuery<IQueryResult>[];
}