import { DbContext } from "../../DbContext";
import { Type, UnwrappedType } from "@simplysm/sd-core-common";
import { IDeleteQueryDef, IInsertIfNotExistsQueryDef, IInsertQueryDef, IQueryTableNameDef, ISelectQueryDef, IUpdateQueryDef, IUpsertQueryDef, TQueryBuilderValue } from "../query-builder/types";
import { ITableDef, TQueryValue } from "../../types";
import { IQueryableDef, TEntity, TEntityUnwrap, TEntityValue, TEntityValueOrQueryableOrArray, TIncludeEntity, TInsertObject, TSelectEntity, TUpdateObject } from "./types";
export declare class Queryable<D extends DbContext, T> {
    readonly db: D;
    T?: T;
    tableType?: Type<T>;
    tableDef?: ITableDef;
    private readonly _as?;
    private readonly _entity;
    private _isCustomEntity;
    private readonly _def;
    constructor(db: D, cloneQueryable: Queryable<D, T>);
    constructor(db: D, cloneQueryable: Queryable<D, any>, entity: TEntity<T>);
    constructor(db: D, tableType: Type<T>, as?: string);
    constructor(db: D, tableType: Type<T> | undefined, as: string | undefined, entity: TEntity<T>, defs: IQueryableDef);
    get tableName(): string;
    get tableDescription(): string;
    get tableNameDef(): IQueryTableNameDef;
    static union<ND extends DbContext, NT>(qrs: Queryable<ND, NT>[], as?: string): Queryable<ND, NT>;
    lock(): Queryable<D, T>;
    select<A, B extends TEntityUnwrap<A>>(fwd: (entity: TEntity<T>) => A): Queryable<D, B>;
    select<R>(fwd: (entity: TEntity<T>) => TSelectEntity<R>): Queryable<D, R>;
    selectByType<A>(tableType: Type<A>): Queryable<D, A>;
    ofType<A>(): Queryable<D, A>;
    where(predicate: (entity: TEntity<T>) => TEntityValueOrQueryableOrArray<D, any>[]): Queryable<D, T>;
    distinct(): Queryable<D, T>;
    top(count: number): Queryable<D, T>;
    orderBy(arg1: ((entity: TEntity<T>) => TEntityValue<TQueryValue>) | string, desc?: boolean): Queryable<D, T>;
    clearOrderBy(): Queryable<D, T>;
    limit(skip: number, take: number): Queryable<D, T>;
    sample(rowCount: number): Queryable<D, T>;
    pivot<V extends TQueryValue, P extends string>(valueFwd: (entity: TEntity<T>) => TEntityValue<V>, valueDupFwd: (value: TEntityValue<V>) => TEntityValue<V>, emptyValue: V, pivotFwd: (entity: TEntity<T>) => TEntityValue<any>, pivotKeys: P[]): Queryable<D, T & Record<P, V>>;
    unpivot<VC extends string, PC extends string, RT extends TQueryValue>(valueColumn: VC, pivotColumn: PC, pivotKeys: string[], _resultType: Type<RT>): Queryable<D, T & Record<PC, string> & Record<VC, UnwrappedType<RT> | undefined>>;
    groupBy(fwd: (entity: TEntity<T>) => TEntityValue<TQueryValue>[]): Queryable<D, T>;
    having(predicate: (entity: TEntity<T>) => TEntityValueOrQueryableOrArray<D, any>[]): Queryable<D, T>;
    join<A extends string, J, R>(joinTypeOrQrs: Type<J> | Queryable<D, J>[], as: A, fwd: (qr: Queryable<D, J>, en: TEntity<T>) => Queryable<D, R>): Queryable<D, Omit<T, A> & {
        [K in A]: R[];
    }>;
    joinSingle<A extends string, J, R>(joinTypeOrQrs: Type<J> | Queryable<D, J>[], as: A, fwd: (qr: Queryable<D, J>, en: TEntity<T>) => Queryable<D, R>): Queryable<D, T & {
        [K in A]?: R;
    }>;
    includeByTableChainedName(tableChainedName: string): Queryable<D, T>;
    include(arg: (entity: TIncludeEntity<T>) => TIncludeEntity<any> | TIncludeEntity<any>[]): Queryable<D, T>;
    search(fwd: (entity: TEntity<T>) => TEntityValue<String | string | undefined>[], searchText: string): Queryable<D, T>;
    wrap(): Queryable<D, T>;
    wrap<R extends Partial<T>>(tableType: Type<R>): Queryable<D, R>;
    getSelectQueryDef(): ISelectQueryDef & {
        select: Record<string, TQueryBuilderValue>;
    };
    getInsertQueryDef(obj: TInsertObject<T>, outputColumns: (keyof T)[] | undefined): IInsertQueryDef;
    getUpdateQueryDef(obj: TUpdateObject<T>, outputColumns: (keyof T)[] | undefined): IUpdateQueryDef;
    getInsertIfNotExistsQueryDef(insertObj: TInsertObject<T>, outputColumns: (keyof T)[] | undefined): IInsertIfNotExistsQueryDef;
    getUpsertQueryDef<U extends TUpdateObject<T>>(updateObj: U, insertObj: TInsertObject<T> | undefined, outputColumns: (keyof T)[] | undefined, aiKeyName: string | undefined, pkColNames: string[]): IUpsertQueryDef;
    getDeleteQueryDef(outputColumns: (keyof T)[] | undefined): IDeleteQueryDef;
    insertIntoAsync(tableType: Type<T>, stopAutoIdentity?: boolean): Promise<void>;
    resultAsync(): Promise<T[]>;
    singleAsync(): Promise<T | undefined>;
    countAsync(): Promise<number>;
    countAsync(fwd: (entity: TEntity<T>) => TEntityValue<any>): Promise<number>;
    existsAsync(): Promise<boolean>;
    bulkInsertAsync(records: TInsertObject<T>[]): Promise<void>;
    bulkUpsertAsync(records: TInsertObject<T>[]): Promise<void>;
    insertAsync(records: TInsertObject<T>[]): Promise<void>;
    insertAsync<OK extends keyof T>(records: TInsertObject<T>[], outputColumns: OK[]): Promise<{
        [K in OK]: T[K];
    }[]>;
    insertWithoutFkCheckAsync(records: TInsertObject<T>[]): Promise<void>;
    insertWithoutFkCheckAsync<OK extends keyof T>(records: TInsertObject<T>[], outputColumns: OK[]): Promise<{
        [K in OK]: T[K];
    }[]>;
    insertPrepare(records: TInsertObject<T>[]): void;
    insertWithoutFkCheckPrepare(records: TInsertObject<T>[]): void;
    updateAsync(recordFwd: (entity: TEntity<T>) => TUpdateObject<T> | Promise<TUpdateObject<T>>): Promise<void>;
    updateAsync<OK extends keyof T>(recordFwd: (entity: TEntity<T>) => TUpdateObject<T> | Promise<TUpdateObject<T>>, outputColumns: OK[]): Promise<{
        [K in OK]: T[K];
    }[]>;
    updatePrepare(recordFwd: (entity: TEntity<T>) => TUpdateObject<T>): void;
    deleteAsync(): Promise<void>;
    deleteAsync<OK extends keyof T>(outputColumns: OK[]): Promise<{
        [K in OK]: T[K];
    }[]>;
    deletePrepare(): void;
    upsertAsync(inAndUpsertFwd: (entity: TEntity<T>) => TInsertObject<T> | Promise<TInsertObject<T>>): Promise<void>;
    upsertAsync<OK extends keyof T>(inAndUpsertFwd: (entity: TEntity<T>) => TInsertObject<T> | Promise<TInsertObject<T>>, outputColumns: OK[]): Promise<{
        [K in OK]: T[K];
    }[]>;
    upsertAsync<U extends TUpdateObject<T>>(updateFwd: (entity: TEntity<T>) => U | Promise<U>, insertFwd: (updateRecord: U) => TInsertObject<T> | Promise<TInsertObject<T>>): Promise<void>;
    upsertAsync<U extends TUpdateObject<T>, OK extends keyof T>(updateFwd: (entity: TEntity<T>) => U | Promise<U>, insertFwd: (updateRecord: U) => TInsertObject<T> | Promise<TInsertObject<T>>, outputColumns: OK[]): Promise<{
        [K in OK]: T[K];
    }[]>;
    upsertPrepare<U extends TUpdateObject<T>>(updateObjOrFwd: U | ((entity: TEntity<T>) => U), insertObjOrFwd?: TInsertObject<T> | ((updateRecord: U) => TInsertObject<T>)): void;
    configIdentityInsert(state: "on" | "off"): void;
    private _include;
    private _getParentEntity;
    private _insertAsync;
    private _insertPrepare;
    private _getInsertDefs;
    private _getUpdateDefs;
    private _getDeleteDefs;
    private _getUpsertDefs;
    private _getParseOption;
    private _setEntityChainValue;
    private _getEntityChainValue;
}