orchid-orm 1.6.39 → 1.7.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as pqb from 'pqb';
-import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, defaultsKey, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, DefaultColumnTypes, ColumnsShape, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, defaultsKey, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, DefaultColumnTypes, ColumnsShape, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes } from 'pqb';
 import * as orchid_core from 'orchid-core';
 import { StringKey, EmptyObject, ColumnTypesBase, ColumnShapeOutput, SetOptional } from 'orchid-core';
@@ -10,7 +10,7 @@ interface BelongsTo extends RelationThunkBase {
     returns: 'one';
     options: BelongsToRelation['options'];
 }
-declare type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
+type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
     params: Record<FK, T['columns']['shape'][FK]['type']>;
     populate: never;
     chainedCreate: false;
@@ -22,7 +22,7 @@ interface HasMany extends RelationThunkBase {
     returns: 'many';
     options: HasManyRelation['options'];
 }
-declare type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany> = {
+type HasManyInfo<T extends Table, 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 {
@@ -42,7 +42,7 @@ interface HasOne extends RelationThunkBase {
     returns: 'one';
     options: HasOneRelation['options'];
 }
-declare type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne> = {
+type HasOneInfo<T extends Table, 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 {
@@ -59,9 +59,12 @@ declare type HasOneInfo<T extends Table, Relations extends RelationThunks, Relat
 
 declare function transaction<T extends {
     $queryBuilder: Db;
-}, Result>(this: T, fn: (db: T) => Promise<Result>): Promise<Result>;
+}, Result>(this: T, fn: () => Promise<Result>): Promise<Result>;
+declare function transaction<T extends {
+    $queryBuilder: Db;
+}, Result>(this: T, options: IsolationLevel | TransactionOptions, fn: () => Promise<Result>): Promise<Result>;
 
-declare type OrchidORM<T extends TableClasses> = {
+type OrchidORM<T extends TableClasses> = {
     [K in keyof T]: DbTable<T[K]>;
 } & {
     $transaction: typeof transaction;
@@ -82,7 +85,7 @@ interface HasAndBelongsToMany extends RelationThunkBase {
     returns: 'many';
     options: HasAndBelongsToManyRelation['options'];
 }
-declare type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
+type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
     params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
     populate: never;
     chainedCreate: true;
@@ -95,9 +98,9 @@ interface RelationThunkBase {
     fn(): TableClass;
     options: BaseRelation['options'];
 }
-declare type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
-declare type RelationThunks = Record<string, RelationThunk>;
-declare type Relation<T extends Table, Relations extends RelationThunks, K extends StringKey<keyof Relations>, M extends Query = SetQueryTableAlias<DbTable<ReturnType<Relations[K]['fn']>>, K>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
+type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
+type RelationThunks = Record<string, RelationThunk>;
+type Relation<T extends Table, Relations extends RelationThunks, K extends StringKey<keyof Relations>, M extends Query = SetQueryTableAlias<DbTable<ReturnType<Relations[K]['fn']>>, K>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
     type: Relations[K]['type'];
     returns: Relations[K]['returns'];
     key: K;
@@ -111,33 +114,33 @@ declare type Relation<T extends Table, Relations extends RelationThunks, K exten
     primaryKey: string;
     options: Relations[K]['options'];
 };
-declare type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
-declare type RelationInfo<T extends Table = Table, 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 Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Info extends {
+type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
+type RelationInfo<T extends Table = Table, 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;
+type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<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 Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+type MapRelations<T extends Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
 } : EmptyObject : EmptyObject;
 
-declare type TableClass<T extends Table = Table> = new () => T;
-declare type TableClasses = Record<string, TableClass>;
-declare type TableToDb<T extends Table> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+type TableClass<T extends Table = Table> = new () => T;
+type TableClasses = Record<string, TableClass>;
+type TableToDb<T extends Table> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in StringKey<keyof T['relations']>]: Relation<T, T['relations'], K>;
 } : Query['relations'] : Query['relations'], T['columnTypes']> & {
     definedAs: string;
     db: OrchidORM<TableClasses>;
 };
-declare type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
-declare type TableConfig = {
+type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
+type TableConfig = {
     shape: ColumnsShape;
     type: unknown;
 };
-declare type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
-declare type Table = {
+type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
+type Table = {
     table: string;
     columns: TableConfig;
     schema?: string;
@@ -159,8 +162,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 };
                 timestamp(): T;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
             };
             timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
@@ -168,8 +171,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 };
                 timestamp(): T_1;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
             };
             name: typeof orchid_core.name;
             raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
@@ -240,12 +243,12 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 nativeEnum: <T_9 extends orchid_core.EnumLike>(givenEnum: T_9) => orchid_core.JSONNativeEnum<T_9>;
                 nullable: <T_10 extends orchid_core.JSONTypeAny>(type: T_10) => orchid_core.JSONNullable<T_10>;
                 nullish: <T_11 extends orchid_core.JSONTypeAny>(type: T_11) => orchid_core.JSONNullish<T_11>;
-                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_16 extends object ? { [k in keyof T_16]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
-                } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_15 extends object ? { [k in keyof T_15]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
                 })[k_2]; } : never>;
-                optional: <T_15 extends orchid_core.JSONTypeAny>(type: T_15) => orchid_core.JSONOptional<T_15>;
+                optional: <T_17 extends orchid_core.JSONTypeAny>(type: T_17) => orchid_core.JSONOptional<T_17>;
                 record: typeof orchid_core.record;
             }) => Type)): pqb.JSONColumn<Type>;
             jsonText(this: ColumnTypesBase): pqb.JSONTextColumn;
@@ -257,29 +260,29 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
             } | undefined): {};
             index(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
             unique(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
-            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_1>>, ...pqb.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
                 name?: string | undefined;
                 references?: [columns: string[], fnOrTable: Table_1, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
-                check?: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | undefined;
+                check?: orchid_core.RawExpression | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }): {};
-            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_2>>, ...pqb.ColumnNameOfTable<ReturnType<Table_2>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
                 name?: string | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }) | undefined): {};
-            check(check: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>): {};
+            check(check: orchid_core.RawExpression): {};
         } : CT;
         noPrimaryKey?: boolean | undefined;
         snakeCase: boolean | undefined;
-        setColumns: <T_16 extends ColumnsShape>(fn: (t: ColumnTypesBase extends CT ? {
+        setColumns: <T_18 extends ColumnsShape>(fn: (t: ColumnTypesBase extends CT ? {
             timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
                     timestamp(): T;
                 };
                 timestamp(): T;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
             };
             timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
@@ -287,8 +290,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 };
                 timestamp(): T_1;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
             };
             name: typeof orchid_core.name;
             raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
@@ -359,12 +362,12 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 nativeEnum: <T_9 extends orchid_core.EnumLike>(givenEnum: T_9) => orchid_core.JSONNativeEnum<T_9>;
                 nullable: <T_10 extends orchid_core.JSONTypeAny>(type: T_10) => orchid_core.JSONNullable<T_10>;
                 nullish: <T_11 extends orchid_core.JSONTypeAny>(type: T_11) => orchid_core.JSONNullish<T_11>;
-                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_19 extends object ? { [k in keyof T_19]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_22 extends object ? { [k in keyof T_22]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
-                } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                } extends infer T_20 extends object ? { [k_2 in keyof T_20]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_21 extends object ? { [k in keyof T_21]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
                 })[k_2]; } : never>;
-                optional: <T_15 extends orchid_core.JSONTypeAny>(type: T_15) => orchid_core.JSONOptional<T_15>;
+                optional: <T_17 extends orchid_core.JSONTypeAny>(type: T_17) => orchid_core.JSONOptional<T_17>;
                 record: typeof orchid_core.record;
             }) => Type)): pqb.JSONColumn<Type>;
             jsonText(this: ColumnTypesBase): pqb.JSONTextColumn;
@@ -376,20 +379,20 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
             } | undefined): {};
             index(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
             unique(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
-            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_1>>, ...pqb.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
                 name?: string | undefined;
                 references?: [columns: string[], fnOrTable: Table_1, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
-                check?: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | undefined;
+                check?: orchid_core.RawExpression | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }): {};
-            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_2>>, ...pqb.ColumnNameOfTable<ReturnType<Table_2>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
                 name?: string | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }) | undefined): {};
-            check(check: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>): {};
-        } : CT) => T_16) => {
-            shape: T_16;
-            type: ColumnShapeOutput<T_16>;
+            check(check: orchid_core.RawExpression): {};
+        } : CT) => T_18) => {
+            shape: T_18;
+            type: ColumnShapeOutput<T_18>;
         };
         belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends {
             primaryKey: keyof InstanceType<Related>["columns"]["shape"];
@@ -449,20 +452,20 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
     };
 };
 
-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> = {
+type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
+type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;
+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> ? {
+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 {
+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);
+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;
@@ -470,7 +473,7 @@ declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(tabl
 
 declare class AppCodeUpdaterError extends Error {
 }
-declare type AppCodeUpdaterConfig = {
+type AppCodeUpdaterConfig = {
     tablePath(tableName: string): string;
     baseTablePath: string;
     baseTableName: string;