import { BelongsToRelation, HasOneRelation, Db, Adapter, AdapterOptions, QueryLogOptions, HasManyRelation, HasAndBelongsToManyRelation, Query, defaultsKey, BaseRelation, EmptyObject, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, ColumnTypesBase, ColumnsShape, ColumnShapeOutput, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';

interface BelongsTo extends RelationThunkBase {
    type: 'belongsTo';
    returns: 'one';
    options: BelongsToRelation['options'];
}
declare type BelongsToInfo<T extends Model, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
    params: Record<FK, T['columns']['shape'][FK]['type']>;
    populate: never;
    chainedCreate: false;
    chainedDelete: false;
};

interface HasOne extends RelationThunkBase {
    type: 'hasOne';
    returns: 'one';
    options: HasOneRelation['options'];
}
declare type HasOneInfo<T extends Model, Relations extends RelationThunks, Relation extends HasOne> = {
    params: Relation['options'] extends {
        primaryKey: string;
    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
        through: string;
    } ? RelationInfo<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
    populate: Relation['options'] extends {
        foreignKey: string;
    } ? Relation['options']['foreignKey'] : never;
    chainedCreate: Relation['options'] extends {
        primaryKey: string;
    } ? true : false;
    chainedDelete: true;
};

declare function transaction<T extends {
    $queryBuilder: Db;
}, Result>(this: T, fn: (db: T) => Promise<Result>): Promise<Result>;

declare type OrchidORM<T extends ModelClasses> = {
    [K in keyof T]: DbModel<T[K]>;
} & {
    $transaction: typeof transaction;
    $adapter: Adapter;
    $queryBuilder: Db;
    $close(): Promise<void>;
};
declare const orchidORM: <T extends ModelClasses>({ log, logger, ...options }: ({
    adapter: Adapter;
} | Omit<AdapterOptions, 'log'>) & QueryLogOptions, models: T) => OrchidORM<T>;

interface HasMany extends RelationThunkBase {
    type: 'hasMany';
    returns: 'many';
    options: HasManyRelation['options'];
}
declare type HasManyInfo<T extends Model, Relations extends RelationThunks, Relation extends HasMany> = {
    params: Relation['options'] extends {
        primaryKey: string;
    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
        through: string;
    } ? RelationInfo<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
    populate: Relation['options'] extends {
        foreignKey: string;
    } ? Relation['options']['foreignKey'] : never;
    chainedCreate: Relation['options'] extends {
        primaryKey: string;
    } ? true : false;
    chainedDelete: true;
};

interface HasAndBelongsToMany extends RelationThunkBase {
    type: 'hasAndBelongsToMany';
    returns: 'many';
    options: HasAndBelongsToManyRelation['options'];
}
declare type HasAndBelongsToManyInfo<T extends Model, Relation extends HasAndBelongsToMany> = {
    params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
    populate: never;
    chainedCreate: true;
    chainedDelete: true;
};

interface RelationThunkBase {
    type: string;
    returns: 'one' | 'many';
    fn(): ModelClass;
    options: BaseRelation['options'];
}
declare type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
declare type RelationThunks = Record<string, RelationThunk>;
declare type Relation<T extends Model, Relations extends RelationThunks, K extends keyof Relations, M extends Query = DbModel<ReturnType<Relations[K]['fn']>>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
    type: Relations[K]['type'];
    returns: Relations[K]['returns'];
    key: K;
    model: M;
    query: M;
    joinQuery(fromQuery: Query, toQuery: Query): Query;
    defaults: Info['populate'];
    nestedCreateQuery: [Info['populate']] extends [never] ? M : M & {
        [defaultsKey]: Record<Info['populate'], true>;
    };
    nestedInsert: BaseRelation['nestedInsert'];
    nestedUpdate: BaseRelation['nestedUpdate'];
    primaryKey: string;
    options: Relations[K]['options'];
};
declare type RelationScopeOrModel<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbModel<ReturnType<Relation['fn']>>;
declare type RelationInfo<T extends Model = Model, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
declare type MapRelation<T extends Model, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrModel<Relation>, Info extends {
    params: Record<string, unknown>;
    populate: string;
    chainedCreate: boolean;
    chainedDelete: boolean;
} = RelationInfo<T, Relations, Relation>> = RelationQuery<RelationName, Info['params'], Info['populate'], Relation['returns'] extends 'one' ? Relation['options']['required'] extends true ? SetQueryReturnsOne<RelatedQuery> : SetQueryReturnsOneOptional<RelatedQuery> : SetQueryReturnsAll<RelatedQuery>, Relation['options']['required'] extends boolean ? Relation['options']['required'] : false, Info['chainedCreate'], Info['chainedDelete']>;
declare type MapRelations<T extends Model> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
    [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
} : EmptyObject : EmptyObject;

declare type ModelClass<T extends Model = Model> = new () => T;
declare type ModelClasses = Record<string, ModelClass>;
declare type ModelToDb<T extends Model> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
    [K in keyof T['relations']]: Relation<T, T['relations'], K>;
} : Query['relations'] : Query['relations'], T['columnTypes']> & {
    definedAs: string;
    db: OrchidORM<ModelClasses>;
};
declare type DbModel<T extends ModelClass> = ModelToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
declare type ModelConfig = {
    shape: ColumnsShape;
    type: unknown;
};
declare type ScopeFn<Related extends ModelClass, Scope extends Query> = (q: DbModel<Related>) => Scope;
declare type Model = {
    table: string;
    columns: ModelConfig;
    schema?: string;
    columnTypes: ColumnTypesBase;
};
declare const createModel: <CT extends ColumnTypesBase>(options: {
    columnTypes: CT;
}) => {
    new (): {
        table: string;
        columns: ModelConfig;
        schema?: string | undefined;
        columnTypes: CT;
        setColumns: <T extends ColumnsShape>(fn: (t: CT) => T) => {
            shape: T;
            type: ColumnShapeOutput<T>;
        };
        belongsTo<Self extends any, Related extends ModelClass<Model>, Scope extends Query, Options extends {
            primaryKey: keyof InstanceType<Related>["columns"]["shape"];
            foreignKey: keyof Self["columns"]["shape"];
            scope?: ScopeFn<Related, Scope> | undefined;
            required?: boolean | undefined;
        }>(this: Self, fn: () => Related, options: Options): {
            type: "belongsTo";
            returns: "one";
            fn: () => Related;
            options: Options;
        };
        hasOne<Self_1 extends any, Related_1 extends ModelClass<Model>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends ({
            primaryKey: keyof Self_1["columns"]["shape"];
            foreignKey: keyof InstanceType<Related_1>["columns"]["shape"];
        } | {
            through: Through;
            source: Source;
        }) & {
            scope?: ScopeFn<Related_1, Scope_1> | undefined;
            required?: boolean | undefined;
        }>(this: Self_1, fn: () => Related_1, options: Options_1): {
            type: "hasOne";
            returns: "one";
            fn: () => Related_1;
            options: Options_1;
        };
        hasMany<Self_2 extends any, Related_2 extends ModelClass<Model>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends ({
            primaryKey: keyof Self_2["columns"]["shape"];
            foreignKey: keyof InstanceType<Related_2>["columns"]["shape"];
        } | {
            through: Through_1;
            source: Source_1;
        }) & {
            scope?: ScopeFn<Related_2, Scope_2> | undefined;
            required?: boolean | undefined;
        }>(this: Self_2, fn: () => Related_2, options: Options_2): {
            type: "hasMany";
            returns: "many";
            fn: () => Related_2;
            options: Options_2;
        };
        hasAndBelongsToMany<Self_3 extends any, Related_3 extends ModelClass<Model>, Scope_3 extends Query, Options_3 extends {
            primaryKey: keyof Self_3["columns"]["shape"];
            associationPrimaryKey: keyof InstanceType<Related_3>["columns"]["shape"];
            foreignKey: string;
            associationForeignKey: string;
            joinTable: string;
            scope?: ScopeFn<Related_3, Scope_3> | undefined;
            required?: boolean | undefined;
        }>(this: Self_3, fn: () => Related_3, options: Options_3): {
            type: "hasAndBelongsToMany";
            returns: "many";
            fn: () => Related_3;
            options: Options_3;
        };
    };
};

declare type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
declare type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;
declare type MethodsBase<T extends Query> = {
    queryMethods?: QueryMethods<T>;
    queryOneMethods?: QueryMethods<QueryOne<T>>;
    queryWithWhereMethods?: QueryMethods<WhereResult<T>>;
    queryOneWithWhereMethods?: QueryMethods<QueryOne<WhereResult<T>>>;
    methods?: Record<string, unknown>;
};
declare type MapQueryMethods<T extends Query, BaseQuery extends Query, Methods> = Methods extends QueryMethods<T> ? {
    [K in keyof Methods]: Methods[K] extends (q: any, ...args: infer Args) => infer Result ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
} : EmptyObject;
declare type MapMethods<T extends Query, Methods extends MethodsBase<T>> = MapQueryMethods<T, Query, Methods['queryMethods']> & MapQueryMethods<QueryOne<T>, QueryOne<Query>, Methods['queryOneMethods']> & MapQueryMethods<WhereResult<T>, WhereResult<Query>, Methods['queryWithWhereMethods']> & MapQueryMethods<QueryOne<WhereResult<T>>, QueryOne<WhereResult<Query>>, Methods['queryOneWithWhereMethods']> & (Methods['methods'] extends Record<string, unknown> ? Methods['methods'] : EmptyObject);
declare type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapMethods<T, Methods>> = (<Q extends {
    table: T['table'];
    shape: T['shape'];
}>(q: Q) => Q & Mapped) & T & Mapped;
declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(model: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;

export { DbModel, MapMethods, MapQueryMethods, MethodsBase, Model, ModelClass, ModelClasses, ModelToDb, OrchidORM, QueryMethods, Repo, createModel, createRepo, orchidORM };