orchid-orm 1.67.1 → 1.68.1

package/dist/index.d.ts

@@ -1,793 +1,753 @@
-import { Column, TableData, ColumnsShape, RelationConfigBase, QueryManyTake, QueryManyTakeOptional, EmptyObject, CreateData, UpdateData, WhereArg, SelectableFromShape, CreateManyMethodsNames, QueryHasWhere, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, StorageOptions, DbSharedOptions, ColumnSchemaConfig, DbSqlMethod, TableDataItem, QueryData, IsQuery, TableDataFn, ComputedOptionsFactory, DbTableOptionScopes, QueryScopes, RecordUnknown, QueryBeforeHook, QueryAfterHook, QueryBeforeActionHook, AfterHook, ShallowSimplify, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, ComputedOptionsConfig, QueryOrExpression, DefaultSchemaConfig, DefaultColumnTypes, QueryReturnType, MergeQuery } from 'pqb/internal';
-import { Query, Db, QuerySchema } from 'pqb';
-export * from 'pqb';
-
+import { Adapter, AfterCommitStandaloneHook, AfterHook, Column, ColumnSchemaConfig, ColumnsShape, ComputedColumnsFromOptions, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, IsQuery, IsolationLevel, JoinQueryMethod, MapTableScopesOption, MaybeArray, MergeQuery, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryManyTake, QueryManyTakeOptional, QueryOrExpression, QueryReturnType, QuerySchema, QueryScopes, RecordUnknown, RelationConfigBase, SelectableFromShape, ShallowSimplify, ShapeColumnPrimaryKeys, ShapeUniqueColumns, StorageOptions, TableData, TableDataFn, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TransactionOptions, UniqueConstraints, UpdateData, WhereArg } from "pqb/internal";
+import { Db, Query } from "pqb";
+export * from "pqb";
 interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
-    required?: boolean;
-    columns: Column[];
-    references: (keyof Shape)[];
-    foreignKey?: boolean | TableData.References.Options;
-    on?: ColumnsShape.InputPartial<Shape>;
+  required?: boolean;
+  columns: Column[];
+  references: (keyof Shape)[];
+  foreignKey?: boolean | TableData.References.Options;
+  on?: ColumnsShape.InputPartial<Shape>;
 }
 interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
-    through: Through;
-    source: Source;
+  through: Through;
+  source: Source;
 }
-
 interface HasOne extends RelationThunkBase {
-    type: 'hasOne';
-    options: HasOneOptions;
+  type: 'hasOne';
+  options: HasOneOptions;
 }
 interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
-    required?: boolean;
+  required?: boolean;
 }
 type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
-type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? {
-    [Name in Options['columns'][number]]: T['columns']['shape'][Name]['type'];
-} : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
-type HasOneQueryThrough<Name extends string, TableQuery extends Query> = {
-    [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K];
-} & QueryHasWhere & HasRelJoin;
-type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? {
-    [K in keyof TableQuery]: K extends '__defaults' ? {
-        [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true;
-    } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K];
-} & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
+type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? { [Name in Options['columns'][number]]: T['columns']['shape'][Name]['type'] } : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
+type HasOneQueryThrough<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K] } & QueryHasWhere & HasRelJoin;
+type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K] } & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
 interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query> extends RelationConfigBase {
-    returnsOne: true;
-    query: Q;
-    params: HasOneParams<T, Rel['options']>;
-    maybeSingle: T['relations'][Name]['options']['required'] extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
-    omitForeignKeyInCreate: never;
-    optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
-        [P in Name]?: RelationToOneDataForCreate<{
-            nestedCreateQuery: CreateData<Q>;
-            table: Q;
-        }>;
-    };
-    dataForCreate: never;
-    dataForUpdate: {
-        disconnect: boolean;
-    } | {
-        delete: boolean;
-    } | {
-        update: UpdateData<Q>;
-    };
-    dataForUpdateOne: {
-        disconnect: boolean;
-    } | {
-        set: WhereArg<Q>;
-    } | {
-        delete: boolean;
-    } | {
-        update: UpdateData<Q>;
-    } | {
-        upsert: {
-            update: UpdateData<Q>;
-            create: CreateData<Q> | (() => CreateData<Q>);
-        };
-    } | {
-        create: CreateData<Q>;
+  returnsOne: true;
+  query: Q;
+  params: HasOneParams<T, Rel['options']>;
+  maybeSingle: T['relations'][Name]['options']['required'] extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
+  omitForeignKeyInCreate: never;
+  optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : { [P in Name]?: RelationToOneDataForCreate<{
+    nestedCreateQuery: CreateData<Q>;
+    table: Q;
+  }> };
+  dataForCreate: never;
+  dataForUpdate: {
+    disconnect: boolean;
+  } | {
+    delete: boolean;
+  } | {
+    update: UpdateData<Q>;
+  };
+  dataForUpdateOne: {
+    disconnect: boolean;
+  } | {
+    set: WhereArg<Q>;
+  } | {
+    delete: boolean;
+  } | {
+    update: UpdateData<Q>;
+  } | {
+    upsert: {
+      update: UpdateData<Q>;
+      create: CreateData<Q> | (() => CreateData<Q>);
     };
+  } | {
+    create: CreateData<Q>;
+  };
 }
-
 interface HasMany extends RelationThunkBase {
-    type: 'hasMany';
-    options: HasOneOptions;
+  type: 'hasMany';
+  options: HasOneOptions;
 }
-type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? {
-    [K in keyof TableQuery]: K extends '__defaults' ? {
-        [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true;
-    } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
-} & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
+type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
 interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasMany, Q extends Query> extends RelationConfigBase {
-    returnsOne: false;
-    query: Q;
-    params: HasOneParams<T, Rel['options']>;
-    maybeSingle: Q;
-    omitForeignKeyInCreate: never;
-    optionalDataForCreate: {
-        [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
-            create?: CreateData<Q>[];
-            connect?: WhereArg<Q>[];
-            connectOrCreate?: {
-                where: WhereArg<Q>;
-                create: CreateData<Q>;
-            }[];
-        };
-    };
-    dataForCreate: never;
-    dataForUpdate: {
-        disconnect?: MaybeArray<WhereArg<Q>>;
-        delete?: MaybeArray<WhereArg<Q>>;
-        update?: {
-            where: MaybeArray<WhereArg<Q>>;
-            data: UpdateData<Q>;
-        };
+  returnsOne: false;
+  query: Q;
+  params: HasOneParams<T, Rel['options']>;
+  maybeSingle: Q;
+  omitForeignKeyInCreate: never;
+  optionalDataForCreate: { [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
+    create?: CreateData<Q>[];
+    connect?: WhereArg<Q>[];
+    connectOrCreate?: {
+      where: WhereArg<Q>;
+      create: CreateData<Q>;
+    }[];
+  } };
+  dataForCreate: never;
+  dataForUpdate: {
+    disconnect?: MaybeArray<WhereArg<Q>>;
+    delete?: MaybeArray<WhereArg<Q>>;
+    update?: {
+      where: MaybeArray<WhereArg<Q>>;
+      data: UpdateData<Q>;
     };
-    dataForUpdateOne: {
-        disconnect?: MaybeArray<WhereArg<Q>>;
-        delete?: MaybeArray<WhereArg<Q>>;
-        update?: {
-            where: MaybeArray<WhereArg<Q>>;
-            data: UpdateData<Q>;
-        };
-        set?: MaybeArray<WhereArg<Q>>;
-        add?: MaybeArray<WhereArg<Q>>;
-        create?: CreateData<Q>[];
+  };
+  dataForUpdateOne: {
+    disconnect?: MaybeArray<WhereArg<Q>>;
+    delete?: MaybeArray<WhereArg<Q>>;
+    update?: {
+      where: MaybeArray<WhereArg<Q>>;
+      data: UpdateData<Q>;
     };
+    set?: MaybeArray<WhereArg<Q>>;
+    add?: MaybeArray<WhereArg<Q>>;
+    create?: CreateData<Q>[];
+  };
 }
-
 interface RelJoin extends JoinQueryMethod {
-    <T extends Query>(this: T): T;
+  <T extends Query>(this: T): T;
 }
 interface HasRelJoin {
-    join: RelJoin;
+  join: RelJoin;
 }
-
 interface BelongsTo extends RelationThunkBase {
-    type: 'belongsTo';
-    options: BelongsToOptions;
+  type: 'belongsTo';
+  options: BelongsToOptions;
 }
 interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
-    required?: boolean;
-    columns: (keyof Columns)[];
-    references: (keyof Related['columns']['shape'])[];
-    foreignKey?: boolean | TableData.References.Options;
-    on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
+  required?: boolean;
+  columns: (keyof Columns)[];
+  references: (keyof Related['columns']['shape'])[];
+  foreignKey?: boolean | TableData.References.Options;
+  on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
-type BelongsToParams<T extends RelationConfigSelf, FK extends string> = {
-    [Name in FK]: T['columns']['shape'][Name]['type'];
-};
-type BelongsToQuery<T extends Query, Name extends string> = {
-    [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P];
-} & QueryHasWhere & HasRelJoin;
+type BelongsToParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['type'] };
+type BelongsToQuery<T extends Query, Name extends string> = { [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P] } & QueryHasWhere & HasRelJoin;
 interface BelongsToInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Required, Q extends Query> extends RelationConfigBase {
-    returnsOne: true;
-    query: Q;
-    params: BelongsToParams<T, FK>;
-    maybeSingle: Required extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
-    omitForeignKeyInCreate: FK;
-    dataForCreate: {
-        columns: FK;
-        nested: Required extends true ? {
-            [Key in Name]: RelationToOneDataForCreateSameQuery<Q>;
-        } : {
-            [Key in Name]?: RelationToOneDataForCreateSameQuery<Q>;
-        };
-    };
-    optionalDataForCreate: EmptyObject;
-    dataForUpdate: {
-        disconnect: boolean;
-    } | {
-        set: WhereArg<Q>;
-    } | {
-        delete: boolean;
-    } | {
-        update: UpdateData<Q>;
-    } | {
-        create: CreateData<Q>;
-    };
-    dataForUpdateOne: {
-        disconnect: boolean;
-    } | {
-        set: WhereArg<Q>;
-    } | {
-        delete: boolean;
-    } | {
-        update: UpdateData<Q>;
-    } | {
-        create: CreateData<Q>;
-    } | {
-        upsert: {
-            update: UpdateData<Q>;
-            create: CreateData<Q> | (() => CreateData<Q>);
-        };
+  returnsOne: true;
+  query: Q;
+  params: BelongsToParams<T, FK>;
+  maybeSingle: Required extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
+  omitForeignKeyInCreate: FK;
+  dataForCreate: {
+    columns: FK;
+    nested: Required extends true ? { [Key in Name]: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: RelationToOneDataForCreateSameQuery<Q> };
+  };
+  optionalDataForCreate: EmptyObject;
+  dataForUpdate: {
+    disconnect: boolean;
+  } | {
+    set: WhereArg<Q>;
+  } | {
+    delete: boolean;
+  } | {
+    update: UpdateData<Q>;
+  } | {
+    create: CreateData<Q>;
+  };
+  dataForUpdateOne: {
+    disconnect: boolean;
+  } | {
+    set: WhereArg<Q>;
+  } | {
+    delete: boolean;
+  } | {
+    update: UpdateData<Q>;
+  } | {
+    create: CreateData<Q>;
+  } | {
+    upsert: {
+      update: UpdateData<Q>;
+      create: CreateData<Q> | (() => CreateData<Q>);
     };
+  };
 }
-
 declare function transaction<Result>(this: {
-    $qb: Db;
+  $qb: Db;
 }, fn: () => Promise<Result>): Promise<Result>;
 declare function transaction<Result>(this: {
-    $qb: Db;
+  $qb: Db;
 }, options: IsolationLevel | TransactionOptions, fn: () => Promise<Result>): Promise<Result>;
 declare function ensureTransaction<Result>(this: {
-    $qb: Db;
+  $qb: Db;
 }, cb: () => Promise<Result>): Promise<Result>;
 declare function isInTransaction(this: {
-    $qb: Db;
+  $qb: Db;
 }): boolean;
 declare function afterCommit(this: {
-    $qb: Db;
+  $qb: Db;
 }, hook: AfterCommitStandaloneHook): void;
-
 interface FromQuery extends Query {
-    returnType: 'all';
+  returnType: 'all';
 }
-type OrchidORM<T extends TableClasses = TableClasses> = {
-    [K in keyof T]: T[K] extends {
-        new (): infer R extends ORMTableInput;
-    } ? TableToDb<R> : never;
-} & OrchidORMMethods;
+type OrchidORM<T extends TableClasses = TableClasses> = { [K in keyof T]: T[K] extends {
+  new (): infer R extends ORMTableInput;
+} ? TableToDb<R> : never } & OrchidORMMethods;
 interface OrchidORMMethods {
-    /**
-     * @see import('pqb').QueryTransaction.prototype.transaction
-     */
-    $transaction: typeof transaction;
-    /**
-     * @see import('pqb').QueryTransaction.prototype.ensureTransaction
-     */
-    $ensureTransaction: typeof ensureTransaction;
-    /**
-     * @see import('pqb').QueryTransaction.prototype.isInTransaction
-     */
-    $isInTransaction: typeof isInTransaction;
-    /**
-     * @see import('pqb').QueryTransaction.prototype.afterCommit
-     */
-    $afterCommit: typeof afterCommit;
-    $qb: Db;
-    $adapterNotInTransaction: AdapterBase;
-    /**
-     * Adapter is a wrapper on top of `postgres-js`, `node-postgres`, or other db driver.
-     *
-     * When in transaction, returns a db adapter object for the transaction,
-     * returns a default adapter object otherwise.
-     *
-     * Treat the adapter as implementation detail and avoid accessing it directly.
-     */
-    $getAdapter(): AdapterBase;
-    /**
-     * Use `$query` to perform raw SQL queries.
-     *
-     * ```ts
-     * const value = 1;
-     *
-     * // it is safe to interpolate inside the backticks (``):
-     * const result = await db.$query<{ one: number }>`SELECT ${value}  one`;
-     * // data is inside `rows` array:
-     * result.rows[0].one;
-     * ```
-     *
-     * If the query is executing inside a transaction, it will use the transaction connection automatically.
-     *
-     * ```ts
-     * await db.transaction(async () => {
-     *   // both queries will execute in the same transaction
-     *   await db.$query`SELECT 1`;
-     *   await db.$query`SELECT 2`;
-     * });
-     * ```
-     *
-     * Alternatively, support a simple SQL string, with optional `values`:
-     *
-     * Note that the values is a simple array, and the SQL is referring to the values with `$1`, `$2` and so on.
-     *
-     * ```ts
-     * const value = 1;
-     *
-     * // it is NOT safe to interpolate inside a simple string, use `values` to pass the values.
-     * const result = await db.$query<{ one: number }>({
-     *   raw: 'SELECT $1 AS one',
-     *   values: [value],
-     * });
-     * // data is inside `rows` array:
-     * result.rows[0].one;
-     * ```
-     *
-     * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
-     */
-    $query: Db['query'];
-    /**
-     * The same as the {@link $query}, but returns an array of arrays instead of objects:
-     *
-     * ```ts
-     * const value = 1;
-     *
-     * // it is safe to interpolate inside the backticks (``):
-     * const result = await db.$queryArrays<[number]>`SELECT ${value} AS one`;
-     * // `rows` is an array of arrays:
-     * const row = result.rows[0];
-     * row[0]; // our value
-     * ```
-     *
-     * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
-     */
-    $queryArrays: Db['queryArrays'];
-    /**
-     * See {@link FromMethods.from}
-     */
-    $from<Arg extends MaybeArray<FromArg<Query>>>(arg: Arg): FromResult<FromQuery, Arg>;
-    /**
-     * `$withOptions` supports overriding `log`, `schema`, `role`, and `setConfig`.
-     *
-     * - `log`: boolean, enables or disables logging in the scope of the callback.
-     * - `schema`: set a **default** schema, note that it does not override
-     *   if you already have a schema set in the ORM config or for a specific table.
-     * - `role`: string, switches the Postgres role for the duration of the callback.
-     *   Used for row-level security policies.
-     * - `setConfig`: object with string, number, or boolean values, sets Postgres custom
-     *   settings for the duration of the callback. Use dotted names like `app.tenant_id`.
-     *   Values are normalized to strings internally.
-     *
-     * SQL session options (`role` and `setConfig`) cannot be nested.
-     * If an outer scope already has `role` or `setConfig`, attempting to set them again
-     * in a nested `$withOptions` call will throw an error.
-     * Nested scopes that only change `log` or `schema` will inherit the outer SQL session context.
-     *
-     * Explicit transactions inside the callback inherit the same SQL session context:
-     *
-     * ```ts
-     * await db.$withOptions(
-     *   {
-     *     role: 'app_user',
-     *     setConfig: {
-     *       'app.tenant_id': tenantId,
-     *       'app.user_id': userId,
-     *     },
-     *   },
-     *   async () => {
-     *     const project = await db.project.find(projectId);
-     *
-     *     await db.$transaction(async () => {
-     *       // This query runs in the transaction with the same role and config
-     *       await db.project.find(projectId).update({ lastViewedAt: new Date() });
-     *     });
-     *   },
-     * );
-     * ```
-     *
-     * Basic usage with `log` and `schema`:
-     *
-     * ```ts
-     * await db.$withOptions({ log: true, schema: 'custom' }, async () => {
-     *   // will log this query, and will use the custom schema for this table,
-     *   // unless this table already has a configured schema.
-     *   await db.table.find(123);
-     * });
-     * ```
-     */
-    $withOptions<Result>(options: StorageOptions, cb: () => Promise<Result>): Promise<Result>;
-    $close(): Promise<void>;
+  /**
+   * @see import('pqb').QueryTransaction.prototype.transaction
+   */
+  $transaction: typeof transaction;
+  /**
+   * @see import('pqb').QueryTransaction.prototype.ensureTransaction
+   */
+  $ensureTransaction: typeof ensureTransaction;
+  /**
+   * @see import('pqb').QueryTransaction.prototype.isInTransaction
+   */
+  $isInTransaction: typeof isInTransaction;
+  /**
+   * @see import('pqb').QueryTransaction.prototype.afterCommit
+   */
+  $afterCommit: typeof afterCommit;
+  $qb: Db;
+  $adapterNotInTransaction: Adapter;
+  /**
+   * Adapter is a wrapper on top of `postgres-js`, `node-postgres`, or other db driver.
+   *
+   * When in transaction, returns a db adapter object for the transaction,
+   * returns a default adapter object otherwise.
+   *
+   * Treat the adapter as implementation detail and avoid accessing it directly.
+   */
+  $getAdapter(): Adapter;
+  /**
+   * Use `$query` to perform raw SQL queries.
+   *
+   * ```ts
+   * const value = 1;
+   *
+   * // it is safe to interpolate inside the backticks (``):
+   * const result = await db.$query<{ one: number }>`SELECT ${value}  one`;
+   * // data is inside `rows` array:
+   * result.rows[0].one;
+   * ```
+   *
+   * If the query is executing inside a transaction, it will use the transaction connection automatically.
+   *
+   * ```ts
+   * await db.transaction(async () => {
+   *   // both queries will execute in the same transaction
+   *   await db.$query`SELECT 1`;
+   *   await db.$query`SELECT 2`;
+   * });
+   * ```
+   *
+   * Alternatively, support a simple SQL string, with optional `values`:
+   *
+   * Note that the values is a simple array, and the SQL is referring to the values with `$1`, `$2` and so on.
+   *
+   * ```ts
+   * const value = 1;
+   *
+   * // it is NOT safe to interpolate inside a simple string, use `values` to pass the values.
+   * const result = await db.$query<{ one: number }>({
+   *   raw: 'SELECT $1 AS one',
+   *   values: [value],
+   * });
+   * // data is inside `rows` array:
+   * result.rows[0].one;
+   * ```
+   *
+   * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
+   */
+  $query: Db['query'];
+  /**
+   * The same as the {@link $query}, but returns an array of arrays instead of objects:
+   *
+   * ```ts
+   * const value = 1;
+   *
+   * // it is safe to interpolate inside the backticks (``):
+   * const result = await db.$queryArrays<[number]>`SELECT ${value} AS one`;
+   * // `rows` is an array of arrays:
+   * const row = result.rows[0];
+   * row[0]; // our value
+   * ```
+   *
+   * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
+   */
+  $queryArrays: Db['queryArrays'];
+  /**
+   * See {@link FromMethods.from}
+   */
+  $from<Arg extends MaybeArray<FromArg<Query>>>(arg: Arg): FromResult<FromQuery, Arg>;
+  /**
+   * `$withOptions` supports overriding `log`, `schema`, `role`, and `setConfig`.
+   *
+   * - `log`: boolean, enables or disables logging in the scope of the callback.
+   * - `schema`: set a **default** schema, note that it does not override
+   *   if you already have a schema set in the ORM config or for a specific table.
+   * - `role`: string, switches the Postgres role for the duration of the callback.
+   *   Used for row-level security policies.
+   * - `setConfig`: object with string, number, or boolean values, sets Postgres custom
+   *   settings for the duration of the callback. Use dotted names like `app.tenant_id`.
+   *   Values are normalized to strings internally.
+   *
+   * SQL session options (`role` and `setConfig`) cannot be nested.
+   * If an outer scope already has `role` or `setConfig`, attempting to set them again
+   * in a nested `$withOptions` call will throw an error.
+   * Nested scopes that only change `log` or `schema` will inherit the outer SQL session context.
+   *
+   * Explicit transactions inside the callback inherit the same SQL session context:
+   *
+   * ```ts
+   * await db.$withOptions(
+   *   {
+   *     role: 'app_user',
+   *     setConfig: {
+   *       'app.tenant_id': tenantId,
+   *       'app.user_id': userId,
+   *     },
+   *   },
+   *   async () => {
+   *     const project = await db.project.find(projectId);
+   *
+   *     await db.$transaction(async () => {
+   *       // This query runs in the transaction with the same role and config
+   *       await db.project.find(projectId).update({ lastViewedAt: new Date() });
+   *     });
+   *   },
+   * );
+   * ```
+   *
+   * Basic usage with `log` and `schema`:
+   *
+   * ```ts
+   * await db.$withOptions({ log: true, schema: 'custom' }, async () => {
+   *   // will log this query, and will use the custom schema for this table,
+   *   // unless this table already has a configured schema.
+   *   await db.table.find(123);
+   * });
+   * ```
+   */
+  $withOptions<Result>(options: StorageOptions, cb: () => Promise<Result>): Promise<Result>;
+  $close(): Promise<void>;
 }
 type OrchidOrmParam<Options> = true | null extends true ? 'Set strict: true to tsconfig' : Options;
-declare const orchidORMWithAdapter: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, schema, ...options }: OrchidOrmParam<({
-    db: Query;
+declare const orchidORMWithAdapter: <T extends TableClasses>({
+  log,
+  logger,
+  autoPreparedStatements,
+  noPrimaryKey,
+  schema,
+  ...options
+}: OrchidOrmParam<({
+  db: Query;
 } | {
-    adapter: AdapterBase;
+  adapter: Adapter;
 }) & DbSharedOptions>, tables: T) => OrchidORM<T>;
-
 interface HasAndBelongsToMany extends RelationThunkBase {
-    type: 'hasAndBelongsToMany';
-    options: HasAndBelongsToManyOptions;
+  type: 'hasAndBelongsToMany';
+  options: HasAndBelongsToManyOptions;
 }
 interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
-    required?: boolean;
-    columns: (keyof Columns)[];
-    references: string[];
+  required?: boolean;
+  columns: (keyof Columns)[];
+  references: string[];
+  foreignKey?: boolean | TableData.References.Options;
+  through: {
+    schema?: QuerySchema;
+    table: string;
+    columns: string[];
+    references: (keyof Related['columns']['shape'])[];
     foreignKey?: boolean | TableData.References.Options;
-    through: {
-        schema?: QuerySchema;
-        table: string;
-        columns: string[];
-        references: (keyof Related['columns']['shape'])[];
-        foreignKey?: boolean | TableData.References.Options;
-    };
-    on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
+  };
+  on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
-type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = {
-    [Name in FK]: T['columns']['shape'][Name]['type'];
-};
-type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = {
-    [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
-} & QueryHasWhere & HasRelJoin;
+type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['type'] };
+type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere & HasRelJoin;
 interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Q extends Query> extends RelationConfigBase {
-    returnsOne: false;
-    query: Q;
-    params: HasAndBelongsToManyParams<T, FK>;
-    maybeSingle: Q;
-    omitForeignKeyInCreate: never;
-    optionalDataForCreate: {
-        [P in Name]?: {
-            create?: CreateData<Q>[];
-            connect?: WhereArg<Q>[];
-            connectOrCreate?: {
-                where: WhereArg<Q>;
-                create: CreateData<Q>;
-            }[];
-        };
+  returnsOne: false;
+  query: Q;
+  params: HasAndBelongsToManyParams<T, FK>;
+  maybeSingle: Q;
+  omitForeignKeyInCreate: never;
+  optionalDataForCreate: { [P in Name]?: {
+    create?: CreateData<Q>[];
+    connect?: WhereArg<Q>[];
+    connectOrCreate?: {
+      where: WhereArg<Q>;
+      create: CreateData<Q>;
+    }[];
+  } };
+  dataForCreate: never;
+  dataForUpdate: {
+    disconnect?: MaybeArray<WhereArg<Q>>;
+    set?: MaybeArray<WhereArg<Q>>;
+    add?: MaybeArray<WhereArg<Q>>;
+    delete?: MaybeArray<WhereArg<Q>>;
+    update?: {
+      where: MaybeArray<WhereArg<Q>>;
+      data: UpdateData<Q>;
     };
-    dataForCreate: never;
-    dataForUpdate: {
-        disconnect?: MaybeArray<WhereArg<Q>>;
-        set?: MaybeArray<WhereArg<Q>>;
-        add?: MaybeArray<WhereArg<Q>>;
-        delete?: MaybeArray<WhereArg<Q>>;
-        update?: {
-            where: MaybeArray<WhereArg<Q>>;
-            data: UpdateData<Q>;
-        };
-        create?: CreateData<Q>[];
-    };
-    dataForUpdateOne: {
-        disconnect?: MaybeArray<WhereArg<Q>>;
-        set?: MaybeArray<WhereArg<Q>>;
-        add?: MaybeArray<WhereArg<Q>>;
-        delete?: MaybeArray<WhereArg<Q>>;
-        update?: {
-            where: MaybeArray<WhereArg<Q>>;
-            data: UpdateData<Q>;
-        };
-        create?: CreateData<Q>[];
+    create?: CreateData<Q>[];
+  };
+  dataForUpdateOne: {
+    disconnect?: MaybeArray<WhereArg<Q>>;
+    set?: MaybeArray<WhereArg<Q>>;
+    add?: MaybeArray<WhereArg<Q>>;
+    delete?: MaybeArray<WhereArg<Q>>;
+    update?: {
+      where: MaybeArray<WhereArg<Q>>;
+      data: UpdateData<Q>;
     };
+    create?: CreateData<Q>[];
+  };
 }
-
 type RelationToOneDataForCreate<Rel extends {
-    nestedCreateQuery: unknown;
-    table: Query;
+  nestedCreateQuery: unknown;
+  table: Query;
 }> = {
-    create: Rel['nestedCreateQuery'];
-    connect?: never;
-    connectOrCreate?: never;
+  create: Rel['nestedCreateQuery'];
+  connect?: never;
+  connectOrCreate?: never;
 } | {
-    create?: never;
-    connect: WhereArg<Rel['table']>;
-    connectOrCreate?: never;
+  create?: never;
+  connect: WhereArg<Rel['table']>;
+  connectOrCreate?: never;
 } | {
-    create?: never;
-    connect?: never;
-    connectOrCreate: {
-        where: WhereArg<Rel['table']>;
-        create: Rel['nestedCreateQuery'];
-    };
+  create?: never;
+  connect?: never;
+  connectOrCreate: {
+    where: WhereArg<Rel['table']>;
+    create: Rel['nestedCreateQuery'];
+  };
 };
 type RelationToOneDataForCreateSameQuery<Q extends Query> = {
-    create: CreateData<Q>;
-    connect?: never;
-    connectOrCreate?: never;
+  create: CreateData<Q>;
+  connect?: never;
+  connectOrCreate?: never;
 } | {
-    create?: never;
-    connect: WhereArg<Q>;
-    connectOrCreate?: never;
+  create?: never;
+  connect: WhereArg<Q>;
+  connectOrCreate?: never;
 } | {
-    create?: never;
-    connect?: never;
-    connectOrCreate: {
-        where: WhereArg<Q>;
-        create: CreateData<Q>;
-    };
+  create?: never;
+  connect?: never;
+  connectOrCreate: {
+    where: WhereArg<Q>;
+    create: CreateData<Q>;
+  };
 };
 interface RelationThunkBase {
-    type: string;
-    related: ORMTableInput;
-    options: unknown;
+  type: string;
+  related: ORMTableInput;
+  options: unknown;
 }
 type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 interface RelationThunks {
-    [K: string]: RelationThunk;
+  [K: string]: RelationThunk;
 }
 type RelationTableToQuery<Relation> = Relation extends {
-    related: infer R extends ORMTableInput;
+  related: infer R extends ORMTableInput;
 } ? TableToDb<R> : never;
 interface RelationConfigSelf {
-    columns: {
-        shape: Column.Shape.QueryInit;
-    };
-    relations: RelationThunks;
+  columns: {
+    shape: Column.Shape.QueryInit;
+  };
+  relations: RelationThunks;
 }
 type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation['options']['columns'][number] & string> : Relation extends HasOne | HasMany ? HasOneParams<T, Relation['options']> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation['options']['columns'][number] & string> : never;
-
 interface TableClass<T extends ORMTableInput = ORMTableInput> {
-    new (): T;
+  new (): T;
 }
 interface TableClasses {
-    [K: string]: TableClass;
+  [K: string]: TableClass;
 }
 interface TableInfo {
-    definedAs: string;
-    db: OrchidORM;
-    getFilePath(): string;
-    name: string;
-}
-interface Table extends Query, TableInfo {
+  definedAs: string;
+  db: OrchidORM;
+  getFilePath(): string;
+  name: string;
 }
+interface Table extends Query, TableInfo {}
 interface TableToDb<T extends ORMTableInput> extends TableInfo, Db<T['table'], T['columns']['shape'], keyof ShapeColumnPrimaryKeys<T['columns']['shape']> extends never ? never : ShapeColumnPrimaryKeys<T['columns']['shape']>, ShapeUniqueColumns<T['columns']['shape']> | TableDataItemsUniqueColumns<T['columns']['shape'], T['columns']['data']>, TableDataItemsUniqueColumnTuples<T['columns']['shape'], T['columns']['data']>, UniqueConstraints<T['columns']['shape']> | TableDataItemsUniqueConstraints<T['columns']['data']>, T['types'], T['columns']['shape'] & ComputedColumnsFromOptions<T['computed']>, MapTableScopesOption<T>, ColumnsShape.DefaultSelectKeys<T['columns']['shape']>> {
-    relations: T extends RelationConfigSelf ? {
-        [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<RelationTableToQuery<T['relations'][K]>, K>> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>> : never;
-    } : EmptyObject;
+  relations: T extends RelationConfigSelf ? { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<RelationTableToQuery<T['relations'][K]>, K>> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>> : never } : EmptyObject;
 }
 interface ORMTableInput {
-    table: string;
-    columns: {
-        shape: Column.Shape.QueryInit;
-        data: MaybeArray<TableDataItem>;
-    };
-    schema?: QuerySchema;
-    types: unknown;
-    noPrimaryKey?: boolean;
-    filePath: string;
-    language?: string;
-    /**
-     * collect computed columns returned by {@link BaseTable.setColumns}
-     */
-    computed?: ComputedOptionsFactory<never, never>;
-    scopes?: RecordUnknown;
-    readonly softDelete?: true | string;
-    comment?: string;
-    autoForeignKeys?: TableData.References.BaseOptions | boolean;
+  table: string;
+  columns: {
+    shape: Column.Shape.QueryInit;
+    data: MaybeArray<TableDataItem>;
+  };
+  schema?: QuerySchema;
+  types: unknown;
+  noPrimaryKey?: boolean;
+  filePath: string;
+  language?: string;
+  /**
+   * collect computed columns returned by {@link BaseTable.setColumns}
+   */
+  computed?: ComputedOptionsFactory<never, never>;
+  scopes?: RecordUnknown;
+  readonly softDelete?: true | string;
+  comment?: string;
+  autoForeignKeys?: TableData.References.BaseOptions | boolean;
 }
-type Queryable<T extends ORMTableInput> = ShallowSimplify<{
-    [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'];
-}>;
+type Queryable<T extends ORMTableInput> = ShallowSimplify<{ [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'] }>;
 type DefaultSelect<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.DefaultOutput<T['columns']['shape']>>;
-type Selectable<T extends ORMTableInput> = T['computed'] extends ((t: never) => infer R extends ComputedOptionsConfig) ? ShallowSimplify<ColumnsShape.Output<T['columns']['shape']> & {
-    [K in keyof R]: R[K] extends QueryOrExpression<unknown> ? R[K]['result']['value']['outputType'] : R[K] extends () => {
-        result: {
-            value: infer Value extends Column.Pick.QueryColumn;
-        };
-    } ? Value['outputType'] : never;
-}> : ShallowSimplify<ColumnsShape.Output<T['columns']['shape']>>;
+type Selectable<T extends ORMTableInput> = T['computed'] extends ((t: never) => infer R extends ComputedOptionsConfig) ? ShallowSimplify<ColumnsShape.Output<T['columns']['shape']> & { [K in keyof R]: R[K] extends QueryOrExpression<unknown> ? R[K]['result']['value']['outputType'] : R[K] extends (() => {
+  result: {
+    value: infer Value extends Column.Pick.QueryColumn;
+  };
+}) ? Value['outputType'] : never }> : ShallowSimplify<ColumnsShape.Output<T['columns']['shape']>>;
 type Insertable<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.Input<T['columns']['shape']>>;
 type Updatable<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.InputPartial<T['columns']['shape']>>;
 type BeforeHookMethod = (cb: QueryBeforeHook) => void;
 type BeforeActionHookMethod = (cb: QueryBeforeActionHook) => void;
 type AfterHookMethod = (cb: QueryAfterHook) => void;
 type AfterSelectableHookMethod = <Shape extends Column.QueryColumns, S extends (keyof Shape)[]>(this: {
-    columns: {
-        shape: Shape;
-    };
+  columns: {
+    shape: Shape;
+  };
 }, select: S, cb: AfterHook<S, Shape>) => void;
 interface SetColumnsResult<Shape extends Column.Shape.QueryInit, Data extends MaybeArray<MaybeArray<TableDataItem>>> {
-    shape: Shape;
-    data: Data extends unknown[] ? Data : [Data];
+  shape: Shape;
+  data: Data extends unknown[] ? Data : [Data];
 }
 interface BaseTableInstance<ColumnTypes> {
-    table: string;
+  table: string;
+  columns: {
+    shape: Column.Shape.QueryInit;
+    data: MaybeArray<TableDataItem>;
+  };
+  schema?: QuerySchema;
+  noPrimaryKey?: boolean;
+  snakeCase?: boolean;
+  types: ColumnTypes;
+  q: QueryData;
+  language?: string;
+  filePath: string;
+  result: Column.Shape.QueryInit;
+  clone<T extends IsQuery>(this: T): T;
+  getFilePath(): string;
+  setColumns<Shape extends Column.Shape.QueryInit, Data extends MaybeArray<TableDataItem>>(fn: (t: ColumnTypes) => Shape, tableData?: TableDataFn<Shape, Data>): SetColumnsResult<Shape, Data>;
+  /**
+   * You can add a generated column in the migration (see [generated](/guide/migration-column-methods.html#generated-column)),
+   * such column will persist in the database, it can be indexed.
+   *
+   * Or you can add a computed column on the ORM level, without adding it to the database, in such a way:
+   *
+   * ```ts
+   * import { BaseTable, sql } from './baseTable';
+   *
+   * export class UserTable extends BaseTable {
+   *   readonly table = 'user';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     firstName: t.string(),
+   *     lastName: t.string(),
+   *   }));
+   *
+   *   computed = this.setComputed({
+   *     fullName: (q) =>
+   *       sql`${q.column('firstName')} || ' ' || ${q.column('lastName')}`.type(
+   *         (t) => t.string(),
+   *       ),
+   *   });
+   * }
+   * ```
+   *
+   * `setComputed` takes an object where keys are computed column names, and values are functions returning raw SQL.
+   *
+   * Use `q.column` as shown above to reference a table column, it will be prefixed with a correct table name even if the table is joined under a different name.
+   *
+   * Computed columns are not selected by default, only on demand:
+   *
+   * ```ts
+   * const a = await db.user.take();
+   * a.fullName; // not selected
+   *
+   * const b = await db.user.select('*', 'fullName');
+   * b.fullName; // selected
+   *
+   * // Table post belongs to user as an author.
+   * // it's possible to select joined computed column:
+   * const posts = await db.post
+   *   .join('author')
+   *   .select('post.title', 'author.fullName');
+   * ```
+   *
+   * SQL query can be generated dynamically based on the current request context.
+   *
+   * Imagine we are using [AsyncLocalStorage](https://nodejs.org/api/async_context.html#asynchronous-context-tracking)
+   * to keep track of current user's language.
+   *
+   * And we have articles translated to different languages, each article has `title_en`, `title_uk`, `title_be` and so on.
+   *
+   * We can define a computed `title` by passing a function into `sql` method:
+   *
+   * ```ts
+   * import { sql } from './baseTable';
+   *
+   * type Locale = 'en' | 'uk' | 'be';
+   * const asyncLanguageStorage = new AsyncLocalStorage<Locale>();
+   * const defaultLocale: Locale = 'en';
+   *
+   * export class ArticleTable extends BaseTable {
+   *   readonly table = 'article';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     title_en: t.text(),
+   *     title_uk: t.text().nullable(),
+   *     title_be: t.text().nullable(),
+   *   }));
+   *
+   *   computed = this.setComputed({
+   *     title: () =>
+   *       // `sql` accepts a callback to generate a new query on every run
+   *       sql(() => {
+   *         // get locale dynamically based on current storage value
+   *         const locale = asyncLanguageStorage.getStore() || defaultLocale;
+   *
+   *         // use COALESCE in case when localized title is NULL, use title_en
+   *         return sql`COALESCE(
+   *             ${q.column(`title_${locale}`)},
+   *             ${q.column(`title_${defaultLocale}`)}
+   *           )`;
+   *       }).type((t) => t.text()),
+   *   });
+   * }
+   * ```
+   *
+   * @param computed - object where keys are column names and values are functions returning raw SQL
+   */
+  setComputed<Shape extends Column.Shape.QueryInit, Computed extends ComputedOptionsFactory<ColumnTypes, Shape>>(this: {
     columns: {
-        shape: Column.Shape.QueryInit;
-        data: MaybeArray<TableDataItem>;
+      shape: Shape;
     };
-    schema?: QuerySchema;
-    noPrimaryKey?: boolean;
-    snakeCase?: boolean;
-    types: ColumnTypes;
-    q: QueryData;
-    language?: string;
-    filePath: string;
-    result: Column.Shape.QueryInit;
-    clone<T extends IsQuery>(this: T): T;
-    getFilePath(): string;
-    setColumns<Shape extends Column.Shape.QueryInit, Data extends MaybeArray<TableDataItem>>(fn: (t: ColumnTypes) => Shape, tableData?: TableDataFn<Shape, Data>): SetColumnsResult<Shape, Data>;
-    /**
-     * You can add a generated column in the migration (see [generated](/guide/migration-column-methods.html#generated-column)),
-     * such column will persist in the database, it can be indexed.
-     *
-     * Or you can add a computed column on the ORM level, without adding it to the database, in such a way:
-     *
-     * ```ts
-     * import { BaseTable, sql } from './baseTable';
-     *
-     * export class UserTable extends BaseTable {
-     *   readonly table = 'user';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     firstName: t.string(),
-     *     lastName: t.string(),
-     *   }));
-     *
-     *   computed = this.setComputed({
-     *     fullName: (q) =>
-     *       sql`${q.column('firstName')} || ' ' || ${q.column('lastName')}`.type(
-     *         (t) => t.string(),
-     *       ),
-     *   });
-     * }
-     * ```
-     *
-     * `setComputed` takes an object where keys are computed column names, and values are functions returning raw SQL.
-     *
-     * Use `q.column` as shown above to reference a table column, it will be prefixed with a correct table name even if the table is joined under a different name.
-     *
-     * Computed columns are not selected by default, only on demand:
-     *
-     * ```ts
-     * const a = await db.user.take();
-     * a.fullName; // not selected
-     *
-     * const b = await db.user.select('*', 'fullName');
-     * b.fullName; // selected
-     *
-     * // Table post belongs to user as an author.
-     * // it's possible to select joined computed column:
-     * const posts = await db.post
-     *   .join('author')
-     *   .select('post.title', 'author.fullName');
-     * ```
-     *
-     * SQL query can be generated dynamically based on the current request context.
-     *
-     * Imagine we are using [AsyncLocalStorage](https://nodejs.org/api/async_context.html#asynchronous-context-tracking)
-     * to keep track of current user's language.
-     *
-     * And we have articles translated to different languages, each article has `title_en`, `title_uk`, `title_be` and so on.
-     *
-     * We can define a computed `title` by passing a function into `sql` method:
-     *
-     * ```ts
-     * import { sql } from './baseTable';
-     *
-     * type Locale = 'en' | 'uk' | 'be';
-     * const asyncLanguageStorage = new AsyncLocalStorage<Locale>();
-     * const defaultLocale: Locale = 'en';
-     *
-     * export class ArticleTable extends BaseTable {
-     *   readonly table = 'article';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     title_en: t.text(),
-     *     title_uk: t.text().nullable(),
-     *     title_be: t.text().nullable(),
-     *   }));
-     *
-     *   computed = this.setComputed({
-     *     title: () =>
-     *       // `sql` accepts a callback to generate a new query on every run
-     *       sql(() => {
-     *         // get locale dynamically based on current storage value
-     *         const locale = asyncLanguageStorage.getStore() || defaultLocale;
-     *
-     *         // use COALESCE in case when localized title is NULL, use title_en
-     *         return sql`COALESCE(
-     *             ${q.column(`title_${locale}`)},
-     *             ${q.column(`title_${defaultLocale}`)}
-     *           )`;
-     *       }).type((t) => t.text()),
-     *   });
-     * }
-     * ```
-     *
-     * @param computed - object where keys are column names and values are functions returning raw SQL
-     */
-    setComputed<Shape extends Column.Shape.QueryInit, Computed extends ComputedOptionsFactory<ColumnTypes, Shape>>(this: {
-        columns: {
-            shape: Shape;
-        };
-    }, computed: Computed): Computed;
-    /**
-     * See {@link ScopeMethods}
-     */
-    setScopes<Table extends string, Shape extends Column.Shape.QueryInit, Keys extends string>(this: {
-        table: Table;
-        columns: {
-            shape: Shape;
-        };
-    }, scopes: DbTableOptionScopes<Table, Shape, Keys>): QueryScopes<Keys>;
-    belongsTo<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends BelongsToOptions<Columns, Related>>(this: {
-        columns: {
-            shape: Columns;
-        };
-    }, fn: () => {
-        new (): Related;
-    }, options: Options): {
-        type: 'belongsTo';
-        related: Related;
-        options: Options;
+  }, computed: Computed): Computed;
+  /**
+   * See {@link ScopeMethods}
+   */
+  setScopes<Table extends string, Shape extends Column.Shape.QueryInit, Keys extends string>(this: {
+    table: Table;
+    columns: {
+      shape: Shape;
     };
-    hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
-        columns: {
-            shape: Columns;
-        };
-    }, fn: () => {
-        new (): Related;
-    }, options: Options): {
-        type: 'hasOne';
-        related: Related;
-        options: Options;
+  }, scopes: DbTableOptionScopes<Table, Shape, Keys>): QueryScopes<Keys>;
+  belongsTo<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends BelongsToOptions<Columns, Related>>(this: {
+    columns: {
+      shape: Columns;
     };
-    hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
-        columns: {
-            shape: Columns;
-        };
-    }, fn: () => {
-        new (): Related;
-    }, options: Options): {
-        type: 'hasMany';
-        related: Related;
-        options: Options;
+  }, fn: () => {
+    new (): Related;
+  }, options: Options): {
+    type: 'belongsTo';
+    related: Related;
+    options: Options;
+  };
+  hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+    columns: {
+      shape: Columns;
     };
-    hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
-        columns: {
-            shape: Columns;
-        };
-    }, fn: () => {
-        new (): Related;
-    }, options: Options): {
-        type: 'hasAndBelongsToMany';
-        related: Related;
-        options: Options;
+  }, fn: () => {
+    new (): Related;
+  }, options: Options): {
+    type: 'hasOne';
+    related: Related;
+    options: Options;
+  };
+  hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+    columns: {
+      shape: Columns;
     };
-    beforeQuery: BeforeHookMethod;
-    afterQuery: AfterHookMethod;
-    beforeCreate: BeforeActionHookMethod;
-    afterCreate: AfterSelectableHookMethod;
-    afterCreateCommit: AfterSelectableHookMethod;
-    beforeUpdate: BeforeActionHookMethod;
-    afterUpdate: AfterSelectableHookMethod;
-    afterUpdateCommit: AfterSelectableHookMethod;
-    beforeSave: BeforeActionHookMethod;
-    afterSave: AfterSelectableHookMethod;
-    afterSaveCommit: AfterSelectableHookMethod;
-    beforeDelete: BeforeHookMethod;
-    afterDelete: AfterSelectableHookMethod;
-    afterDeleteCommit: AfterSelectableHookMethod;
+  }, fn: () => {
+    new (): Related;
+  }, options: Options): {
+    type: 'hasMany';
+    related: Related;
+    options: Options;
+  };
+  hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
+    columns: {
+      shape: Columns;
+    };
+  }, fn: () => {
+    new (): Related;
+  }, options: Options): {
+    type: 'hasAndBelongsToMany';
+    related: Related;
+    options: Options;
+  };
+  beforeQuery: BeforeHookMethod;
+  afterQuery: AfterHookMethod;
+  beforeCreate: BeforeActionHookMethod;
+  afterCreate: AfterSelectableHookMethod;
+  afterCreateCommit: AfterSelectableHookMethod;
+  beforeUpdate: BeforeActionHookMethod;
+  afterUpdate: AfterSelectableHookMethod;
+  afterUpdateCommit: AfterSelectableHookMethod;
+  beforeSave: BeforeActionHookMethod;
+  afterSave: AfterSelectableHookMethod;
+  afterSaveCommit: AfterSelectableHookMethod;
+  beforeDelete: BeforeHookMethod;
+  afterDelete: AfterSelectableHookMethod;
+  afterDeleteCommit: AfterSelectableHookMethod;
 }
 interface BaseTableClass<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
-    nowSQL: string | undefined;
-    exportAs: string;
-    columnTypes: ColumnTypes;
-    getFilePath(): string;
-    sql: DbSqlMethod<ColumnTypes>;
-    new (): BaseTableInstance<ColumnTypes>;
-    instance(): BaseTableInstance<ColumnTypes>;
-    /**
-     * All column types for inserting.
-     */
-    inputSchema: SchemaConfig['inputSchema'];
-    /**
-     * All column types as returned from a database.
-     */
-    outputSchema: SchemaConfig['outputSchema'];
-    /**
-     * All column types for query methods such as `where`.
-     */
-    querySchema: SchemaConfig['querySchema'];
-    /**
-     * Primary key column(s) type for query methods such as `where`.
-     */
-    pkeySchema: SchemaConfig['pkeySchema'];
-    /**
-     * Column types for inserting, excluding primary keys.
-     * Equals to {@link inputSchema} without primary keys.
-     */
-    createSchema: SchemaConfig['createSchema'];
-    /**
-     * Column types for updating, excluding primary keys.
-     * Equals to partial {@link createSchema}.
-     */
-    updateSchema: SchemaConfig['updateSchema'];
+  nowSQL: string | undefined;
+  exportAs: string;
+  columnTypes: ColumnTypes;
+  getFilePath(): string;
+  sql: DbSqlMethod<ColumnTypes>;
+  new (): BaseTableInstance<ColumnTypes>;
+  instance(): BaseTableInstance<ColumnTypes>;
+  /**
+   * All column types for inserting.
+   */
+  inputSchema: SchemaConfig['inputSchema'];
+  /**
+   * All column types as returned from a database.
+   */
+  outputSchema: SchemaConfig['outputSchema'];
+  /**
+   * All column types for query methods such as `where`.
+   */
+  querySchema: SchemaConfig['querySchema'];
+  /**
+   * Primary key column(s) type for query methods such as `where`.
+   */
+  pkeySchema: SchemaConfig['pkeySchema'];
+  /**
+   * Column types for inserting, excluding primary keys.
+   * Equals to {@link inputSchema} without primary keys.
+   */
+  createSchema: SchemaConfig['createSchema'];
+  /**
+   * Column types for updating, excluding primary keys.
+   * Equals to partial {@link createSchema}.
+   */
+  updateSchema: SchemaConfig['updateSchema'];
 }
-declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ schemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, autoForeignKeys, }?: {
-    schemaConfig?: SchemaConfig;
-    columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
-    snakeCase?: boolean;
-    filePath?: string;
-    nowSQL?: string;
-    exportAs?: string;
-    language?: string;
-    autoForeignKeys?: boolean | TableData.References.BaseOptions;
+declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({
+  schemaConfig,
+  columnTypes: columnTypesArg,
+  snakeCase,
+  filePath: filePathArg,
+  nowSQL,
+  exportAs,
+  language,
+  autoForeignKeys
+}?: {
+  schemaConfig?: SchemaConfig;
+  columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
+  snakeCase?: boolean;
+  filePath?: string;
+  nowSQL?: string;
+  exportAs?: string;
+  language?: string;
+  autoForeignKeys?: boolean | TableData.References.BaseOptions;
 }): BaseTableClass<SchemaConfig, ColumnTypes>;
-
 type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
-type QueryOne<T extends Query> = {
-    [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all' | undefined> : T[K];
-};
+type QueryOne<T extends Query> = { [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all' | undefined> : T[K] };
 interface MethodsBase<T extends Query> {
-    queryMethods?: QueryMethods<T>;
-    queryOneMethods?: QueryMethods<QueryOne<T>>;
-    queryWithWhereMethods?: QueryMethods<T & QueryHasWhere>;
-    queryOneWithWhereMethods?: QueryMethods<QueryOne<T & QueryHasWhere>>;
-    methods?: RecordUnknown;
+  queryMethods?: QueryMethods<T>;
+  queryOneMethods?: QueryMethods<QueryOne<T>>;
+  queryWithWhereMethods?: QueryMethods<T & QueryHasWhere>;
+  queryOneWithWhereMethods?: QueryMethods<QueryOne<T & QueryHasWhere>>;
+  methods?: RecordUnknown;
 }
-type MapQueryMethods<BaseQuery extends Query, Method> = Method extends (q: any, ...args: infer Args) => infer Result ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
-type MapMethods<T extends Query, Methods extends MethodsBase<T>> = {
-    [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<Query & QueryHasWhere>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<Query & QueryHasWhere, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never;
-};
+type MapQueryMethods<BaseQuery extends Query, Method> = Method extends ((q: any, ...args: infer Args) => infer Result) ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
+type MapMethods<T extends Query, Methods extends MethodsBase<T>> = { [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<Query & QueryHasWhere>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<Query & QueryHasWhere, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never };
 type Repo<T extends Query, Methods extends MethodsBase<T>> = T & MapMethods<T, Methods>;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<(<Q extends {
-    table: T["table"];
-    shape: T["shape"];
+  table: T["table"];
+  shape: T["shape"];
 }>(q: Q) => Query & Q & MapMethods<T, Methods>) & T, Methods>;
-
-export { createBaseTable, createRepo, orchidORMWithAdapter };
-export type { BaseTableClass, BaseTableInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidOrmParam, Queryable, Repo, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableInfo, TableToDb, Updatable };
+export { BaseTableClass, BaseTableInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidOrmParam, Queryable, Repo, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableInfo, TableToDb, Updatable, createBaseTable, createRepo, orchidORMWithAdapter };