import * as Knex from 'knex';
export declare function unflatten(o: any): any;
export declare class TypedKnex {
    private knex;
    constructor(knex: Knex);
    query<T>(tableClass: new () => T): ITypedQueryBuilder<T, T>;
}
export declare function registerBeforeInsertTransform<T>(f: (item: T, typedQueryBuilder: TypedQueryBuilder<{}, {}>) => T): void;
export declare function registerBeforeUpdateTransform<T>(f: (item: T, typedQueryBuilder: TypedQueryBuilder<{}, {}>) => T): void;
export interface ITypedQueryBuilder<ModelType, Row> {
    where: IWhere<ModelType, Row>;
    andWhere: IWhere<ModelType, Row>;
    orWhere: IWhere<ModelType, Row>;
    whereNot: IWhere<ModelType, Row>;
    selectColumns: ISelectColumns<ModelType, Row extends ModelType ? {} : Row>;
    selectColumn: ISelectColumn<ModelType, Row extends ModelType ? {} : Row>;
    orderBy: IKeysAsParametersReturnQueryBuider<ModelType, Row>;
    innerJoinColumn: IKeysAsParametersReturnQueryBuider<ModelType, Row>;
    leftOuterJoinColumn: IKeysAsParametersReturnQueryBuider<ModelType, Row>;
    whereColumns: IWhereCompareTwoColumns<ModelType, Row>;
    whereNull: IKeysAsParametersReturnQueryBuider<ModelType, Row>;
    whereNotNull: IKeysAsParametersReturnQueryBuider<ModelType, Row>;
    innerJoinTable: IJoinTable<ModelType, Row>;
    leftOuterJoinTable: IJoinTable<ModelType, Row>;
    leftOuterJoinTableOnFunction: IJoinTableMultipleOnClauses<ModelType, Row>;
    selectRaw: ISelectRaw<ModelType, Row>;
    findById: IFindById<ModelType, Row>;
    whereIn: IWhereIn<ModelType, Row>;
    whereNotIn: IWhereIn<ModelType, Row>;
    whereBetween: IWhereBetween<ModelType, Row>;
    whereNotBetween: IWhereBetween<ModelType, Row>;
    whereExists: IWhereExists<ModelType, Row>;
    orWhereExists: IWhereExists<ModelType, Row>;
    whereNotExists: IWhereExists<ModelType, Row>;
    orWhereNotExists: IWhereExists<ModelType, Row>;
    groupBy: IGroupBy<ModelType, Row>;
    having: IHaving<ModelType, Row>;
    limit(value: number): ITypedQueryBuilder<ModelType, Row>;
    offset(value: number): ITypedQueryBuilder<ModelType, Row>;
    firstItemOrNull(): Promise<Row | null>;
    firstItem(): Promise<Row>;
    list(): Promise<Row[]>;
    useKnexQueryBuilder(f: (query: Knex.QueryBuilder) => void): void;
    toQuery(): string;
    insert(newObject: Partial<ModelType>): Promise<void>;
    countResult(): Promise<number>;
    delById(id: string): Promise<void>;
    update(id: string, item: Partial<ModelType>): Promise<void>;
    whereRaw(sql: string, ...bindings: string[]): ITypedQueryBuilder<ModelType, Row>;
    havingIn(): void;
    havingNotIn(): void;
    havingNull(): void;
    havingNotNull(): void;
    havingExists(): void;
    havingNotExists(): void;
    havingRaw(): void;
    havingBetween(): void;
    havingNotBetween(): void;
    union(): void;
    unionAll(): void;
    returningColumn(): void;
    returningColumns(): void;
    transacting(trx: Knex.Transaction): void;
    minColumn(): void;
    countColumn(): void;
    countDistinctColumn(): void;
    maxColumn(): void;
    sumColumn(): void;
    sumDistinctColumn(): void;
    avgColumn(): void;
    avgDistinctColumn(): void;
    minResult(): void;
    countDistinctResult(): void;
    maxResult(): void;
    sumResult(): void;
    sumDistinctResult(): void;
    avgResult(): void;
    avgDistinctResult(): void;
    increment(): void;
    decrement(): void;
    truncate(): void;
    clearSelect(): void;
    clearWhere(): void;
    clearOrder(): void;
    distinct(): void;
    clone(): void;
    beginTransaction(): Promise<Knex.Transaction>;
    groupByRaw(): void;
}
export declare type TransformAll<T, IT> = {
    [Key in keyof T]: IT;
};
export declare type FilterObjectsOnly<T> = {
    [K in keyof T]: T[K] extends object ? K : never;
}[keyof T];
export declare type FilterNonObjects<T> = {
    [K in keyof T]: T[K] extends object ? never : K;
}[keyof T];
export declare type ObjectToPrimitive<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : never;
export declare type Operator = '=' | '!=' | '>' | '<' | string;
export interface IConstructor<T> {
    new (...args: any[]): T;
}
export declare type AddPropertyWithType<Original, NewKey extends keyof TypeWithIndexerOf<NewKeyType>, NewKeyType> = Original & Pick<TypeWithIndexerOf<NewKeyType>, NewKey>;
export interface IKeysAsArguments<Model, Return> {
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keys: string[]): Return;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3): Return;
    <K1 extends keyof Model, K2 extends keyof Model[K1]>(key1: K1, key2: K2): Return;
    <K extends keyof Model>(key1: K): Return;
}
export interface IKeysAsParametersReturnQueryBuider<Model, Row> extends IKeysAsArguments<Model, ITypedQueryBuilder<Model, Row>> {
}
export declare type TypeWithIndexerOf<T> = {
    [key: string]: T;
};
export interface IJoinTable<Model, Row> {
    <NewPropertyType, NewPropertyKey extends keyof TypeWithIndexerOf<NewPropertyType>, L1K1 extends keyof AddPropertyWithType<Model, NewPropertyKey, NewPropertyType>, L2K1 extends keyof AddPropertyWithType<Model, NewPropertyKey, NewPropertyType>, L2K2 extends keyof AddPropertyWithType<Model, NewPropertyKey, NewPropertyType>[L2K1]>(newPropertyKey: NewPropertyKey, newPropertyClass: new () => NewPropertyType, column1: [L1K1] | [L2K1, L2K2], operator: Operator, column2: [L1K1] | [L2K1, L2K2]): ITypedQueryBuilder<AddPropertyWithType<Model, NewPropertyKey, NewPropertyType>, Row>;
}
export interface IJoinOnClause<Model> {
    onColumns: <L1K1 extends keyof Model, L2K1 extends keyof Model, L2K2 extends keyof Model[L2K1]>(column1: [L1K1] | [L2K1, L2K2], operator: Operator, column2: [L1K1] | [L2K1, L2K2]) => IJoinOnClause<Model>;
    onNull: IKeysAsParametersReturnQueryBuider<Model, IJoinOnClause<Model>>;
}
interface IReferencedColumn {
}
export interface IJoinTableMultipleOnClauses<Model, Row> {
    <NewPropertyType, NewPropertyKey extends keyof TypeWithIndexerOf<NewPropertyType>>(newPropertyKey: NewPropertyKey, newPropertyClass: new () => NewPropertyType, on: (join: IJoinOnClause<AddPropertyWithType<Model, NewPropertyKey, NewPropertyType>>) => void): ITypedQueryBuilder<AddPropertyWithType<Model, NewPropertyKey, NewPropertyType>, Row>;
}
export interface IWhereCompareTwoColumns<Model, Row> {
    <L1K1 extends keyof Model, L2K1 extends keyof Model, L2K2 extends keyof Model[L2K1]>(column1: [L1K1] | [L2K1, L2K2], operator: Operator, column2: [L1K1] | [L2K1, L2K2] | IReferencedColumn): ITypedQueryBuilder<Model, Row>;
}
export interface IGroupBy<Model, Row> {
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keys: string[]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1]>(key1: K1, key2: K2): ITypedQueryBuilder<Model, Row>;
    <K extends keyof Model>(key1: K): ITypedQueryBuilder<Model, Row>;
}
export interface ISelectRaw<Model, Row> {
    <TReturn extends Boolean | String | Number, TName extends keyof TypeWithIndexerOf<TReturn>>(name: TName, returnType: IConstructor<TReturn>, query: string): ITypedQueryBuilder<Model, Pick<TypeWithIndexerOf<ObjectToPrimitive<TReturn>>, TName> & Row>;
}
export interface ISelectColumn<Model, Row> {
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keys: string[]): ITypedQueryBuilder<Model, TransformAll<Pick<Model, K1>, TransformAll<Pick<Model[K1], K2>, TransformAll<Pick<Model[K1][K2], K3>, any>>> & Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3): ITypedQueryBuilder<Model, TransformAll<Pick<Model, K1>, TransformAll<Pick<Model[K1], K2>, Pick<Model[K1][K2], K3>>> & Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1]>(key1: K1, key2: K2): ITypedQueryBuilder<Model, TransformAll<Pick<Model, K1>, Pick<Model[K1], K2>> & Row>;
    <K extends keyof Model>(key1: K): ITypedQueryBuilder<Model, Pick<Model, K> & Row>;
}
export interface IReferenceColumn<Model> {
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keys: string[]): IReferencedColumn;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3): IReferencedColumn;
    <K1 extends keyof Model, K2 extends keyof Model[K1]>(key1: K1, key2: K2): IReferencedColumn;
    <K extends keyof Model>(key1: K): IReferencedColumn;
}
export interface ISelectColumns<Model, Row> {
    <Prev extends Row, K1 extends FilterObjectsOnly<Model>, K2 extends FilterNonObjects<Model[K1]>>(key1: K1, keys2: K2[]): ITypedQueryBuilder<Model, TransformAll<Pick<Model, K1>, Pick<Model[K1], K2>> & Prev>;
    <K extends FilterNonObjects<Model>>(keys: K[]): ITypedQueryBuilder<Model, Pick<Model, K> & Row>;
}
export interface IFindById<Model, Row> {
    <Prev extends Row, K1 extends FilterObjectsOnly<Model>, K2 extends FilterNonObjects<Model[K1]>>(id: string, key1: K1, keys2: K2[]): Promise<(TransformAll<Pick<Model, K1>, Pick<Model[K1], K2>> & Prev) | void>;
    <K extends FilterNonObjects<Model>>(id: string, keys: K[]): Promise<(Pick<Model, K> & Row) | void>;
}
export interface IHaving<Model, Row> {
    <K extends FilterNonObjects<Model>>(key1: K, operator: Operator, value: Model[K]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends FilterNonObjects<Model[K1]>>(key1: K1, key2: K2, operator: Operator, value: Model[K1][K2]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends FilterNonObjects<Model[K1][K2]>>(key1: K1, key2: K2, key3: K3, operator: Operator, value: Model[K1][K2][K3]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keysOperratorAndValue: any[]): ITypedQueryBuilder<Model, Row>;
}
export interface IWhere<Model, Row> {
    <K extends FilterNonObjects<Model>>(key1: K, value: Model[K]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends FilterNonObjects<Model[K1]>>(key1: K1, key2: K2, value: Model[K1][K2]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends FilterNonObjects<Model[K1][K2]>>(key1: K1, key2: K2, key3: K3, value: Model[K1][K2][K3]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keysAndValues: any[]): ITypedQueryBuilder<Model, Row>;
}
export interface IWhereIn<Model, Row> {
    <K extends FilterNonObjects<Model>>(key1: K, value: Model[K][]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends FilterNonObjects<Model[K1]>>(key1: K1, key2: K2, value: Model[K1][K2][]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends FilterNonObjects<Model[K1][K2]>>(key1: K1, key2: K2, key3: K3, value: Model[K1][K2][K3][]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keysAndValues: any[]): ITypedQueryBuilder<Model, Row>;
}
export interface IWhereBetween<Model, Row> {
    <K extends FilterNonObjects<Model>>(key1: K, range: [Model[K], Model[K]]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends FilterNonObjects<Model[K1]>>(key1: K1, key2: K2, range: [Model[K1][K2], Model[K1][K2]]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends FilterNonObjects<Model[K1][K2]>>(key1: K1, key2: K2, key3: K3, range: [Model[K1][K2][K3], Model[K1][K2][K3]]): ITypedQueryBuilder<Model, Row>;
    <K1 extends keyof Model, K2 extends keyof Model[K1], K3 extends keyof Model[K1][K2]>(key1: K1, key2: K2, key3: K3, ...keysAndValues: any[]): ITypedQueryBuilder<Model, Row>;
}
export interface IWhereExists<Model, Row> {
    <SubQueryModel>(subQueryModel: new () => SubQueryModel, code: (subQuery: ITypedQueryBuilder<SubQueryModel, {}>, parent: ISelectColumn<Model, Row>) => void): ITypedQueryBuilder<Model, Row>;
}
export declare class TypedQueryBuilder<ModelType, Row = {}> implements ITypedQueryBuilder<ModelType, Row> {
    private tableClass;
    private knex;
    columns: {
        name: string;
    }[];
    private queryBuilder;
    private tableName;
    private extraJoinedProperties;
    constructor(tableClass: new () => ModelType, knex: Knex, queryBuilder?: Knex.QueryBuilder);
    delById(id: string): Promise<void>;
    insert(newObject: Partial<ModelType>): Promise<void>;
    insertItems(items: Partial<ModelType>[]): Promise<void>;
    update(id: string, item: Partial<ModelType>): Promise<void>;
    updateItems(items: {
        id: string;
        data: Partial<ModelType>;
    }[]): Promise<void>;
    limit(value: number): any;
    offset(value: number): any;
    findById(id: string, columns: (keyof ModelType)[]): Promise<any>;
    countResult(): Promise<any>;
    firstItemOrNull(): Promise<any>;
    firstItem(): Promise<any>;
    selectColumn(): any;
    selectColumns(): any;
    orderBy(): any;
    list(): Promise<Row[]>;
    selectRaw(): any;
    innerJoinColumn(): this;
    leftOuterJoinColumn(): this;
    innerJoinTable(): this;
    leftOuterJoinTableOnFunction(): this;
    leftOuterJoinTable(): this;
    whereColumns(): this;
    toQuery(): string;
    whereNull(): this;
    whereNotNull(): this;
    where(): this;
    whereNot(): this;
    andWhere(): this;
    orWhere(): this;
    whereIn(): this;
    whereNotIn(): this;
    whereBetween(): this;
    whereNotBetween(): this;
    callQueryCallbackFunction(functionName: string, typeOfSubQuery: any, functionToCall: any): void;
    whereExists(): this;
    orWhereExists(): this;
    whereNotExists(): this;
    orWhereNotExists(): this;
    whereRaw(sql: string, ...bindings: string[]): this;
    having(): this;
    havingIn(): this;
    havingNotIn(): this;
    havingNull(): this;
    havingNotNull(): this;
    havingExists(): void;
    havingNotExists(): void;
    havingRaw(): void;
    havingBetween(): this;
    havingNotBetween(): this;
    union(): void;
    unionAll(): void;
    returningColumn(): void;
    returningColumns(): void;
    transacting(trx: Knex.Transaction): void;
    minColumn(): void;
    countColumn(): void;
    countDistinctColumn(): void;
    maxColumn(): void;
    sumColumn(): void;
    sumDistinctColumn(): void;
    avgColumn(): void;
    avgDistinctColumn(): void;
    minResult(): void;
    countDistinctResult(): void;
    maxResult(): void;
    sumResult(): void;
    sumDistinctResult(): void;
    avgResult(): void;
    avgDistinctResult(): void;
    increment(): this;
    decrement(): this;
    truncate(): void;
    clearSelect(): void;
    clearWhere(): void;
    clearOrder(): void;
    distinct(): void;
    clone(): void;
    beginTransaction(): Promise<Knex.Transaction>;
    groupBy(): this;
    groupByRaw(): void;
    useKnexQueryBuilder(f: (query: Knex.QueryBuilder) => void): void;
    private joinColumn;
    private getColumnNameFromArgumentsIgnoringLastParameter;
    private getColumnNameFromArgumentsIgnoringLastTwoParameters;
    private getColumnName;
    private getColumnSelectAlias;
}
export {};