pqb 0.57.6 → 0.58.0

package/dist/postgres-js.d.ts

@@ -1,1082 +1,10 @@
 import * as pqb from 'pqb';
-import { DbOptions, DefaultSchemaConfig, DefaultColumnTypes, DbResult } from 'pqb';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import postgres, { Error as Error$1 } from 'postgres';
-
-type MaybePromise<T> = T | Promise<T>;
-interface FnUnknownToUnknown {
-    (a: unknown): unknown;
-}
-interface RecordKeyTrue {
-    [K: string]: true;
-}
-interface RecordString {
-    [K: string]: string;
-}
-interface RecordUnknown {
-    [K: string]: unknown;
-}
-type EmptyObject = {};
-
-type ExpressionChain = (OperatorToSQL<unknown, unknown> | unknown)[];
-interface ExpressionData {
-    chain?: ExpressionChain;
-    expr?: Expression;
-}
-declare abstract class Expression<T extends QueryColumn = QueryColumn> {
-    abstract result: {
-        value: T;
-    };
-    abstract q: ExpressionData;
-    meta: {
-        kind: 'select';
-    };
-    toSQL(ctx: {
-        values: unknown[];
-    }, quotedAs?: string): string;
-    abstract makeSQL(ctx: {
-        values: unknown[];
-    }, quotedAs?: string): string;
-}
-type TemplateLiteralArgs = [
-    strings: TemplateStringsArray,
-    ...values: unknown[]
-];
-type RawSQLValues = RecordUnknown;
-declare abstract class ExpressionTypeMethod {
-    type<T extends {
-        q: {
-            expr?: Expression;
-        };
-        columnTypes: unknown;
-    }, C extends QueryColumn>(this: T, fn: (types: T['columnTypes']) => C): // Omit is optimal
-    Omit<T, 'result'> & {
-        result: {
-            value: C;
-        };
-    };
-}
-interface RawSQLBase<T extends QueryColumn = QueryColumn, ColumnTypes = unknown> extends Expression<T>, ExpressionTypeMethod {
-}
-declare abstract class RawSQLBase<T extends QueryColumn = QueryColumn, ColumnTypes = unknown> extends Expression<T> {
-    _sql: string | TemplateLiteralArgs;
-    _values?: RecordUnknown | undefined;
-    result: {
-        value: T;
-    };
-    q: ExpressionData;
-    abstract columnTypes: ColumnTypes;
-    abstract makeSQL(ctx: {
-        values: unknown[];
-    }): string;
-    constructor(_sql: string | TemplateLiteralArgs, _values?: RecordUnknown | undefined);
-    values<Self extends RawSQLBase>(this: Self, values: RawSQLValues): Self;
-    toCode(t: string): string;
-}
-
-interface OperatorBase<Value> {
-    (this: any, arg: Value): any;
-    _opType: Value;
-}
-/**
- * Function to turn the operator expression into SQL.
- *
- * @param key - SQL of the target to apply operator for, can be a quoted column name or an SQL expression wrapped with parens.
- * @param args - arguments of operator function.
- * @param ctx - context object for SQL conversions, for collecting query variables.
- * @param quotedAs - quoted table name.
- */
-interface OperatorToSQL<Value, Ctx> {
-    (key: string, args: [Value], ctx: Ctx, quotedAs?: string): string;
-}
-
-interface ColumnSchemaGetterTableClass {
-    prototype: {
-        columns: {
-            shape: ColumnTypesBase;
-        };
-    };
-    inputSchema(): unknown;
-    querySchema(): unknown;
-    pkeySchema(): unknown;
-    createSchema(): unknown;
-}
-interface ColumnTypeSchemaArg {
-    type: unknown;
-    nullable<T extends ColumnTypeBase>(this: T): NullableColumn<T, unknown, unknown, unknown>;
-    encode: unknown;
-    parse: unknown;
-    parseNull: unknown;
-    asType: unknown;
-    narrowType: unknown;
-    narrowAllTypes: unknown;
-    error?: unknown;
-}
-interface ColumnSchemaConfig<T extends ColumnTypeBase = ColumnTypeBase> extends ColumnTypeSchemaArg {
-    dateAsNumber: unknown;
-    dateAsDate: unknown;
-    enum: unknown;
-    array: unknown;
-    boolean(): unknown;
-    buffer(): unknown;
-    unknown(): unknown;
-    never(): unknown;
-    stringSchema(): unknown;
-    stringMin(max: number): unknown;
-    stringMax(max: number): unknown;
-    stringMinMax(min: number, max: number): unknown;
-    number(): unknown;
-    int(): unknown;
-    stringNumberDate(): unknown;
-    timeInterval(): unknown;
-    bit(max?: number): unknown;
-    uuid(): unknown;
-    json(): T;
-    inputSchema(this: ColumnSchemaGetterTableClass): unknown;
-    outputSchema(this: ColumnSchemaGetterTableClass): unknown;
-    querySchema(this: ColumnSchemaGetterTableClass): unknown;
-    createSchema(this: ColumnSchemaGetterTableClass): unknown;
-    updateSchema(this: ColumnSchemaGetterTableClass): unknown;
-    pkeySchema(this: ColumnSchemaGetterTableClass): unknown;
-    smallint(): T;
-    integer(): T;
-    real(): T;
-    smallSerial(): T;
-    serial(): T;
-    bigint(): T;
-    decimal(precision?: number, scale?: number): T;
-    doublePrecision(): T;
-    bigSerial(): T;
-    money(): T;
-    varchar(limit?: number): T;
-    text(): T;
-    string(limit?: number): T;
-    citext(): T;
-    date(): T;
-    timestampNoTZ(precision?: number): T;
-    timestamp(precision?: number): T;
-    geographyPointSchema(): unknown;
-}
-
-interface PickQueryShape {
-    shape: QueryColumns;
-}
-interface PickQueryInputType {
-    inputType: unknown;
-}
-
-declare class QueryHookUtils<T extends PickQueryInputType> {
-    query: IsQuery;
-    columns: string[];
-    private key;
-    constructor(query: IsQuery, columns: string[], key: 'hookCreateSet' | 'hookUpdateSet');
-    set: (data: { [K in keyof T["inputType"]]?: T["inputType"][K] | (() => QueryOrExpression<T["inputType"][K]>) | undefined; }) => void;
-}
-
-interface ColumnsShapeBase {
-    [K: string]: ColumnTypeBase;
-}
-type NullableColumn<T extends ColumnTypeBase, InputSchema, OutputSchema, QuerySchema> = {
-    [K in keyof T]: K extends 'type' ? T['type'] | null : K extends 'inputType' ? T['inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends 'outputType' ? T['outputType'] | (unknown extends T['nullType'] ? null : T['nullType']) : K extends 'outputSchema' ? OutputSchema : K extends 'queryType' ? T['queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? // `Omit` here is faster than ternaries
-    Omit<T['operators'], 'equals' | 'not'> & OperatorsNullable<T['queryType']> : T[K];
-};
-interface DataNullable {
-    isNullable: true;
-    optional: true;
-}
-interface OperatorsNullable<T> {
-    equals: OperatorBase<T | null>;
-    not: OperatorBase<T | null>;
-}
-interface PickColumnBaseData {
-    data: ColumnDataBase;
-}
-type ColumnWithDefault<T extends PickColumnBaseData, Value> = {
-    [K in keyof T]: K extends 'data' ? {
-        [K in keyof T['data']]: K extends 'default' ? Value extends null ? never : Value : K extends 'optional' ? true : T['data'][K];
-    } : T[K];
-};
-type ColumnDefaultSelect<T extends PickColumnBaseData, Value extends boolean> = {
-    [K in keyof T]: K extends 'data' ? {
-        [K in keyof T['data']]: K extends 'explicitSelect' ? Value extends true ? false : true : T['data'][K];
-    } : T[K];
-};
-interface ColumnDataAppReadOnly {
-    data: {
-        appReadOnly: true;
-    };
-}
-type ColumnTypesBase = {
-    [K in string]: ColumnTypeBase;
-};
-interface ColumnDataBase {
-    key: string;
-    name?: string;
-    optional: true | undefined;
-    isNullable?: true;
-    primaryKey?: string;
-    default: unknown;
-    defaultDefault: unknown;
-    runtimeDefault?(): unknown;
-    explicitSelect?: boolean;
-    as?: ColumnTypeBase;
-    unique?: string;
-    modifyQuery?(q: QueryBaseCommon, column: ColumnTypeBase): void;
-    checks?: ColumnDataCheckBase[];
-    isOfCustomType?: boolean;
-    errors?: RecordString;
-    defaultTimestamp?: 'createdAt' | 'updatedAt';
-    alias?: string;
-    extension?: string;
-    encode?(input: any): unknown;
-    parse?(input: any): unknown;
-    parseItem?(input: string): unknown;
-    parseNull?(): unknown;
-    jsonCast?: string;
-    readOnly?: boolean;
-    appReadOnly: true | undefined;
-    setOnCreate?(arg: QueryHookUtils<PickQueryInputType>): unknown;
-    setOnUpdate?(arg: QueryHookUtils<PickQueryInputType>): unknown;
-    setOnSave?(arg: QueryHookUtils<PickQueryInputType>): unknown;
-    typmod?: number;
-    virtual?: true;
-}
-interface ColumnDataCheckBase {
-    sql: RawSQLBase;
-    name?: string;
-}
-interface QueryColumn<T = unknown, Op = any> {
-    dataType: string;
-    type: T;
-    outputType: T;
-    queryType: T;
-    operators: Op;
-}
-interface QueryColumns {
-    [K: string]: QueryColumn;
-}
-interface QueryColumnData {
-    explicitSelect?: boolean;
-    primaryKey?: string;
-    unique?: string;
-    optional?: true;
-    isNullable?: true;
-    default?: unknown;
-    name?: string;
-    readOnly?: boolean;
-    appReadOnly: true | undefined;
-}
-interface QueryColumnInit extends QueryColumn {
-    inputType: unknown;
-    data: QueryColumnData;
-}
-interface QueryColumnsInit {
-    [K: string]: QueryColumnInit;
-}
-interface ColumnToCodeCtx {
-    t: string;
-    table: string;
-    currentSchema: string;
-    migration?: boolean;
-    snakeCase?: boolean;
-}
-declare abstract class ColumnTypeBase<Schema extends ColumnTypeSchemaArg = ColumnTypeSchemaArg, Type = unknown, InputSchema = any, Ops = any, InputType = Type, OutputType = Type, OutputSchema = InputSchema, QueryType = InputType, QuerySchema = InputSchema, Data extends ColumnDataBase = ColumnDataBase> {
-    inputSchema: InputSchema;
-    outputSchema: OutputSchema;
-    querySchema: QuerySchema;
-    abstract dataType: string;
-    abstract operators: Ops;
-    abstract toCode(ctx: ColumnToCodeCtx, key: string): Code;
-    abstract toSQL(): string;
-    type: Type;
-    inputType: InputType;
-    outputType: OutputType;
-    queryType: QueryType;
-    nullType: unknown;
-    nullSchema: unknown;
-    isNullable: boolean;
-    data: Data;
-    error: Schema['error'];
-    _parse?: (input: unknown) => unknown;
-    constructor(schema: ColumnTypeSchemaArg, inputSchema: InputSchema, outputSchema?: OutputSchema, querySchema?: QuerySchema);
-    /**
-     * Set a default value to a column. Columns that have defaults become optional when creating a record.
-     *
-     * If you provide a value or a raw SQL, such default should be set on the column in migration to be applied on a database level.
-     *
-     * Or you can specify a callback that returns a value. This function will be called for each creating record. Such a default won't be applied to a database.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     // values as defaults:
-     *     int: t.integer().default(123),
-     *     text: t.text().default('text'),
-     *
-     *     // raw SQL default:
-     *     timestamp: t.timestamp().default(t.sql`now()`),
-     *
-     *     // runtime default, each new records gets a new random value:
-     *     random: t.numeric().default(() => Math.random()),
-     *   }));
-     * }
-     * ```
-     *
-     * @param value - default value or a function returning a value
-     */
-    default<T extends Pick<ColumnTypeBase, 'type' | 'inputType' | 'data'>, Value extends T['inputType'] | null | RawSQLBase | (() => T['inputType'])>(this: T, value: Value): ColumnWithDefault<T, Value>;
-    /**
-     * Use `hasDefault` to let the column be omitted when creating records.
-     *
-     * It's better to use {@link default} instead so the value is explicit and serves as a hint.
-     */
-    hasDefault<T extends PickColumnBaseData>(this: T): ColumnWithDefault<T, RawSQLBase>;
-    /**
-     * Set a database-level validation check to a column. `check` accepts a raw SQL.
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.createTable('table', (t) => ({
-     *     // validate rank to be from 1 to 10
-     *     rank: t.integer().check(t.sql`1 >= "rank" AND "rank" <= 10`),
-     *     // constraint name can be passed as a second argument
-     *     column: t.integer().check(t.sql`...`, 'check_name'),
-     *     // a single column can have multiple checks
-     *     multiChecksColumn: t
-     *       .integer()
-     *       .check(t.sql`...`)
-     *       .check(t.sql`...`, 'optional_name'),
-     *   }));
-     * });
-     * ```
-     *
-     * @param sql - raw SQL expression
-     * @param name - to specify a constraint name
-     */
-    check<T extends PickColumnBaseData>(this: T, sql: RawSQLBase, name?: string): T;
-    /**
-     * Use `nullable` to mark the column as nullable. By default, all columns are required.
-     *
-     * Nullable columns are optional when creating records.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     name: t.integer().nullable(),
-     *   }));
-     * }
-     * ```
-     */
-    nullable: Schema['nullable'];
-    /**
-     * Set a custom function to process value for the column when creating or updating a record.
-     *
-     * The type of `input` argument will be used as the type of the column when creating and updating.
-     *
-     * If you have a validation library [installed and configured](/guide/columns-validation-methods.html),
-     * first argument is a schema to validate the input.
-     *
-     * ```ts
-     * import { z } from 'zod';
-     *
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     // encode boolean, number, or string to text before saving
-     *     column: t
-     *       .string()
-     *       // when having validation library, the first argument is a validation schema
-     *       .encode(
-     *         z.boolean().or(z.number()).or(z.string()),
-     *         (input: boolean | number | string) => String(input),
-     *       )
-     *       // no schema argument otherwise
-     *       .encode((input: boolean | number | string) => String(input)),
-     *   }));
-     * }
-     *
-     * // numbers and booleans will be converted to a string:
-     * await db.table.create({ column: 123 });
-     * await db.table.create({ column: true });
-     * await db.table.where({ column: 'true' }).update({ column: false });
-     * ```
-     *
-     * @param fn - function to encode value for a database, argument type is specified by you, return type must be compatible with a database
-     */
-    encode: Schema['encode'];
-    /**
-     * Set a custom function to process value after loading it from a database.
-     *
-     * The type of input is the type of column before `.parse`, the resulting type will replace the type of column.
-     *
-     * If you have a validation library [installed and configured](/guide/columns-validation-methods.html),
-     * first argument is a schema for validating the output.
-     *
-     * For handling `null` values use {@link parseNull} instead or in addition.
-     *
-     * ```ts
-     * import { z } from 'zod';
-     * import { number, integer } from 'valibot';
-     *
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     columnZod: t
-     *       .string()
-     *       // when having validation library, the first argument is a schema
-     *       .parse(z.number().int(), (input) => parseInt(input))
-     *       // no schema argument otherwise
-     *       .parse((input) => parseInt(input)),
-     *
-     *     columnValibot: t
-     *       .string()
-     *       .parse(number([integer()]), (input) => parseInt(input))
-     *       .parse((input) => parseInt(input)),
-     *   }));
-     * }
-     *
-     * // column will be parsed to a number
-     * const value: number = await db.table.get('column');
-     * ```
-     *
-     * @param fn - function to parse a value from the database, argument is the type of this column, return type is up to you
-     */
-    parse: Schema['parse'];
-    /**
-     * Use `parseNull` to specify runtime defaults at selection time.
-     *
-     * The `parseNull` function is only triggered for `nullable` columns.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     column: t
-     *       .integer()
-     *       .parse(String) // parse non-nulls to string
-     *       .parseNull(() => false), // replace nulls with false
-     *       .nullable(),
-     *   }));
-     * }
-     *
-     * const record = await db.table.take()
-     * record.column // can be a string or boolean, not null
-     * ```
-     *
-     * If you have a validation library [installed and configured](/guide/columns-validation-methods),
-     * first argument is a schema for validating the output.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     column: t
-     *       .integer()
-     *       .parse(z.string(), String) // parse non-nulls to string
-     *       .parseNull(z.literal(false), () => false), // replace nulls with false
-     *     .nullable(),
-     *   }));
-     * }
-     *
-     * const record = await db.table.take()
-     * record.column // can be a string or boolean, not null
-     *
-     * Table.outputSchema().parse({
-     *   column: false, // the schema expects strings or `false` literals, not nulls
-     * })
-     * ```
-     */
-    parseNull: Schema['parseNull'];
-    /**
-     * This method changes a column type without modifying its behavior.
-     * This is needed when converting columns to a validation schema, the converter will pick a different type specified by `.as`.
-     *
-     * Before calling `.as` need to use `.encode` with the input of the same type as the input of the target column,
-     * and `.parse` which returns the correct type.
-     *
-     * ```ts
-     * // column has the same type as t.integer()
-     * const column = t
-     *   .string()
-     *   .encode((input: number) => input)
-     *   .parse((text) => parseInt(text))
-     *   .as(t.integer());
-     * ```
-     *
-     * @param column - other column type to inherit from
-     */
-    as<T extends {
-        inputType: unknown;
-        outputType: unknown;
-        data: ColumnDataBase;
-    }, C extends Omit<ColumnTypeBase, 'inputType' | 'outputType'> & {
-        inputType: T['inputType'];
-        outputType: T['outputType'];
-    }>(this: T, column: C): C;
-    /**
-     * @deprecated use narrowType instead
-     */
-    asType: Schema['asType'];
-    /**
-     * `narrowType` narrows TypeScript types of a column. It sets input, output, query type altogether.
-     *
-     * For example, to narrow a `string` type to a union of string literals.
-     *
-     * When _not_ integrating with [validation libraries](/guide/columns-validation-methods), `narrowType` has the following syntax:
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     size: t.string().narrowType((t) => t<'small' | 'medium' | 'large'>()),
-     *   }));
-     * }
-     *
-     * // size will be typed as 'small' | 'medium' | 'large'
-     * const size = await db.table.get('size');
-     * ```
-     *
-     * - `input` is for `create`, `update` methods.
-     * - `output` is for the data that is loaded from a database and parsed if the column has `parse`.
-     * - `query` is used in `where` and other query methods, it should be compatible with the actual database column type.
-     *
-     * When integrating with a [validation library](/guide/columns-validation-methods), also provide validation schemas:
-     *
-     * ```ts
-     * const sizeSchema = z.union([
-     *   z.literal('small'),
-     *   z.literal('medium'),
-     *   z.literal('large'),
-     * ]);
-     *
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     size: t.text().narrowType(sizeSchema),
-     *   }));
-     * }
-     *
-     * // size will be typed as 'small' | 'medium' | 'large'
-     * const size = await db.table.get('size');
-     * ```
-     */
-    narrowType: Schema['narrowType'];
-    /**
-     * Allows to narrow different TypeScript types of a column granularly.
-     *
-     * Use it when the column's input is different from output.
-     *
-     * When _not_ integrating with [validation libraries](/guide/columns-validation-methods), `narrowAllTypes` has the following syntax:
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     size: t.string().narrowAllTypes((t) =>
-     *       t<{
-     *         // what types are accepted when creating/updating
-     *         input: 'small' | 'medium' | 'large';
-     *         // how types are retured from a database
-     *         output: 'small' | 'medium' | 'large';
-     *         // what types the column accepts in `where` and similar
-     *         query: 'small' | 'medium' | 'large';
-     *       }>(),
-     *     ),
-     *   }));
-     * }
-     *
-     * // size will be typed as 'small' | 'medium' | 'large'
-     * const size = await db.table.get('size');
-     * ```
-     *
-     * - `input` is for `create`, `update` methods.
-     * - `output` is for the data that is loaded from a database and parsed if the column has `parse`.
-     * - `query` is used in `where` and other query methods, it should be compatible with the actual database column type.
-     *
-     * When integrating with a [validation library](/guide/columns-validation-methods), also provide validation schemas:
-     *
-     * ```ts
-     * const sizeSchema = z.union([
-     *   z.literal('small'),
-     *   z.literal('medium'),
-     *   z.literal('large'),
-     * ]);
-     *
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     size: t.text().narrowAllTypes({
-     *       input: sizeSchema,
-     *       output: sizeSchema,
-     *       query: sizeSchema,
-     *     }),
-     *   }));
-     * }
-     *
-     * // size will be typed as 'small' | 'medium' | 'large'
-     * const size = await db.table.get('size');
-     * ```
-     */
-    narrowAllTypes: Schema['narrowAllTypes'];
-    input<T extends {
-        inputSchema: unknown;
-    }, InputSchema extends Schema['type']>(this: T, fn: (schema: T['inputSchema']) => InputSchema): {
-        [K in keyof T]: K extends 'inputSchema' ? InputSchema : T[K];
-    };
-    output<T extends {
-        outputSchema: unknown;
-    }, OutputSchema extends Schema['type']>(this: T, fn: (schema: T['outputSchema']) => OutputSchema): {
-        [K in keyof T]: K extends 'outputSchema' ? OutputSchema : T[K];
-    };
-    query<T extends {
-        querySchema: unknown;
-    }, QuerySchema extends Schema['type']>(this: T, fn: (schema: T['querySchema']) => QuerySchema): {
-        [K in keyof T]: K extends 'querySchema' ? QuerySchema : T[K];
-    };
-    /**
-     * Set a database column name.
-     *
-     * @param name - name of the column in database.
-     */
-    name<T extends PickColumnBaseData>(this: T, name: string): T;
-    /**
-     * Append `select(false)` to a column to exclude it from the default selection.
-     * It won't be selected with `selectAll` or `select('*')` as well.
-     *
-     * ```ts
-     * export class UserTable extends BaseTable {
-     *   readonly table = 'user';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     name: t.string(),
-     *     password: t.string().select(false),
-     *   }));
-     * }
-     *
-     * // only id and name are selected, without password
-     * const user = await db.user.find(123);
-     *
-     * // password is still omitted, even with the wildcard
-     * const same = await db.user.find(123).select('*');
-     *
-     * const comment = await db.comment.find(123).select({
-     *   // password is omitted in the sub-selects as well
-     *   author: (q) => q.author,
-     * });
-     *
-     * // password is omitted here as well
-     * const created = await db.user.create(userData);
-     * ```
-     *
-     * Such a column can only be selected explicitly.
-     *
-     * ```ts
-     * const userWithPassword = await db.user.find(123).select('*', 'password');
-     * ```
-     */
-    select<T extends PickColumnBaseData, Value extends boolean>(this: T, value: Value): ColumnDefaultSelect<T, Value>;
-    /**
-     * Forbid the column to be used in [create](/guide/create-update-delete.html#create-insert) and [update](/guide/create-update-delete.html#update) methods.
-     *
-     * `readOnly` column is still can be set from a [hook](http://localhost:5173/guide/hooks.html#set-values-before-create-or-update).
-     *
-     * `readOnly` column can be used together with a `default`.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     column: t.string().default(() => 'default value'),
-     *     another: t.string().readOnly(),
-     *   }));
-     *
-     *   init(orm: typeof db) {
-     *     this.beforeSave(({ set }) => {
-     *       set({ another: 'value' });
-     *     });
-     *   }
-     * }
-     *
-     * // later in the code
-     * db.table.create({ column: 'value' }); // TS error, runtime error
-     * ```
-     */
-    readOnly<T>(this: T): T & ColumnDataAppReadOnly;
-    /**
-     * Set a column value when creating a record.
-     * This works for [readOnly](#readonly) columns as well.
-     *
-     * If no value or undefined is returned, the hook won't have any effect.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     column: t.string().setOnCreate(() => 'value'),
-     *   }));
-     * }
-     * ```
-     */
-    setOnCreate<T extends QueryColumnInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
-    /**
-     * Set a column value when updating a record.
-     * This works for [readOnly](#readonly) columns as well.
-     *
-     * If no value or undefined is returned, the hook won't have any effect.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     column: t.string().setOnUpdate(() => 'value'),
-     *   }));
-     * }
-     * ```
-     */
-    setOnUpdate<T extends QueryColumnInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
-    /**
-     * Set a column value when creating or updating a record.
-     * This works for [readOnly](#readonly) columns as well.
-     *
-     * If no value or undefined is returned, the hook won't have any effect.
-     *
-     * ```ts
-     * export class Table extends BaseTable {
-     *   readonly table = 'table';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *     column: t.string().setOnSave(() => 'value'),
-     *   }));
-     * }
-     * ```
-     */
-    setOnSave<T extends QueryColumnInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
-}
-
-type Code = string | Codes;
-type Codes = Code[];
-
-type DelayedRelationSelect = {
-    query: QueryBase;
-    value?: {
-        [K: string]: IsQuery;
-    };
-};
-
-interface QueryInternalColumnNameToKey {
-    columnNameToKeyMap?: Map<string, string>;
-}
-
-interface PickQueryDataAliases {
-    aliases?: RecordString;
-}
-interface QueryDataAliases extends PickQueryDataAliases {
-    as?: string;
-    outerAliases?: RecordString;
-}
-
-interface HasCteHooks {
-    cteHooks?: CteHooks;
-}
-interface CteHooks {
-    hasSelect: boolean;
-    tableHooks: CteTableHooks;
-}
-interface CteTableHooks {
-    [K: string]: CteTableHook;
-}
-interface CteTableHook {
-    shape: ColumnsShapeBase;
-    tableHook: TableHook;
-}
-interface TableHook {
-    select?: HookSelect;
-    after?: ((data: unknown, query: any) => unknown | Promise<unknown>)[];
-    afterCommit?: ((data: unknown, query: any) => unknown | Promise<unknown>)[];
-}
-type HookSelect = Map<string, HookSelectValue>;
-interface HookSelectValue {
-    select: string | {
-        sql: string;
-    };
-    as?: string;
-    temp?: string;
-}
-interface HasTableHook {
-    tableHook?: TableHook;
-}
-interface HasHookSelect {
-    hookSelect?: HookSelect;
-}
-
-interface PickQueryDataParsers {
-    defaultParsers?: ColumnsParsers;
-    parsers?: ColumnsParsers;
-    batchParsers?: BatchParsers;
-}
-type ColumnParser = FnUnknownToUnknown;
-interface BatchParser {
-    path: string[];
-    fn: (path: string[], queryResult: {
-        rows: unknown[];
-    }) => MaybePromise<void>;
-}
-type ColumnsParsers = {
-    [K in string | getValueKey]?: ColumnParser;
-};
-type BatchParsers = BatchParser[];
-
-interface QueryDataBase extends QueryDataAliases, PickQueryDataParsers, HasHookSelect {
-    shape: QueryColumnsInit;
-    select?: unknown;
-}
-
-interface SqlCommonOptions extends HasTableHook, HasCteHooks {
-    delayedRelationSelect?: DelayedRelationSelect;
-}
-interface SingleSqlItem {
-    text: string;
-    values?: unknown[];
-}
-interface SingleSql extends SingleSqlItem, SqlCommonOptions {
-}
-interface QueryMetaBase<Scopes extends RecordKeyTrue = RecordKeyTrue> {
-    kind: string;
-    as?: string;
-    subQuery: boolean;
-    hasSelect?: true;
-    hasWhere?: true;
-    defaults: EmptyObject;
-    tsQuery?: string;
-    scopes: Scopes;
-    selectable: SelectableBase;
-    defaultSelect: PropertyKey;
-}
-interface QueryInternalTableDataPrimaryKey {
-    columns: string[];
-    name?: string;
-}
-interface QueryInternalTableDataBase {
-    primaryKey?: QueryInternalTableDataPrimaryKey;
-}
-interface QueryInternalBase extends QueryInternalColumnNameToKey {
-    runtimeDefaultColumns?: string[];
-    transactionStorage: AsyncLocalStorage<TransactionState>;
-    scopes?: RecordUnknown;
-    snakeCase?: boolean;
-    noPrimaryKey: boolean;
-    comment?: string;
-    primaryKeys?: string[];
-    tableData: QueryInternalTableDataBase;
-}
-interface IsQuery {
-    __isQuery: true;
-}
-interface QueryBase extends IsQuery {
-    internal: QueryInternalBase;
-    shape: QueryColumns;
-    q: QueryDataBase;
-    table?: string;
-}
-interface QueryBaseCommon<Scopes extends RecordKeyTrue = RecordKeyTrue> extends QueryBase {
-    meta: QueryMetaBase<Scopes>;
-}
-interface SelectableBase {
-    [K: PropertyKey]: {
-        as: string;
-        column: QueryColumn;
-    };
-}
-type getValueKey = typeof getValueKey;
-declare const getValueKey: unique symbol;
-interface QueryOrExpression<T> {
-    result: {
-        value: QueryColumn<T>;
-    };
-}
-
-interface QueryLogObject {
-    colors: boolean;
-    beforeQuery(sql: SingleSql): unknown;
-    afterQuery(sql: SingleSql, logData: unknown): void;
-    onError(error: Error, sql: SingleSql, logData: unknown): void;
-}
-
-declare class OrchidOrmInternalError extends Error {
-    #private;
-    data?: RecordUnknown | undefined;
-    constructor(query: QueryBase, message?: string, data?: RecordUnknown | undefined);
-    get query(): QueryBase;
-}
-type QueryErrorName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
-declare abstract class QueryError<T extends PickQueryShape = PickQueryShape> extends OrchidOrmInternalError {
-    message: string;
-    name: QueryErrorName;
-    stack: string | undefined;
-    code: string | undefined;
-    detail: string | undefined;
-    severity: string | undefined;
-    hint: string | undefined;
-    position: string | undefined;
-    internalPosition: string | undefined;
-    internalQuery: string | undefined;
-    where: string | undefined;
-    schema: string | undefined;
-    table: string | undefined;
-    column: string | undefined;
-    dataType: string | undefined;
-    constraint: string | undefined;
-    file: string | undefined;
-    line: string | undefined;
-    routine: string | undefined;
-    get isUnique(): boolean;
-    columnsCache?: {
-        [K in keyof T['shape']]?: true;
-    };
-    get columns(): { [K in keyof T["shape"]]?: true | undefined; };
-}
-
-/**
- * Generic result returning from query methods.
- */
-interface QueryResultRow {
-    [K: string]: any;
-}
-interface QueryResult<T extends QueryResultRow = any> {
-    rowCount: number;
-    rows: T[];
-    fields: {
-        name: string;
-    }[];
-}
-interface QueryArraysResult<R extends any[] = any[]> {
-    rowCount: number;
-    rows: R[];
-    fields: {
-        name: string;
-    }[];
-}
-interface AdapterConfigBase {
-    databaseURL?: string;
-    /**
-     * This option may be useful in CI when database container has started, CI starts performing next steps,
-     * migrations begin to apply though database may be not fully ready for connections yet.
-     *
-     * Set `connectRetry: true` for the default backoff strategy. It performs 10 attempts starting with 50ms delay and increases delay exponentially according to this formula:
-     *
-     * ```
-     * (factor, defaults to 1.5) ** (currentAttempt - 1) * (delay, defaults to 50)
-     * ```
-     *
-     * So the 2nd attempt will happen in 50ms from start, 3rd attempt in 125ms, 3rd in 237ms, and so on.
-     *
-     * You can customize max attempts to be made, `factor` multiplier and the starting delay by passing:
-     *
-     * ```ts
-     * const options = {
-     *   databaseURL: process.env.DATABASE_URL,
-     *   connectRetry: {
-     *     attempts: 15, // max attempts
-     *     strategy: {
-     *       delay: 100, // initial delay
-     *       factor: 2, // multiplier for the formula above
-     *     }
-     *   }
-     * };
-     *
-     * rakeDb(options, { ... });
-     * ```
-     *
-     * You can pass a custom function to `strategy` to customize delay behavior:
-     *
-     * ```ts
-     * import { setTimeout } from 'timers/promises';
-     *
-     * const options = {
-     *   databaseURL: process.env.DATABASE_URL,
-     *   connectRetry: {
-     *     attempts: 5,
-     *     stragegy(currentAttempt: number, maxAttempts: number) {
-     *       // linear: wait 100ms after 1st attempt, then 200m after 2nd, and so on.
-     *       return setTimeout(currentAttempt * 100);
-     *     },
-     *   },
-     * };
-     * ```
-     */
-    connectRetry?: AdapterConfigConnectRetryParam | true;
-}
-interface AdapterConfigConnectRetryParam {
-    attempts?: number;
-    strategy?: AdapterConfigConnectRetryStrategyParam | AdapterConfigConnectRetryStrategy;
-}
-interface AdapterConfigConnectRetryStrategyParam {
-    delay?: number;
-    factor?: number;
-}
-interface AdapterConfigConnectRetry {
-    attempts: number;
-    strategy: AdapterConfigConnectRetryStrategy;
-}
-interface AdapterConfigConnectRetryStrategy {
-    (attempt: number, attempts: number): Promise<void> | void;
-}
-interface AdapterBase {
-    connectRetryConfig?: AdapterConfigConnectRetry;
-    schema?: string;
-    errorClass: new (...args: any[]) => Error;
-    assignError(to: QueryError, from: Error): void;
-    reconfigure(params: {
-        database?: string;
-        user?: string;
-        password?: string;
-        schema?: string;
-    }): AdapterBase;
-    getDatabase(): string;
-    getUser(): string;
-    getSchema(): string | undefined;
-    getHost(): string;
-    connect?(): Promise<unknown>;
-    query<T extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[], catchingSavepoint?: string): Promise<QueryResult<T>>;
-    arrays<R extends any[] = any[]>(text: string, values?: unknown[], catchingSavepoint?: string): Promise<QueryArraysResult<R>>;
-    /**
-     * Run a transaction
-     *
-     * @param options - optional transaction parameters
-     * @param cb - callback will be called with a db client with a dedicated connection.
-     */
-    transaction<T>(options: string | undefined, cb: (adapter: AdapterBase) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
-}
-interface TransactionState {
-    adapter: AdapterBase;
-    transactionId: number;
-    afterCommit?: TransactionAfterCommitHook[];
-    log?: QueryLogObject;
-    testTransactionCount?: number;
-    catchI?: number;
-}
-/**
- * Element of `afterCommit` transaction array. See {@link TransactionState.afterCommit}.
- */
-type TransactionAfterCommitHook = unknown[] | QueryBaseCommon | AfterCommitHook[] | AfterCommitStandaloneHook;
-interface AfterCommitHook {
-    (data: unknown[], q: QueryBaseCommon): unknown | Promise<unknown>;
-}
-interface AfterCommitStandaloneHook {
-    (): unknown | Promise<unknown>;
-}
+import { ColumnSchemaConfig, DbOptions, DefaultSchemaConfig, DefaultColumnTypes, DbResult, AdapterConfigBase, AdapterBase, QueryResultRow, QueryResult, QueryArraysResult, QueryError } from 'pqb';
+import postgres, { Error } from 'postgres';
 
 interface CreatePostgresJsDbOptions<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> extends PostgresJsAdapterOptions, DbOptions<SchemaConfig, ColumnTypes> {
 }
-declare const createDb: <SchemaConfig extends ColumnSchemaConfig<pqb.ColumnTypeBase<pqb.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, pqb.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>(options: CreatePostgresJsDbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const createDb: <SchemaConfig extends ColumnSchemaConfig<pqb.Column.Pick.Data> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>(options: CreatePostgresJsDbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
 interface PostgresJsAdapterOptions extends postgres.Options<any>, AdapterConfigBase {
     databaseURL?: string;
     schema?: string;
@@ -1087,7 +15,9 @@ declare class PostgresJsAdapter implements AdapterBase {
     config: PostgresJsAdapterOptions;
     errorClass: typeof postgres.PostgresError;
     constructor(config: PostgresJsAdapterOptions);
+    private configure;
     private getURL;
+    updateConfig(config: PostgresJsAdapterOptions): Promise<void>;
     reconfigure(params: {
         database?: string;
         user?: string;
@@ -1098,17 +28,18 @@ declare class PostgresJsAdapter implements AdapterBase {
     getUser(): string;
     getSchema(): string | undefined;
     getHost(): string;
-    query<T extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[], catchingSavepoint?: string): Promise<QueryResult<T>>;
-    arrays<R extends any[] = any[]>(text: string, values?: unknown[], catchingSavepoint?: string): Promise<QueryArraysResult<R>>;
+    query<T extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[]): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(text: string, values?: unknown[]): Promise<QueryArraysResult<R>>;
     transaction<Result>(options: string | undefined, cb: (adapter: AdapterBase) => Promise<Result>): Promise<Result>;
     close(): Promise<void>;
-    assignError(to: QueryError, dbError: Error$1): void;
+    assignError(to: QueryError, dbError: Error): void;
 }
 declare class PostgresJsTransactionAdapter implements AdapterBase {
     adapter: PostgresJsAdapter;
     sql: postgres.Sql;
     errorClass: typeof postgres.PostgresError;
     constructor(adapter: PostgresJsAdapter, sql: postgres.Sql);
+    updateConfig(config: PostgresJsAdapterOptions): Promise<void>;
     reconfigure(params: {
         database?: string;
         user?: string;
@@ -1123,7 +54,7 @@ declare class PostgresJsTransactionAdapter implements AdapterBase {
     arrays<R extends any[] = any[]>(text: string, values?: unknown[], catchingSavepoint?: string): Promise<QueryArraysResult<R>>;
     transaction<Result>(_options: string | undefined, cb: (adapter: PostgresJsTransactionAdapter) => Promise<Result>): Promise<Result>;
     close(): Promise<void>;
-    assignError(to: QueryError, from: Error$1): void;
+    assignError(to: QueryError, from: Error): void;
 }
 
 export { type CreatePostgresJsDbOptions, PostgresJsAdapter, type PostgresJsAdapterOptions, PostgresJsTransactionAdapter, createDb };