pqb 0.57.0 → 0.57.2

package/dist/index.d.ts

@@ -1,8 +1,1792 @@
-import * as orchid_core from 'orchid-core';
-import { Expression, MaybeArray, QueryColumns, IsQuery, ColumnTypesBase, RecordUnknown, RelationConfigBase, TemplateLiteralArgs, QueryOrExpression, QueryColumn, EmptyObject, MaybePromise, FnUnknownToUnknown, RelationsBase, QueryMetaBase, QueryReturnType, RecordString, ColumnsShapeBase, ColumnsParsers, QueryHookUtils, PickQueryInputType, PickQueryTable, QueryResult, Sql, QueryDataBase, AdapterBase, HookSelect, BatchParsers, QueryLogObject, QueryLogger, QueryDataTransform, ExpressionChain, DelayedRelationSelect, QueryDataAliases, ColumnSchemaConfig, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, ExpressionData, StaticSQLArgs, SQLQueryArgs, PickQueryRelationsWithData, PickQueryTableMetaResult, PickQueryMetaShapeRelationsWithData, EmptyTuple, PickQueryMeta, WithDataItem, PickQueryMetaResultReturnType, QueryColumnToNullable, QueryThenByQuery, PickQueryMetaResultRelationsWithDataReturnType, AliasOrTable, PickQueryTableMetaResultShape, PickQueryTableMetaShape, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaColumnTypes, ColumnShapeInput, SelectableBase, PickQueryMetaShape, PickQueryMetaResultRelationsWindows, PickQueryMetaResultWindows, PickOutputTypeAndOperators, PickQueryResult, PickQueryResultColumnTypes, PickQueryColumnTypes, PickQueryShape, ValExpression, PickQueryMetaResultRelationsWindowsColumnTypes, PickOutputType, QueryThen, PickQueryMetaRelations, PickQueryRelations, PickQueryMetaRelationsResultReturnType, DateColumnData, ColumnToCodeCtx, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ColumnTypeBase, ParseColumn, ParseNullColumn, EncodeColumn, ColumnInputOutputQueryTypes, QueryResultRow, QueryColumnsInit, QueryLogOptions, DefaultSelectColumns, DefaultSelectOutput, QueryThenShallowSimplifyArr, QueryErrorName, QueryError, QueryCatch, TransactionState, QueryArraysResult, PickQueryMetaTable, QueryColumnOfDataType, AsQueryArg, SetQueryTableAlias, PickQueryUniqueProperties, RelationConfigDataForCreate, PickQueryMetaResult, PickQueryMetaTableShapeReturnTypeWithData, WithDataItems, PickQueryTableMetaResultInputType, UnionToIntersection, SingleSqlItem, OrchidOrmError, AfterCommitStandaloneHook, PickQueryMetaResultReturnTypeWithDataWindowsThen, getValueKey, PickQueryWithData, QueryMetaIsSubQuery, QueryThenByReturnType, PickQueryReturnType, PickQueryWithDataColumnTypes, PickQueryMetaWithDataColumnTypes, QueryReturnTypeAll, QueryReturnTypeOptional, QueryThenShallowSimplifyOptional, QueryThenShallowSimplify, PickQueryResultReturnType, PickQueryShapeResultReturnTypeSinglePrimaryKey, PickQueryResultReturnTypeUniqueColumns, PickQueryTableMetaResultReturnTypeWithDataWindowsThen, PickQueryMetaShapeRelationsReturnType, QueryInternalBase, QueryBase, IsQueries, PickType, RecordKeyTrue, ColumnShapeOutput, OperatorsNullable, PickQueryMetaReturnType, UniqueColumn, TimestampHelpers, ShallowSimplify, Codes, ColumnDataCheckBase } from 'orchid-core';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { QueryBuilder as QueryBuilder$1, QueryInternal as QueryInternal$1, QueryData as QueryData$1, UpsertThis as UpsertThis$1, UpsertResult as UpsertResult$1 } from 'pqb';
 import { inspect } from 'node:util';
-import { AsyncLocalStorage } from 'node:async_hooks';
+
+declare const colors: {
+    yellow: (s: string) => string;
+    green: (s: string) => string;
+    red: (s: string) => string;
+    blue: (s: string) => string;
+    bright: (s: string) => string;
+    blueBold: (s: string) => string;
+    yellowBold: (s: string) => string;
+    greenBold: (s: string) => string;
+    pale: (s: string) => string;
+};
+
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type MaybeArray<T> = T | T[];
+type MaybePromise<T> = T | Promise<T>;
+interface FnUnknownToUnknown {
+    (a: unknown): unknown;
+}
+interface RecordKeyTrue {
+    [K: string]: true;
+}
+interface RecordString {
+    [K: string]: string;
+}
+interface RecordOptionalString {
+    [K: string]: string | undefined;
+}
+interface RecordUnknown {
+    [K: string]: unknown;
+}
+interface RecordBoolean {
+    [K: string]: boolean;
+}
+type ShallowSimplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+/**
+ * Merge methods from multiple class into another class.
+ * @param derivedCtor - target class to merge methods into
+ * @param constructors - classes to merge methods from
+ */
+declare function applyMixins(derivedCtor: any, constructors: any[]): void;
+/**
+ * Join array of strings with '', ignoring empty strings, false, undefined.
+ * @param strings - array of strings, or false, or undefined
+ */
+declare const joinTruthy: (...strings: (string | false | undefined)[]) => string;
+/**
+ * When array is passed, it is returned as is, otherwise, returns a new array with the provided value.
+ * @param item - array or a value to turn into array
+ */
+declare const toArray: <T>(item: T) => T extends unknown[] ? T : [T];
+declare const noop: () => void;
+declare const returnArg: <T>(a: T) => T;
+type EmptyObject = {};
+declare const emptyObject: {};
+type EmptyTuple = [];
+declare const emptyArray: never[];
+/**
+ * Push a value into an array in the object if it's defined, or set a new array with a single value into the object.
+ * Does not mutate the array.
+ *
+ * @param obj - object that can contain the array by the key
+ * @param key - key to access an array in the object
+ * @param value - value to push into the array
+ */
+declare const pushOrNewArrayToObjectImmutable: (obj: object, key: string | number, value: unknown) => void;
+/**
+ * Set value into the object in data, create the object if it doesn't yet exist.
+ * Does not mutate the object.
+ *
+ * @param q - object
+ * @param object - query data key to get the object
+ * @param key - object key to set the value into
+ * @param value - value to set by the key
+ */
+declare const setObjectValueImmutable: <T>(q: T, object: string, key: PropertyKey, value: unknown) => T;
+declare const spreadObjectValues: (q: object, object: string, value: RecordUnknown) => void;
+/**
+ * Push value into an array if it's defined, or return a new array with a single value.
+ * @param arr - array to push into, or `undefined`
+ * @param value - value to push into the array
+ */
+declare const pushOrNewArray: <Arr extends unknown[]>(arr: Arr | undefined, value: Arr[number]) => Arr;
+/**
+ * For code generation: quote a string with a single quote, escape characters.
+ * @param s - string to quote
+ */
+declare const singleQuote: (s: string) => string;
+/**
+ * For code generation: quote string with a backtick, escape characters.
+ * @param s - string to quote
+ */
+declare const backtickQuote: (s: string) => string;
+/**
+ * For code generation: stringify array of strings using a single quote.
+ * @param arr
+ */
+declare const singleQuoteArray: (arr: string[]) => string;
+/**
+ * For code generation: some strings must be quoted when used as an object key.
+ * This function quotes the strings when needed.
+ * @param key - object key to quote
+ * @param toCamel - change to camel case
+ */
+declare const quoteObjectKey: (key: string, toCamel: boolean | undefined) => string;
+/**
+ * Check if the object has no values that are not `undefined`.
+ * @param obj
+ */
+declare const isObjectEmpty: (obj: object) => boolean;
+/**
+ * Check if the object has at least one value that is not `undefined`.
+ * Nulls counts.
+ * @param obj - any object
+ */
+declare const objectHasValues: (obj?: object) => boolean;
+/**
+ * If we simply log file path as it is, it may be not clickable in the terminal.
+ * On Windows, it is clickable as it is, so it is returned as is.
+ * On Linux (at least in my JetBrains editor terminal) it's transformed to URL format to be clickable.
+ * @param path - file path
+ */
+declare const pathToLog: (path: string) => string;
+/**
+ * Translate a string to camelCase
+ * @param str - string to translate
+ */
+declare const toCamelCase: (str: string) => string;
+/**
+ * Translate a string to a PascalCase
+ * @param str - string to translate
+ */
+declare const toPascalCase: (str: string) => string;
+/**
+ * Translate a string to a snake_case.
+ * @param str - string to translate
+ */
+declare const toSnakeCase: (str: string) => string;
+/**
+ * Compare two values deeply.
+ * undefined and empty object are considered to be equal.
+ * @param a - any value
+ * @param b - any value
+ */
+declare const deepCompare: (a: unknown, b: unknown) => boolean;
+/**
+ * Returns a relative path to use as an `import` source to import one file from another.
+ * @param from - TS file where we want to place the `import`
+ * @param to - TS file that we're importing
+ */
+declare const getImportPath: (from: string, to: string) => string;
+/**
+ * Get stack trace to collect info about who called the function
+ */
+declare const getStackTrace: () => NodeJS.CallSite[] | undefined;
+/**
+ * Get a file path of the function which called the function which called this `getCallerFilePath`.
+ * Determines file path by error stack trace, skips any paths that are located in `node_modules`.
+ * @param stack - optionally provide an existing stack trace
+ */
+declare const getCallerFilePath: (stack?: NodeJS.CallSite[] | undefined) => string | undefined;
+/**
+ * Call function passing `this` as an argument,
+ * micro-optimization for `map` and `forEach` to not define temporary inline function
+ * ```ts
+ * arrayOfFns.map(callWithThis, argument)
+ * ```
+ * @param cb
+ */
+declare const callWithThis: <T, R>(this: T, cb: (arg: T) => R) => R;
+declare const pick: <T, Keys extends keyof T>(obj: T, keys: Keys[]) => Pick<T, Keys>;
+declare const omit: <T, Keys extends keyof T>(obj: T, keys: Keys[]) => Omit<T, Keys>;
+declare const addValue: (values: unknown[], value: unknown) => string;
+declare const getFreeAlias: (obj: RecordUnknown | undefined, as: string) => string;
+declare const getFreeSetAlias: (set: Set<string>, as: string, start?: number) => string;
+declare const exhaustive: (_: never) => never;
+declare const pluralize: (w: string, count: number, append?: string) => string;
+declare const isIterable: (x: unknown) => x is Iterable<unknown>;
+
+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;
+}
+declare const isExpression: (arg: unknown) => arg is Expression<QueryColumn<unknown, any>>;
+type TemplateLiteralArgs = [
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+];
+declare const isTemplateLiteralArgs: (args: unknown[]) => args is TemplateLiteralArgs;
+type SQLArgs = StaticSQLArgs | [DynamicSQLArg<QueryColumn>];
+interface DynamicSQLArg<T extends QueryColumn> {
+    (sql: (...args: StaticSQLArgs) => Expression<T>): Expression<T>;
+}
+type StaticSQLArgs = TemplateLiteralArgs | [{
+    raw: string;
+    values?: RawSQLValues;
+}];
+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;
+}
+declare const templateLiteralSQLToCode: (sql: TemplateLiteralArgs) => string;
+declare const isRawSQL: (arg: unknown) => arg is RawSQLBase<QueryColumn<unknown, any>, unknown>;
+declare class ValExpression extends Expression {
+    value: unknown;
+    result: {
+        value: ColumnTypeBase<ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, ColumnDataBase>;
+    };
+    q: ExpressionData;
+    constructor(value: unknown);
+    makeSQL(ctx: {
+        values: unknown[];
+    }): 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;
+}
+type ColumnSchemaGetterColumns<T extends ColumnSchemaGetterTableClass> = T['prototype']['columns']['shape'];
+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 WithDataItem {
+    table: string;
+    shape: QueryColumns;
+}
+interface WithDataItems {
+    [K: string]: WithDataItem;
+}
+
+interface RelationJoinQuery {
+    (joiningQuery: IsQuery, baseQuery: IsQuery): IsQuery;
+}
+interface RelationConfigQuery extends PickQueryTableMetaResult, PickQueryShape, PickQueryTable {
+}
+interface RelationConfigBase extends IsQuery {
+    returnsOne: boolean;
+    query: RelationConfigQuery;
+    joinQuery: RelationJoinQuery;
+    reverseJoin: RelationJoinQuery;
+    params: unknown;
+    queryRelated(params: unknown): unknown;
+    modifyRelatedQuery?(relatedQuery: IsQuery): (query: IsQuery) => void;
+    maybeSingle: PickQueryMetaReturnType;
+    omitForeignKeyInCreate: PropertyKey;
+    dataForCreate?: RelationConfigDataForCreate;
+    optionalDataForCreate: unknown;
+    dataForUpdate: unknown;
+    dataForUpdateOne: unknown;
+    primaryKeys: string[];
+}
+interface RelationConfigDataForCreate {
+    columns: PropertyKey;
+    nested: RecordUnknown;
+}
+interface RelationsBase {
+    [K: string]: RelationConfigBase;
+}
+declare const isRelationQuery: (q: IsQuery) => q is RelationConfigBase;
+
+interface PickQueryTable {
+    table?: string;
+}
+interface PickQueryMeta {
+    meta: QueryMetaBase;
+}
+interface PickQueryResult {
+    result: QueryColumns;
+}
+interface PickQueryShape {
+    shape: QueryColumns;
+}
+interface PickQueryReturnType {
+    returnType: QueryReturnType;
+}
+interface PickQueryResultReturnType extends PickQueryResult, PickQueryReturnType {
+}
+interface PickQueryMetaShape extends PickQueryMeta, PickQueryShape {
+}
+interface PickQueryMetaResult extends PickQueryMeta, PickQueryResult {
+}
+interface PickQueryResultUniqueColumns extends PickQueryResult {
+    internal: {
+        uniqueColumns: unknown;
+    };
+}
+interface PickQueryResultReturnTypeUniqueColumns extends PickQueryResultUniqueColumns, PickQueryReturnType {
+}
+interface PickQueryUniqueProperties {
+    internal: {
+        uniqueColumnNames: unknown;
+        uniqueColumnTuples: unknown;
+        uniqueConstraints: unknown;
+    };
+}
+interface PickQueryMetaResultWindows extends PickQueryMetaResult {
+    windows: EmptyObject;
+}
+interface PickQueryTableMetaResult extends PickQueryTable, PickQueryMetaResult {
+}
+interface PickQueryInputType {
+    inputType: unknown;
+}
+interface PickQueryTableMetaResultInputType extends PickQueryTableMetaResult, PickQueryInputType {
+}
+interface PickQueryTableMetaShape extends PickQueryTable, PickQueryMetaShape {
+}
+interface PickQueryTableMetaResultShape extends PickQueryTableMetaResult, PickQueryMetaShape {
+}
+interface PickQueryMetaReturnType extends PickQueryMeta, PickQueryReturnType {
+}
+interface PickQueryMetaResultReturnType extends PickQueryMetaResult, PickQueryReturnType {
+}
+interface PickQueryWithData {
+    withData: WithDataItems;
+}
+interface PickQueryWindows {
+    windows: EmptyObject;
+}
+interface PickQueryRelations {
+    relations: RelationsBase;
+}
+interface PickQueryRelationQueries {
+    relationQueries: IsQueries;
+}
+interface PickQueryMetaRelations extends PickQueryMeta, PickQueryRelations {
+}
+interface PickQueryMetaRelationsResult extends PickQueryMetaRelations, PickQueryResult {
+}
+interface PickQueryMetaRelationsReturnType extends PickQueryMetaRelationsResult, PickQueryResultReturnType {
+}
+interface PickQueryMetaShapeRelationsReturnType extends PickQueryMetaRelationsReturnType, PickQueryShape {
+}
+interface PickQueryMetaRelationsResultReturnType extends PickQueryMetaRelationsReturnType, PickQueryResult {
+}
+interface PickQueryMetaResultRelations extends PickQueryResult, PickQueryMeta, PickQueryRelations {
+}
+interface PickQueryMetaResultRelationsWindows extends PickQueryMetaResultRelations, PickQueryWindows {
+}
+interface PickQueryColumnTypes {
+    columnTypes: unknown;
+}
+interface PickQueryMetaColumnTypes extends PickQueryMeta, PickQueryColumnTypes {
+}
+interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows, PickQueryColumnTypes {
+}
+interface PickQueryWithDataColumnTypes extends PickQueryWithData, PickQueryColumnTypes {
+}
+interface PickQueryResultColumnTypes extends PickQueryResult, PickQueryColumnTypes {
+}
+interface PickQueryMetaWithDataColumnTypes extends PickQueryMeta, PickQueryWithData, PickQueryColumnTypes {
+}
+interface PickQueryMetaTable extends PickQueryMeta, PickQueryTable {
+}
+interface PickQueryMetaTableShape extends PickQueryMetaTable, PickQueryShape {
+}
+interface PickQueryMetaWithData extends PickQueryMeta, PickQueryWithData {
+}
+interface PickQueryRelationsWithData extends PickQueryWithData, PickQueryRelations {
+}
+interface PickQueryMetaShapeRelationsWithData extends PickQueryMeta, PickQueryShape, PickQueryRelations, PickQueryWithData {
+}
+interface PickQueryMetaResultRelationsWithDataReturnType extends PickQueryMeta, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType {
+}
+interface PickQueryMetaTableShapeReturnTypeWithData extends PickQueryMetaTableShape, PickQueryReturnType, PickQueryMetaWithData {
+}
+interface PickQueryMetaResultRelationsWithDataReturnTypeShape extends PickQueryMetaResultRelationsWithDataReturnType, PickQueryShape {
+}
+interface PickQueryMetaResultReturnTypeWithDataWindows extends PickQueryMetaResultReturnType, PickQueryWithData, PickQueryWindows {
+}
+interface PickQueryMetaResultReturnTypeWithDataWindowsThen extends PickQueryMetaResultReturnTypeWithDataWindows {
+    then: unknown;
+}
+interface PickQueryTableMetaResultReturnTypeWithDataWindowsThen extends PickQueryMetaResultReturnTypeWithDataWindowsThen, PickQueryTable {
+}
+interface PickQuerySinglePrimaryKey {
+    internal: {
+        singlePrimaryKey: unknown;
+    };
+}
+interface PickQueryShapeSinglePrimaryKey extends PickQueryShape, PickQuerySinglePrimaryKey {
+}
+interface PickQueryShapeResultSinglePrimaryKey extends PickQueryShapeSinglePrimaryKey, PickQueryResult {
+}
+interface PickQueryShapeResultReturnTypeSinglePrimaryKey extends PickQueryShapeResultSinglePrimaryKey, PickQueryReturnType {
+}
+
+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;
+}
+
+type ColumnShapeInput<Shape extends QueryColumnsInit, AppReadOnly = {
+    [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never;
+}[keyof Shape], Optional extends keyof Shape = {
+    [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never;
+}[keyof Shape]> = {
+    [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['inputType'];
+} & {
+    [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['inputType'];
+};
+type ColumnShapeInputPartial<Shape extends QueryColumnsInit> = {
+    [K in keyof Shape]?: Shape[K]['inputType'];
+};
+type ColumnShapeOutput<Shape extends QueryColumns> = {
+    [K in keyof Shape]: Shape[K]['outputType'];
+};
+type DefaultSelectOutput<Shape extends QueryColumnsInit> = {
+    [K in keyof Shape as Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K]: Shape[K]['outputType'];
+};
+interface ColumnsShapeBase {
+    [K: string]: ColumnTypeBase;
+}
+type PrimaryKeyColumn<T, Name extends string> = T & {
+    data: {
+        primaryKey: Name;
+    };
+};
+type UniqueColumn<T, Name extends string> = T & {
+    data: {
+        unique: Name;
+    };
+};
+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>;
+}
+declare function makeColumnNullable<T extends ColumnTypeBase, InputSchema, OutputSchema, QuerySchema>(column: T, inputSchema: InputSchema, outputSchema: OutputSchema, querySchema: QuerySchema): NullableColumn<T, InputSchema, OutputSchema, QuerySchema>;
+type EncodeColumn<T, InputSchema, Input> = {
+    [K in keyof T]: K extends 'inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K];
+};
+type ParseColumn<T extends ColumnTypeBase, OutputSchema, Output> = {
+    [K in keyof T]: K extends 'outputType' ? null extends T['type'] ? Exclude<Output, null> | (unknown extends T['nullType'] ? null : T['nullType']) : Output : K extends 'outputSchema' ? null extends T['type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K];
+};
+type ParseNullColumn<T extends ColumnTypeBase, NullSchema, NullType> = {
+    [K in keyof T]: K extends 'outputType' ? null extends T['type'] ? Exclude<T['outputType'], null> | NullType : T['outputType'] : K extends 'nullType' ? NullType : K extends 'outputSchema' ? null extends T['type'] ? T['outputSchema'] | NullSchema : T['outputSchema'] : K extends 'nullSchema' ? NullSchema : T[K];
+};
+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;
+};
+type DefaultSelectColumns<S extends QueryColumnsInit> = {
+    [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K;
+}[keyof S];
+interface ForeignKeyTable {
+    new (): {
+        schema?: string;
+        table: string;
+        columns: {
+            shape: QueryColumns;
+        };
+    };
+}
+type ColumnNameOfTable<Table extends ForeignKeyTable> = keyof InstanceType<Table>['columns']['shape'] & string;
+declare const setColumnData: <T extends PickColumnBaseData, K extends keyof T["data"]>(q: T, key: K, value: T['data'][K]) => T;
+declare const pushColumnData: <T extends PickColumnBaseData, K extends keyof T["data"]>(q: T, key: K, value: unknown) => T;
+type ErrorMessages = {
+    required?: string;
+    invalidType?: string;
+};
+type ErrorMessage = string | {
+    message?: string;
+};
+declare const setDataValue: <T extends PickColumnBaseData, Key extends string, Value>(item: T, key: Key, value: Value, params?: ErrorMessage) => T;
+interface ColumnInputOutputQueryTypes {
+    inputType: unknown;
+    outputType: unknown;
+    queryType: unknown;
+}
+interface ColumnInputOutputQueryTypesWithSchemas extends ColumnInputOutputQueryTypes {
+    inputSchema: unknown;
+    outputSchema: unknown;
+    querySchema: unknown;
+}
+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;
+}
+declare function setCurrentColumnName(name: string): void;
+declare const consumeColumnName: () => string | undefined;
+declare const setDefaultNowFn: (sql: string) => void;
+declare const setDefaultLanguage: (lang?: string) => void;
+declare const getDefaultLanguage: () => string;
+interface AsTypeArgWithType<Schema> {
+    type: Schema;
+    input?: Schema;
+    output?: Schema;
+    query?: Schema;
+}
+interface AsTypeArgWithoutType<Schema> {
+    input: Schema;
+    output: Schema;
+    query: Schema;
+}
+type AsTypeArg<Schema> = AsTypeArgWithType<Schema> | AsTypeArgWithoutType<Schema>;
+interface PickType {
+    type: unknown;
+}
+interface PickOutputType {
+    outputType: unknown;
+}
+interface PickOutputTypeAndOperators {
+    outputType: unknown;
+    operators: unknown;
+}
+interface QueryColumn<T = unknown, Op = any> {
+    dataType: string;
+    type: T;
+    outputType: T;
+    queryType: T;
+    operators: Op;
+}
+interface QueryColumnOfDataType<DataType extends string> extends QueryColumn {
+    dataType: DataType;
+}
+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;
+}
+type QueryColumnToNullable<C extends QueryColumn> = {
+    [K in keyof C]: K extends 'outputType' | 'queryType' ? C[K] | null : C[K];
+};
+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;
+}
+
+interface BaseNumberData extends ColumnDataBase {
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+    step?: number;
+    int?: boolean;
+    finite?: boolean;
+    safe?: boolean;
+}
+interface StringTypeData extends ColumnDataBase {
+    min?: number;
+    max?: number;
+    length?: number;
+    email?: boolean;
+    url?: boolean;
+    emoji?: boolean;
+    uuid?: boolean;
+    cuid?: boolean;
+    cuid2?: boolean;
+    ulid?: boolean;
+    regex?: RegExp;
+    includes?: string;
+    startsWith?: string;
+    endsWith?: string;
+    datetime?: {
+        offset?: boolean;
+        precision?: number;
+    };
+    ipv4?: true;
+    ipv6?: true;
+    nonEmpty?: boolean;
+    trim?: boolean;
+    toLowerCase?: boolean;
+    toUpperCase?: boolean;
+}
+interface DateColumnData extends ColumnDataBase {
+    min?: Date;
+    max?: Date;
+}
+interface ArrayMethodsData {
+    min?: number;
+    max?: number;
+    length?: number;
+    nonEmpty?: boolean;
+}
+interface ArrayMethodsDataForBaseColumn extends ColumnDataBase, ArrayMethodsData {
+}
+
+type Code = string | Codes;
+type Codes = Code[];
+/**
+ * Push code: this will append a code string to the last code array element when possible.
+ * @param code - array of code to push into
+ * @param add - code to push
+ */
+declare const addCode: (code: Code[], add: Code) => void;
+/**
+ * Convert the code item into string.
+ *
+ * @param code - code item
+ * @param tabs - each new line will be prefixed with the tabs. Each element of the code represents a new line
+ * @param shift - array elements of the given code will be shifted with this sting
+ */
+declare const codeToString: (code: Code, tabs: string, shift: string) => string;
+/**
+ * Convert a column default value into code string.
+ *
+ * @param t - column types variable name
+ * @param value - column default
+ */
+declare const columnDefaultArgumentToCode: (t: string, value: unknown) => string;
+declare const stringDataToCode: (data: StringTypeData, migration: boolean | undefined, skipLocal?: RecordKeyTrue) => string;
+declare const numberDataToCode: (data: BaseNumberData, migration: boolean | undefined, skipLocal?: RecordKeyTrue) => string;
+declare const dateDataToCode: (data: DateColumnData, migration: boolean | undefined, skipLocal?: RecordKeyTrue) => string;
+declare const arrayDataToCode: (data: ArrayMethodsDataForBaseColumn, migration: boolean | undefined, skipLocal?: RecordKeyTrue) => string;
+/**
+ * Converts column type and JSON type custom errors into code
+ *
+ * @param errors - custom error messages
+ */
+declare const columnErrorMessagesToCode: (errors: RecordString) => Code;
+
+/**
+ * Symbol that turns on a snake case column names.
+ * It is set on the column types.
+ * When it's on, column names in ORM are still as user types them, but they are translated to snake_case when generating SQL.
+ */
+declare const snakeCaseKey: unique symbol;
+interface TimeInterval {
+    years?: number;
+    months?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+
+interface Timestamps<T extends ColumnTypeBase> {
+    createdAt: ColumnWithDefault<T, RawSQLBase>;
+    updatedAt: ColumnWithDefault<T, RawSQLBase>;
+}
+interface TimestampHelpers {
+    /**
+     * Add `createdAt` and `updatedAt` timestamps. Both have `now()` as a default, `updatedAt` is automatically updated during update.
+     */
+    timestamps<T extends ColumnTypeBase>(this: {
+        timestamp(): T;
+    }): Timestamps<T>;
+    /**
+     * The same as {@link timestamps}, for the timestamp without time zone time.
+     */
+    timestampsNoTZ<T extends ColumnTypeBase>(this: {
+        timestampNoTZ(): T;
+    }): Timestamps<T>;
+}
+declare const timestampHelpers: TimestampHelpers;
+
+type DelayedRelationSelect = {
+    query: QueryBase;
+    value?: {
+        [K: string]: IsQuery;
+    };
+};
+declare const newDelayedRelationSelect: (query: QueryBase) => {
+    query: QueryBase;
+};
+declare const setDelayedRelation: (d: DelayedRelationSelect, as: string, value: IsQuery) => void;
+
+interface QueryInternalColumnNameToKey {
+    columnNameToKeyMap?: Map<string, string>;
+}
+/**
+ * In snake case mode, or when columns have custom names,
+ * use this method to exchange a db column name to its runtime key.
+ */
+declare const queryColumnNameToKey: (q: QueryBase, name: string) => string | undefined;
+
+interface PickQueryDataAliases {
+    aliases?: RecordString;
+}
+interface QueryDataAliases extends PickQueryDataAliases {
+    as?: string;
+    outerAliases?: RecordString;
+}
+type AliasOrTable<T extends PickQueryMetaTable> = T['meta']['as'] extends string ? T['meta']['as'] : T['table'] extends string ? T['table'] : never;
+type SetQueryTableAlias<T extends PickQueryMetaTableShape, As extends string> = {
+    [K in keyof T]: K extends 'meta' ? {
+        [K in keyof T['meta'] | 'as']: K extends 'as' ? As : K extends 'selectable' ? Omit<T['meta']['selectable'], `${AliasOrTable<T>}.${keyof T['shape'] & string}`> & {
+            [K in keyof T['shape'] & string as `${As}.${K}`]: {
+                as: K;
+                column: T['shape'][K];
+            };
+        } : T['meta'][K];
+    } : T[K];
+};
+type AsQueryArg = PickQueryMetaTableShape;
+/** getters **/
+declare const _getQueryAs: (q: QueryBase) => string | undefined;
+declare const _getQueryFreeAlias: (q: QueryDataAliases, as: string) => string;
+declare const _checkIfAliased: (q: QueryBase, as: string, name: string) => boolean;
+declare const _getQueryAliasOrName: (q: PickQueryDataAliases, as: string) => string;
+declare const _getQueryOuterAliases: (q: QueryDataBase) => RecordString | undefined;
+/** setters **/
+declare const _setQueryAs: <T extends PickQueryMetaTableShape, As extends string>(self: T, as: As) => SetQueryTableAlias<T, As>;
+declare const _setQueryAlias: (q: QueryBase, name: string, as: string) => void;
+declare const _setSubQueryAliases: (q: QueryBase) => void;
+/**
+ * Is used in `chain`: combines query and its relation aliases,
+ * stores the result to the relation query data.
+ */
+declare const _applyRelationAliases: (query: QueryBase, relQueryData: QueryDataBase) => void;
+declare const _copyQueryAliasToQuery: (fromQuery: QueryBase, toQuery: QueryBase, key: string) => string;
+
+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;
+}
+declare const _addToHookSelect: (query: IsQuery, selects: string[]) => void;
+declare const _addToHookSelectWithTable: (query: IsQuery, selects: string[], table: string) => void;
+
+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[];
+/**
+ * generic utility to add a parser to the query object
+ * @param query - the query object, it will be mutated
+ * @param key - the name of the column in the data loaded by the query
+ * @param parser - function to process the value of the column with.
+ */
+declare const setParserToQuery: (query: {
+    parsers?: ColumnsParsers;
+}, key: string | getValueKey, parser: ColumnParser) => void;
+declare const getQueryParsers: (q: QueryBase, hookSelect?: HookSelect) => ColumnsParsers | undefined;
+
+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 BatchSql extends SqlCommonOptions {
+    batch: SingleSql[];
+}
+type Sql = SingleSql | BatchSql;
+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 QueryMetaIsSubQuery {
+    meta: {
+        subQuery: true;
+    };
+}
+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;
+}
+type CoreQueryScopes<Keys extends string> = {
+    [K in Keys]: unknown;
+};
+type QueryReturnType = QueryReturnTypeAll | 'one' | 'oneOrThrow' | 'rows' | 'pluck' | 'value' | 'valueOrThrow' | 'void';
+type QueryReturnTypeAll = undefined | 'all';
+type QueryReturnTypeOptional = 'one' | 'value';
+interface IsQuery {
+    __isQuery: true;
+}
+interface IsQueries {
+    [K: string]: IsQuery;
+}
+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;
+type QueryDataTransform = QueryDataTransformFn | {
+    map: (record: unknown, index: number, array: unknown) => unknown;
+    thisArg?: unknown;
+};
+interface QueryDataTransformFn {
+    (data: unknown, queryData: unknown): unknown;
+}
+/**
+ * See `transform` query method.
+ * This helper applies all transform functions to a result.
+ *
+ * @param queryData - query data
+ * @param returnType - return type of the query, for proper `map` handling
+ * @param fns - array of transform functions, can be undefined
+ * @param result - query result to transform
+ */
+declare const applyTransforms: (queryData: unknown, returnType: QueryReturnType, fns: QueryDataTransform[], result: unknown) => unknown;
+/**
+ * Push a new element into an array in the query data - immutable version
+ *
+ * @param q - query
+ * @param key - key to get the array
+ * @param value - new element to push
+ */
+declare const pushQueryValueImmutable: <T extends IsQuery>(q: T, key: string, value: unknown) => T;
+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;
+}
+interface QueryLogger {
+    log(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+interface QueryLogOptions {
+    log?: boolean | Partial<QueryLogObject>;
+    logger?: QueryLogger;
+}
+declare const logColors: {
+    boldCyanBright: (message: string) => string;
+    boldBlue: (message: string) => string;
+    boldYellow: (message: string) => string;
+    boldMagenta: (message: string) => string;
+    boldRed: (message: string) => string;
+};
+
+declare abstract class OrchidOrmError extends Error {
+}
+/**
+ * When we search for a single record, and it is not found, it can either throw an error, or return `undefined`.
+ *
+ * Unlike other database libraries, `Orchid ORM` decided to throw errors by default when using methods `take`, `find`, `findBy`, `get` and the record is not found.
+ * It is a [good practice](https://github.com/goldbergyoni/nodebestpractices/blob/master/sections/errorhandling/centralizedhandling.md) to catch common errors in a centralized place (see [global error handling](https://orchid-orm.netlify.app/guide/error-handling.html#global-error-handling)), and this allows for a more concise code.
+ *
+ * If it's more suitable to get the `undefined` value instead of throwing, use `takeOptional`, `findOptional`, `findByOptional`, `getOptional` instead.
+ */
+declare class NotFoundError extends OrchidOrmError {
+    #private;
+    constructor(query: QueryBase, message?: string);
+    get query(): QueryBase;
+}
+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; };
+}
+declare class MoreThanOneRowError extends OrchidOrmInternalError {
+    constructor(query: QueryBase, message?: string);
+}
+declare class UnhandledTypeError extends OrchidOrmInternalError {
+    constructor(query: QueryBase, value: never);
+}
+
+/**
+ * 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[]): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(text: string, values?: unknown[]): 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;
+}
+/**
+ * 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>;
+}
+declare const setConnectRetryConfig: (adapter: AdapterBase, config: AdapterConfigConnectRetryParam) => void;
+declare const wrapAdapterFnWithConnectRetry: <Fn extends (this: unknown, ...args: any[]) => Promise<unknown>>(adapter: AdapterBase, fn: Fn) => Fn;
+
+interface QueryThen<T> {
+    <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+}
+type QueryThenShallowSimplify<T> = QueryThen<ShallowSimplify<T>>;
+type QueryThenShallowSimplifyArr<T> = QueryThen<ShallowSimplify<T>[]>;
+type QueryThenShallowSimplifyOptional<T> = QueryThen<ShallowSimplify<T> | undefined>;
+type QueryThenByQuery<T extends PickQueryReturnType, Result extends QueryColumns> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnShapeOutput<Result>> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<ColumnShapeOutput<Result>> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnShapeOutput<Result>> : T['returnType'] extends 'value' ? QueryThen<Result['value']['outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<Result['value']['outputType']> : T['returnType'] extends 'rows' ? QueryThen<ColumnShapeOutput<Result>[keyof Result][][]> : T['returnType'] extends 'pluck' ? QueryThen<Result['pluck']['outputType'][]> : QueryThen<void>;
+type QueryThenByReturnType<T extends QueryReturnType, Result extends QueryColumns> = T extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnShapeOutput<Result>> : T extends 'one' ? QueryThenShallowSimplifyOptional<ColumnShapeOutput<Result>> : T extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnShapeOutput<Result>> : T extends 'value' ? QueryThen<Result['value']['outputType'] | undefined> : T extends 'valueOrThrow' ? QueryThen<Result['value']['outputType']> : T extends 'rows' ? QueryThen<ColumnShapeOutput<Result>[keyof Result][][]> : T extends 'pluck' ? QueryThen<Result['pluck']['outputType'][]> : QueryThen<void>;
+interface QueryCatch {
+    <Q, TResult = never>(this: {
+        then: (onfulfilled?: (value: Q) => any) => any;
+    }, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<Q | TResult>;
+}
+
+type SQLQueryArgs = TemplateLiteralArgs | [RawSQLBase];
+
+declare const getPrimaryKeys: (q: QueryBase) => string[];
+declare const requirePrimaryKeys: (q: QueryBase, message: string) => string[];
 
 declare const checkIfASimpleQuery: (q: Query) => boolean;
 interface WithItem {
@@ -188,7 +1972,7 @@ type OnConflictMerge = string | string[] | {
     except: string | string[];
 };
 
-declare module 'orchid-core' {
+declare module '../core' {
     interface ColumnDataBase {
         computed?: Expression;
     }
@@ -500,7 +2284,7 @@ declare class DynamicRawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTy
 }
 declare function raw<T = never>(...args: StaticSQLArgs): RawSQL<QueryColumn<T>>;
 declare function raw<T = never>(...args: [DynamicSQLArg<QueryColumn<T>>]): DynamicRawSQL<QueryColumn<T>>;
-declare const countSelect: RawSQL<QueryColumn<unknown, any>, DefaultColumnTypes<ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>>[];
+declare const countSelect: RawSQL<QueryColumn<unknown, any>, DefaultColumnTypes<ColumnSchemaConfig<ColumnTypeBase<ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, ColumnDataBase>>>>[];
 declare function sqlQueryArgsToExpression(args: SQLQueryArgs): RawSQL<QueryColumn>;
 interface SqlFn {
     <T, Args extends [sql: TemplateStringsArray, ...values: unknown[]] | [sql: string] | [values: RecordUnknown, sql?: string]>(this: T, ...args: Args): Args extends [RecordUnknown] ? (...sql: TemplateLiteralArgs) => RawSQLBase<QueryColumn, T> : RawSQLBase<QueryColumn, T>;
@@ -3710,12 +5494,13 @@ interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, n
  * })
  * ```
  */
-declare const createDbWithAdapter: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptionsWithAdapter<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const createDbWithAdapter: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptionsWithAdapter<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
 declare const _initQueryBuilder: (adapter: AdapterBase, columnTypes: unknown, transactionStorage: AsyncLocalStorage<TransactionState>, commonOptions: DbTableOptions<unknown, undefined, QueryColumns>, options: DbSharedOptions) => Db;
 
-interface ToSqlOptionsInternal extends ToSQLOptions {
+interface ToSqlOptionsInternal extends ToSQLOptions, HasCteHooks {
     aliasValue?: true;
     skipBatchCheck?: true;
+    selectedCount?: number;
 }
 interface ToSQLCtx extends ToSqlOptionsInternal, ToSQLOptions {
     qb: QueryBuilder;
@@ -3743,7 +5528,8 @@ interface ToSQLQuery {
     result: Query['result'];
     shape: Query['shape'];
 }
-declare const toSQL: (table: ToSQLQuery, options?: ToSqlOptionsInternal) => Sql;
+declare const toSubSqlText: (q: ToSQLQuery, cteName: string, options: ToSqlOptionsInternal) => string;
+declare const toSQL: (table: ToSQLQuery, options?: ToSqlOptionsInternal, isSubSql?: boolean) => Sql;
 declare function pushLimitSQL(sql: string[], values: unknown[], q: QueryData): void;
 
 declare const getSqlText: (sql: Sql) => string;
@@ -4286,10 +6072,10 @@ type CreateManyFromResult<T extends CreateSelf> = T extends {
     isCount: true;
 } ? SetQueryKind<T, 'create'> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKind<T, 'create'> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKind<T, 'create'> : SetQueryKind<T, 'create'>;
 type InsertManyFromResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKind<T, 'create'> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKind<T, 'create'> : SetQueryKind<T, 'create'> : SetQueryReturnsRowCountMany<T, 'create'>;
-declare const _queryCreateOneFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data?: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>) => CreateRawOrFromResult<T>;
-declare const _queryInsertOneFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data?: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>) => InsertRawOrFromResult<T>;
-declare const _queryCreateManyFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>[]) => CreateManyFromResult<T>;
-declare const _queryInsertManyFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>[]) => InsertManyFromResult<T>;
+declare const _queryCreateOneFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>) => CreateRawOrFromResult<T>;
+declare const _queryInsertOneFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>) => InsertRawOrFromResult<T>;
+declare const _queryCreateManyFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data: Omit<CreateData<T>, keyof Q['result']>[]) => CreateManyFromResult<T>;
+declare const _queryInsertManyFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data: Omit<CreateData<T>, keyof Q['result']>[]) => InsertManyFromResult<T>;
 declare const _queryCreateForEachFrom: <T extends CreateSelf>(q: T, query: IsQuery) => CreateManyFromResult<T>;
 declare const _queryInsertForEachFrom: <T extends CreateSelf>(q: T, query: IsQuery) => InsertManyFromResult<T>;
 declare class QueryCreateFrom {
@@ -4344,14 +6130,14 @@ declare class QueryCreateFrom {
      * @param query - query to create new records from
      * @param data - additionally you can set some columns
      */
-    createOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>): CreateRawOrFromResult<T>;
+    createOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateRawOrFromResult<T>;
     /**
      * Works exactly as {@link createOneFrom}, except that it returns inserted row count by default.
      *
      * @param query - query to create new records from
      * @param data - additionally you can set some columns
      */
-    insertOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>): InsertRawOrFromResult<T>;
+    insertOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): InsertRawOrFromResult<T>;
     /**
      * Inserts multiple records based on a query that selects a single record.
      *
@@ -4411,14 +6197,14 @@ declare class QueryCreateFrom {
      * @param query - query to create new records from
      * @param data - array of records to create
      */
-    createManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>[]): CreateManyFromResult<T>;
+    createManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: Omit<CreateData<T>, keyof Q['result']>[]): CreateManyFromResult<T>;
     /**
      * Works exactly as {@link createManyFrom}, except that it returns inserted row count by default.
      *
      * @param query - query to create new records from
      * @param data - array of records to create
      */
-    insertManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>[]): InsertManyFromResult<T>;
+    insertManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: Omit<CreateData<T>, keyof Q['result']>[]): InsertManyFromResult<T>;
     /**
      * Inserts a single record per every record found in a given query.
      *
@@ -4448,7 +6234,7 @@ declare class QueryCreateFrom {
 interface CreateSelf extends IsQuery, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryUniqueProperties {
     inputType: RecordUnknown;
 }
-type CreateData<T extends CreateSelf, BelongsToData = CreateBelongsToData<T>> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['meta']['defaults']> : CreateRelationsData<T, BelongsToData>;
+type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['meta']['defaults']> : CreateRelationsData<T>;
 type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = {
     [K in keyof T['inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K>;
 } & {
@@ -4460,10 +6246,10 @@ type CreateDataWithDefaultsForRelations<T extends CreateSelf, Defaults extends k
     [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K>;
 };
 type CreateColumn<T extends CreateSelf, K extends keyof T['inputType']> = T['inputType'][K] | ((q: T) => QueryOrExpression<T['inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf, BelongsToData> = CreateDataWithDefaultsForRelations<T, keyof T['meta']['defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & ([BelongsToData] extends [never] ? EmptyObject : BelongsToData) & T['relations'][keyof T['relations']]['optionalDataForCreate'];
+type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['meta']['defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateBelongsToData<T> & T['relations'][keyof T['relations']]['optionalDataForCreate'];
 type CreateBelongsToData<T extends CreateSelf> = [
     T['relations'][keyof T['relations']]['dataForCreate']
-] extends [never] ? never : CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
+] extends [never] ? EmptyObject : CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
 type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union extends RelationConfigDataForCreate ? (u: Union['columns'] extends keyof T['meta']['defaults'] ? {
     [P in Exclude<Union['columns'] & keyof T['inputType'], keyof T['meta']['defaults']>]: CreateColumn<T, P>;
 } & {
@@ -4471,25 +6257,21 @@ type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union exte
 } & Partial<Union['nested']> : {
     [P in Union['columns'] & keyof T['inputType']]: CreateColumn<T, P>;
 } | Union['nested']) => void : never) extends (u: infer Obj) => void ? Obj : never;
-type CreateResult<T extends CreateSelf, BT> = T extends {
+type CreateResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKind<T, 'create'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>>;
-type InsertResult<T extends CreateSelf, BT> = T['meta']['hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryReturnsRowCount<T, 'create'>;
-type CreateManyResult<T extends CreateSelf, BT> = T extends {
+} ? SetQueryKind<T, 'create'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>>;
+type InsertResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryReturnsRowCount<T, 'create'>;
+type CreateManyResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>>;
-type InsertManyResult<T extends CreateSelf, BT> = T['meta']['hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryReturnsRowCountMany<T, 'create'>;
+} ? SetQueryKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>>;
+type InsertManyResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryReturnsRowCountMany<T, 'create'>;
 /**
  * When creating a record with a *belongs to* nested record,
  * un-nullify foreign key columns of the result.
  *
  * The same should work as well with any non-null columns passed to `create`, but it's to be implemented later.
  */
-type NarrowCreateResult<T extends CreateSelf, Bt> = EmptyObject extends T['relations'] ? T['result'] : [
-    {
-        [K in keyof T['relations']]: T['relations'][K]['omitForeignKeyInCreate'];
-    }[keyof T['relations'] & keyof Bt]
-] extends [never] ? T['result'] : {
+type NarrowCreateResult<T extends CreateSelf> = EmptyObject extends T['relations'] ? T['result'] : {
     [K in keyof T['result']]: K extends T['relations'][keyof T['relations']]['omitForeignKeyInCreate'] ? QueryColumn<Exclude<T['result'][K]['type'], null>, T['result'][K]['operators']> : T['result'][K];
 };
 type IgnoreResult<T extends CreateSelf> = T['returnType'] extends 'oneOrThrow' ? QueryTakeOptional<T> : T['returnType'] extends 'valueOrThrow' ? SetQueryReturnsColumnOptional<T, T['result']['value']> : T;
@@ -4510,11 +6292,11 @@ interface CreateCtx {
     returnTypeAll?: true;
     resultAll: RecordUnknown[];
 }
-declare const _queryCreate: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>) => CreateResult<T, BT>;
-declare const _queryInsert: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(query: T, data: CreateData<T, BT>) => InsertResult<T, BT>;
-declare const _queryCreateMany: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>[]) => CreateManyResult<T, BT>;
-declare const _queryInsertMany: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>[]) => InsertManyResult<T, BT>;
-declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T, CreateBelongsToData<T>>>>(q: T, data: Data) => AddQueryDefaults<T, { [K in keyof Data]: true; }>;
+declare const _queryCreate: <T extends CreateSelf>(q: T, data: CreateData<T>) => CreateResult<T>;
+declare const _queryInsert: <T extends CreateSelf>(query: T, data: CreateData<T>) => InsertResult<T>;
+declare const _queryCreateMany: <T extends CreateSelf>(q: T, data: CreateData<T>[]) => CreateManyResult<T>;
+declare const _queryInsertMany: <T extends CreateSelf>(q: T, data: CreateData<T>[]) => InsertManyResult<T>;
+declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T>>>(q: T, data: Data) => AddQueryDefaults<T, { [K in keyof Data]: true; }>;
 /**
  * Names of all create methods,
  * is used in relational query to remove these methods if chained relation shouldn't have them,
@@ -4572,13 +6354,13 @@ declare class QueryCreate {
      *
      * @param data - data for the record, may have values, raw SQL, queries, relation operations.
      */
-    create<T extends CreateSelf, BT extends CreateBelongsToData<T>>(this: T, data: CreateData<T, BT>): CreateResult<T, BT>;
+    create<T extends CreateSelf>(this: T, data: CreateData<T>): CreateResult<T>;
     /**
      * Works exactly as {@link create}, except that it returns inserted row count by default.
      *
      * @param data - data for the record, may have values, raw SQL, queries, relation operations.
      */
-    insert<T extends CreateSelf, BT extends CreateBelongsToData<T>>(this: T, data: CreateData<T, BT>): InsertResult<T, BT>;
+    insert<T extends CreateSelf>(this: T, data: CreateData<T>): InsertResult<T>;
     /**
      * `createMany` and `insertMany` will create a batch of records.
      *
@@ -4620,13 +6402,13 @@ declare class QueryCreate {
      *
      * @param data - array of records data, may have values, raw SQL, queries, relation operations
      */
-    createMany<T extends CreateSelf, BT extends CreateBelongsToData<T>>(this: T, data: CreateData<T, BT>[]): CreateManyResult<T, BT>;
+    createMany<T extends CreateSelf>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
     /**
      * Works exactly as {@link createMany}, except that it returns inserted row count by default.
      *
      * @param data - array of records data, may have values, raw SQL, queries, relation operations
      */
-    insertMany<T extends CreateSelf, BT extends CreateBelongsToData<T>>(this: T, data: CreateData<T, BT>[]): InsertManyResult<T, BT>;
+    insertMany<T extends CreateSelf>(this: T, data: CreateData<T>[]): InsertManyResult<T>;
     /**
      * `defaults` allows setting values that will be used later in `create`.
      *
@@ -4649,7 +6431,7 @@ declare class QueryCreate {
      *
      * @param data - default values for `create` and `createMany` which will follow `defaults`
      */
-    defaults<T extends CreateSelf, Data extends Partial<CreateData<T, CreateBelongsToData<T>>>>(this: T, data: Data): AddQueryDefaults<T, {
+    defaults<T extends CreateSelf, Data extends Partial<CreateData<T>>>(this: T, data: Data): AddQueryDefaults<T, {
         [K in keyof Data]: true;
     }>;
     /**
@@ -7072,12 +8854,12 @@ interface QueryUpsert {
      *
      * @param data - `update` property for the data to update, `create` property for the data to create
      */
-    upsert<T extends UpsertThis, Update extends UpdateData<T>, BT extends CreateBelongsToData<T>>(this: T, data: {
+    upsert<T extends UpsertThis, Update extends UpdateData<T>>(this: T, data: {
         update: Update;
-        create: CreateData<T, BT> | ((update: Update) => CreateData<T, BT>);
+        create: CreateData<T> | ((update: Update) => CreateData<T>);
     } | {
         data: Update;
-        create: UpsertCreate<keyof Update, CreateData<T, BT>> | ((update: Update) => UpsertCreate<keyof Update, CreateData<T, BT>>);
+        create: UpsertCreate<keyof Update, CreateData<T>> | ((update: Update) => UpsertCreate<keyof Update, CreateData<T>>);
     }): UpsertResult<T>;
 }
 declare const QueryUpsert: QueryUpsert;
@@ -7282,7 +9064,7 @@ interface QueryOrCreate {
      *
      * @param data - the same data as for `create`, it may be returned from a callback
      */
-    orCreate<T extends UpsertThis$1, BT extends CreateBelongsToData<T>>(this: T, data: OrCreateArg<CreateData<T, BT>>): UpsertResult$1<T>;
+    orCreate<T extends UpsertThis$1>(this: T, data: OrCreateArg<CreateData<T>>): UpsertResult$1<T>;
 }
 declare const QueryOrCreate: QueryOrCreate;
 
@@ -8707,9 +10489,9 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
         point(): PostgisGeographyPointColumn<SchemaConfig>;
     };
 }
-declare const makeColumnTypes: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>(schema: SchemaConfig) => DefaultColumnTypes<SchemaConfig>;
+declare const makeColumnTypes: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, ColumnDataBase>>>(schema: SchemaConfig) => DefaultColumnTypes<SchemaConfig>;
 
-declare const simplifyColumnDefault: (value?: string) => RawSQL<orchid_core.QueryColumn<unknown, any>, DefaultColumnTypes<orchid_core.ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>> | undefined;
+declare const simplifyColumnDefault: (value?: string) => RawSQL<QueryColumn<unknown, any>, DefaultColumnTypes<ColumnSchemaConfig<ColumnTypeBase<ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, ColumnDataBase>>>> | undefined;
 declare const assignDbDataToColumn: (column: ColumnTypeBase, params: ColumnFromDbParams) => ColumnTypeBase;
 
 interface ColumnsShape {
@@ -8981,4 +10763,4 @@ type CopyResult<T extends PickQueryMeta> = SetQueryKind<T, 'copy'>;
  */
 declare function copyTableData<T extends PickQueryMetaShape>(query: T, arg: CopyArg<T>): CopyResult<T>;
 
-export { type AddQueryDefaults, AfterCommitError, type AfterCommitErrorFulfilledResult, type AfterCommitErrorHandler, type AfterCommitErrorRejectedResult, type AfterCommitErrorResult, type AfterHook, type AggregateArgTypes, AggregateMethods, type AggregateOptions, ArrayColumn, type ArrayColumnValue, type ArrayData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, type BooleanQueryColumn, BoxColumn, ByteaColumn, type ChangeCountArg, CidrColumn, CircleColumn, CitextColumn, Clear, type ClearStatement, type ColumnData, type ColumnDataGenerated, type ColumnFromDbParams, ColumnRefExpression, ColumnType, type ColumnsByType, type ColumnsShape, type ColumnsShapeToNullableObject, type ColumnsShapeToObject, type ColumnsShapeToObjectArray, type ColumnsShapeToPluck, ComputedColumn, type ComputedColumns, type ComputedColumnsFromOptions, type ComputedMethods, type ComputedOptionsConfig, type ComputedOptionsFactory, type CopyOptions, type CreateBelongsToData, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbDomainArgRecord, type DbExtension, type DbOptions, type DbOptionsWithAdapter, type DbResult, type DbSharedOptions, type DbSqlQuery, type DbStructureDomainsMap, type DbTableConstructor, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultSchemaConfig, Delete, type DeleteArgs, type DeleteMethodsNames, type DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionMethods, type ExpressionOutput, FnExpression, type FnExpressionArgs, type FnExpressionArgsPairs, type FnExpressionArgsValue, For, type FromArg, FromMethods, type FromQuerySelf, type FromResult, type GeneratedColumn, type GeneratorIgnore, type GetArg, type GetColumnInfo, type GetResult, type GetResultOptional, type GetStringArg, type GroupArgs, type HandleResult, Having, type HavingItem, type HookAction, type HookSelectArg, type IdentityColumn, InetColumn, type InsertQueryDataObjectValues, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsolationLevel, JSONColumn, JSONTextColumn, Join, type JoinArgToQuery, type JoinArgs, type JoinCallback, type JoinFirstArg, type JoinItem, type JoinItemArgs, type JoinLateralResult, type JoinQueryBuilder, type JoinQueryMethod, type JoinResult, type JoinResultFromArgs, type JoinResultRequireMain, type JoinResultSelectable, type JoinedParsers, type JoinedShapes, JsonMethods, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MergeQuery, MergeQueryMethods, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, type NumericColumns, type OnConflictMerge, type OnConflictSet$1 as OnConflictSet, type OnConflictTarget, OnMethods, type Operator, Operators, type OperatorsAny, type OperatorsArray, type OperatorsBoolean, type OperatorsDate, type OperatorsJson, type OperatorsNumber, type OperatorsOrdinalText, type OperatorsText, type OperatorsTime, OrExpression, type OrderArg, type OrderArgSelf, type OrderArgs, type OrderItem, type OrderTsQueryConfig, type Over, PathColumn, type PickColumnData, type PickQueryBaseQuery, type PickQueryDataShapeAndJoinedShapes, type PickQueryDataShapeAndJoinedShapesAndAliases, type PickQueryInternal, type PickQueryQ, type PickQueryQAndBaseQuery, type PickQueryQAndInternal, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type PostgisPoint, type Query, type QueryAfterHook, QueryAsMethods, type QueryBatchResult, type QueryBeforeHook, type QueryBeforeHookInternal, type QueryBuilder, type QueryComputedArg, type QueryData, type QueryDataFromItem, type QueryDataJoinTo, type QueryDefaultReturnData, QueryGet, type QueryGetSelf, type QueryHelperResult, QueryHooks, type QueryIfResultThen, type QueryInternal, QueryLog, type QueryMetaHasSelect, type QueryMetaHasWhere, QueryMethods, type QueryOrExpressionBooleanOrNullResult, type QueryScopeData, type QueryScopes, type QuerySourceItem, type QueryTake, type QueryTakeOptional, QueryUpsert, RawSQL, RealColumn, type RecordOfColumnsShapeBase, RefExpression, type ReturnsQueryOrExpression, type RuntimeComputedQueryColumn, type SearchArg, SearchMethods, type SearchWeight, type SearchWeightRecord, Select, type SelectArg, type SelectArgs, type SelectAs, type SelectAsArg, type SelectAsFnArg, type SelectAsValue, type SelectItem, type SelectSelf, type SelectSubQueryResult, type SelectableFromShape, type SelectableOfType, type SelectableOrExpression, type SelectableOrExpressionOfType, type SelectableOrExpressions, SerialColumn, type SerialColumnData, type SetQueryKind, type SetQueryKindResult, type SetQueryReturnsAll, type SetQueryReturnsAllKind, type SetQueryReturnsAllKindResult, type SetQueryReturnsColumnInfo, type SetQueryReturnsColumnKind, type SetQueryReturnsColumnKindResult, type SetQueryReturnsColumnOptional, type SetQueryReturnsColumnOrThrow, type SetQueryReturnsOneKind, type SetQueryReturnsOneKindResult, type SetQueryReturnsPluck, type SetQueryReturnsPluckColumn, type SetQueryReturnsPluckColumnKind, type SetQueryReturnsPluckColumnKindResult, type SetQueryReturnsRowCount, type SetQueryReturnsRowCountMany, type SetQueryReturnsRows, type SetQueryReturnsValueOptional, type SetQueryReturnsValueOrThrow, type SetQueryReturnsValueOrThrowKind, type SetQueryReturnsVoid, type SetQueryReturnsVoidKind, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, type SortDir, type SqlFn, SqlMethod, StringColumn$1 as StringColumn, TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, TextBaseColumn, TextColumn, type TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, type ToSQLCtx, type ToSQLOptions, type ToSQLQuery, Transaction, type TransactionOptions, TransformMethods, TsQueryColumn, TsVectorColumn, UUIDColumn, Union, type UnionArgs, type UnionItem, type UnionKind, type UnionSet, type UniqueConstraints, type UniqueQueryTypeOrExpression, type UniqueTableDataItem, UnknownColumn, Update, type UpdateArg, type UpdateCtx, type UpdateCtxCollect, type UpdateData, type UpdateQueryDataItem, type UpdateQueryDataObject, type UpdateSelf, type UpdatedAtDataInjector, type UpsertResult, type UpsertThis, VarCharColumn, VirtualColumn, Where, type WhereArg, type WhereArgs, type WhereInArg, type WhereInColumn, type WhereInItem, type WhereInValues, type WhereItem, type WhereJsonPathEqualsItem, type WhereNotArgs, type WhereOnItem, type WhereOnJoinItem, type WhereQueryBuilder, type WhereResult, type WhereSearchItem, type WhereSearchResult, type WindowArg, type WindowArgDeclaration, type WindowDeclaration, type WindowItem, type WithArgsOptions, type WithConfig, type WithConfigs, type WithItem, type WithItems, WithMethods, type WithOptions, type WithQueryBuilder, type WithRecursiveOptions, type WithResult, type WithSqlResult, type WrapQueryArg, XMLColumn, _addWith, _clone, _getSelectableColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryChangeCounter, _queryCreate, _queryCreateForEachFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateOneFrom, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertOneFrom, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _querySelectAll, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotOneOf, _queryWhereNotSql, _queryWhereOneOf, _queryWhereSql, _runAfterCommitHooks, addColumnParserToQuery, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, applyComputedColumns, assignDbDataToColumn, checkIfASimpleQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnExcludesToCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDbWithAdapter, defaultSchemaConfig, escapeForLog, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, extendQuery, filterResult, foreignKeyArgumentToCode, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getFullColumnTable, getQueryAs, getShapeFromSelect, getSqlText, handleResult, identityToCode, indexInnerToCode, indexToCode, isDefaultTimeStamp, isInUserTransaction, isQueryReturnsAll, isSelectingCount, joinSubQuery, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, moveQueryValueToWith, parseRecord, parseTableData, parseTableDataInput, performQuery, postgisTypmodToSql, primaryKeyInnerToCode, processComputedBatches, processComputedResult, processSelectArg, pushLimitSQL, pushQueryArrayImmutable, pushQueryOn, pushQueryOnForOuter, pushQueryOrOn, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, raw, referencesArgsToCode, resolveSubQueryCallbackV2, rollbackSql, saveAliasedShape, setColumnDefaultParse, setColumnEncode, setColumnParse, setColumnParseNull, setParserForSelectedString, setQueryObjectValueImmutable, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfJoinLateral, throwIfNoWhere, toSQL };
+export { type AdapterBase, type AdapterConfigBase, type AddQueryDefaults, AfterCommitError, type AfterCommitErrorFulfilledResult, type AfterCommitErrorHandler, type AfterCommitErrorRejectedResult, type AfterCommitErrorResult, type AfterCommitHook, type AfterCommitStandaloneHook, type AfterHook, type AggregateArgTypes, AggregateMethods, type AggregateOptions, type AliasOrTable, ArrayColumn, type ArrayColumnValue, type ArrayData, type ArrayMethodsData, type AsQueryArg, type AsTypeArg, type BaseNumberData, type BatchParser, type BatchParsers, type BatchSql, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, type BooleanQueryColumn, BoxColumn, ByteaColumn, type ChangeCountArg, CidrColumn, CircleColumn, CitextColumn, Clear, type ClearStatement, type Code, type Codes, type ColumnData, type ColumnDataAppReadOnly, type ColumnDataBase, type ColumnDataCheckBase, type ColumnDataGenerated, type ColumnFromDbParams, type ColumnInputOutputQueryTypes, type ColumnInputOutputQueryTypesWithSchemas, type ColumnNameOfTable, type ColumnParser, ColumnRefExpression, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnShapeInput, type ColumnShapeInputPartial, type ColumnShapeOutput, type ColumnToCodeCtx, ColumnType, ColumnTypeBase, type ColumnTypeSchemaArg, type ColumnTypesBase, type ColumnWithDefault, type ColumnsByType, type ColumnsParsers, type ColumnsShape, type ColumnsShapeBase, type ColumnsShapeToNullableObject, type ColumnsShapeToObject, type ColumnsShapeToObjectArray, type ColumnsShapeToPluck, ComputedColumn, type ComputedColumns, type ComputedColumnsFromOptions, type ComputedMethods, type ComputedOptionsConfig, type ComputedOptionsFactory, type CopyOptions, type CoreQueryScopes, type CreateBelongsToData, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, type CteTableHook, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, type DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbDomainArgRecord, type DbExtension, type DbOptions, type DbOptionsWithAdapter, type DbResult, type DbSharedOptions, type DbSqlQuery, type DbStructureDomainsMap, type DbTableConstructor, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultSchemaConfig, type DefaultSelectColumns, type DefaultSelectOutput, type DelayedRelationSelect, Delete, type DeleteArgs, type DeleteMethodsNames, type DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, type DynamicSQLArg, type EmptyObject, type EmptyTuple, type EncodeColumn, EnumColumn, type ErrorMessage, type ErrorMessages, Expression, type ExpressionChain, type ExpressionData, ExpressionMethods, type ExpressionOutput, ExpressionTypeMethod, FnExpression, type FnExpressionArgs, type FnExpressionArgsPairs, type FnExpressionArgsValue, type FnUnknownToUnknown, For, type ForeignKeyTable, type FromArg, FromMethods, type FromQuerySelf, type FromResult, type GeneratedColumn, type GeneratorIgnore, type GetArg, type GetColumnInfo, type GetResult, type GetResultOptional, type GetStringArg, type GroupArgs, type HandleResult, type HasCteHooks, Having, type HavingItem, type HookAction, type HookSelect, type HookSelectArg, type HookSelectValue, type IdentityColumn, InetColumn, type InsertQueryDataObjectValues, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQueries, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, Join, type JoinArgToQuery, type JoinArgs, type JoinCallback, type JoinFirstArg, type JoinItem, type JoinItemArgs, type JoinLateralResult, type JoinQueryBuilder, type JoinQueryMethod, type JoinResult, type JoinResultFromArgs, type JoinResultRequireMain, type JoinResultSelectable, type JoinedParsers, type JoinedShapes, JsonMethods, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, type NullableColumn, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, type NumericColumns, type OnConflictMerge, type OnConflictSet$1 as OnConflictSet, type OnConflictTarget, OnMethods, type Operator, type OperatorToSQL, Operators, type OperatorsAny, type OperatorsArray, type OperatorsBoolean, type OperatorsDate, type OperatorsJson, type OperatorsNullable, type OperatorsNumber, type OperatorsOrdinalText, type OperatorsText, type OperatorsTime, OrExpression, OrchidOrmError, OrchidOrmInternalError, type OrderArg, type OrderArgSelf, type OrderArgs, type OrderItem, type OrderTsQueryConfig, type Over, type ParseColumn, type ParseNullColumn, PathColumn, type PickColumnBaseData, type PickColumnData, type PickOutputType, type PickOutputTypeAndOperators, type PickQueryBaseQuery, type PickQueryColumnTypes, type PickQueryDataShapeAndJoinedShapes, type PickQueryDataShapeAndJoinedShapesAndAliases, type PickQueryInputType, type PickQueryInternal, type PickQueryMeta, type PickQueryMetaColumnTypes, type PickQueryMetaRelations, type PickQueryMetaRelationsResult, type PickQueryMetaRelationsResultReturnType, type PickQueryMetaRelationsReturnType, type PickQueryMetaResult, type PickQueryMetaResultRelations, type PickQueryMetaResultRelationsWindows, type PickQueryMetaResultRelationsWindowsColumnTypes, type PickQueryMetaResultRelationsWithDataReturnType, type PickQueryMetaResultRelationsWithDataReturnTypeShape, type PickQueryMetaResultReturnType, type PickQueryMetaResultReturnTypeWithDataWindows, type PickQueryMetaResultReturnTypeWithDataWindowsThen, type PickQueryMetaResultWindows, type PickQueryMetaReturnType, type PickQueryMetaShape, type PickQueryMetaShapeRelationsReturnType, type PickQueryMetaShapeRelationsWithData, type PickQueryMetaTable, type PickQueryMetaTableShape, type PickQueryMetaTableShapeReturnTypeWithData, type PickQueryMetaWithData, type PickQueryMetaWithDataColumnTypes, type PickQueryQ, type PickQueryQAndBaseQuery, type PickQueryQAndInternal, type PickQueryRelationQueries, type PickQueryRelations, type PickQueryRelationsWithData, type PickQueryResult, type PickQueryResultColumnTypes, type PickQueryResultReturnType, type PickQueryResultReturnTypeUniqueColumns, type PickQueryReturnType, type PickQueryShape, type PickQueryShapeResultReturnTypeSinglePrimaryKey, type PickQueryShapeResultSinglePrimaryKey, type PickQueryShapeSinglePrimaryKey, type PickQuerySinglePrimaryKey, type PickQueryTable, type PickQueryTableMetaResult, type PickQueryTableMetaResultInputType, type PickQueryTableMetaResultReturnTypeWithDataWindowsThen, type PickQueryTableMetaResultShape, type PickQueryTableMetaShape, type PickQueryUniqueProperties, type PickQueryWindows, type PickQueryWithData, type PickQueryWithDataColumnTypes, type PickType, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type PostgisPoint, type PrimaryKeyColumn, type Query, type QueryAfterHook, type QueryArraysResult, QueryAsMethods, type QueryBase, type QueryBaseCommon, type QueryBatchResult, type QueryBeforeHook, type QueryBeforeHookInternal, type QueryBuilder, type QueryCatch, type QueryColumn, type QueryColumnInit, type QueryColumnOfDataType, type QueryColumnToNullable, type QueryColumns, type QueryColumnsInit, type QueryComputedArg, type QueryData, type QueryDataAliases, type QueryDataBase, type QueryDataFromItem, type QueryDataJoinTo, type QueryDataTransform, type QueryDefaultReturnData, QueryError, type QueryErrorName, QueryGet, type QueryGetSelf, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryIfResultThen, type QueryInternal, type QueryInternalBase, QueryLog, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryMetaBase, type QueryMetaHasSelect, type QueryMetaHasWhere, type QueryMetaIsSubQuery, QueryMethods, type QueryOrExpression, type QueryOrExpressionBooleanOrNullResult, type QueryResult, type QueryResultRow, type QueryReturnType, type QueryReturnTypeAll, type QueryReturnTypeOptional, type QueryScopeData, type QueryScopes, type QuerySourceItem, type QueryTake, type QueryTakeOptional, type QueryThen, type QueryThenByQuery, type QueryThenByReturnType, type QueryThenShallowSimplify, type QueryThenShallowSimplifyArr, type QueryThenShallowSimplifyOptional, QueryUpsert, RawSQL, RawSQLBase, type RawSQLValues, RealColumn, type RecordBoolean, type RecordKeyTrue, type RecordOfColumnsShapeBase, type RecordOptionalString, type RecordString, type RecordUnknown, RefExpression, type RelationConfigBase, type RelationConfigDataForCreate, type RelationConfigQuery, type RelationJoinQuery, type RelationsBase, type ReturnsQueryOrExpression, type RuntimeComputedQueryColumn, type SQLArgs, type SQLQueryArgs, type SearchArg, SearchMethods, type SearchWeight, type SearchWeightRecord, Select, type SelectArg, type SelectArgs, type SelectAs, type SelectAsArg, type SelectAsFnArg, type SelectAsValue, type SelectItem, type SelectSelf, type SelectSubQueryResult, type SelectableBase, type SelectableFromShape, type SelectableOfType, type SelectableOrExpression, type SelectableOrExpressionOfType, type SelectableOrExpressions, SerialColumn, type SerialColumnData, type SetQueryKind, type SetQueryKindResult, type SetQueryReturnsAll, type SetQueryReturnsAllKind, type SetQueryReturnsAllKindResult, type SetQueryReturnsColumnInfo, type SetQueryReturnsColumnKind, type SetQueryReturnsColumnKindResult, type SetQueryReturnsColumnOptional, type SetQueryReturnsColumnOrThrow, type SetQueryReturnsOneKind, type SetQueryReturnsOneKindResult, type SetQueryReturnsPluck, type SetQueryReturnsPluckColumn, type SetQueryReturnsPluckColumnKind, type SetQueryReturnsPluckColumnKindResult, type SetQueryReturnsRowCount, type SetQueryReturnsRowCountMany, type SetQueryReturnsRows, type SetQueryReturnsValueOptional, type SetQueryReturnsValueOrThrow, type SetQueryReturnsValueOrThrowKind, type SetQueryReturnsVoid, type SetQueryReturnsVoidKind, type SetQueryTableAlias, type ShallowSimplify, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SimpleJoinItemNonSubQueryArgs, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type SortDir, type Sql, type SqlFn, SqlMethod, type StaticSQLArgs, StringColumn$1 as StringColumn, type StringTypeData, TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TableHook, type TemplateLiteralArgs, TextBaseColumn, TextColumn, type TextColumnData, Then, TimeColumn, type TimeInterval, TimestampColumn, type TimestampHelpers, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSQLOptions, type ToSQLQuery, Transaction, type TransactionAfterCommitHook, type TransactionOptions, type TransactionState, TransformMethods, TsQueryColumn, TsVectorColumn, UUIDColumn, UnhandledTypeError, Union, type UnionArgs, type UnionItem, type UnionKind, type UnionSet, type UnionToIntersection, type UniqueColumn, type UniqueConstraints, type UniqueQueryTypeOrExpression, type UniqueTableDataItem, UnknownColumn, Update, type UpdateArg, type UpdateCtx, type UpdateCtxCollect, type UpdateData, type UpdateQueryDataItem, type UpdateQueryDataObject, type UpdateSelf, type UpdatedAtDataInjector, type UpsertResult, type UpsertThis, ValExpression, VarCharColumn, VirtualColumn, Where, type WhereArg, type WhereArgs, type WhereInArg, type WhereInColumn, type WhereInItem, type WhereInValues, type WhereItem, type WhereJsonPathEqualsItem, type WhereNotArgs, type WhereOnItem, type WhereOnJoinItem, type WhereQueryBuilder, type WhereResult, type WhereSearchItem, type WhereSearchResult, type WindowArg, type WindowArgDeclaration, type WindowDeclaration, type WindowItem, type WithArgsOptions, type WithConfig, type WithConfigs, type WithDataItem, type WithDataItems, type WithItem, type WithItems, WithMethods, type WithOptions, type WithQueryBuilder, type WithRecursiveOptions, type WithResult, type WithSqlResult, type WrapQueryArg, XMLColumn, _addToHookSelect, _addToHookSelectWithTable, _addWith, _applyRelationAliases, _checkIfAliased, _clone, _copyQueryAliasToQuery, _getQueryAliasOrName, _getQueryAs, _getQueryFreeAlias, _getQueryOuterAliases, _getSelectableColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryChangeCounter, _queryCreate, _queryCreateForEachFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateOneFrom, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertOneFrom, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _querySelectAll, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotOneOf, _queryWhereNotSql, _queryWhereOneOf, _queryWhereSql, _runAfterCommitHooks, _setQueryAlias, _setQueryAs, _setSubQueryAliases, addCode, addColumnParserToQuery, addParserForRawExpression, addParserForSelectItem, addQueryOn, addValue, anyShape, applyComputedColumns, applyMixins, applyTransforms, arrayDataToCode, assignDbDataToColumn, backtickQuote, callWithThis, checkIfASimpleQuery, cloneQueryBaseUnscoped, codeToString, colors, columnCheckToCode, columnCode, columnDefaultArgumentToCode, columnErrorMessagesToCode, columnExcludesToCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, consumeColumnName, copyTableData, countSelect, createDbWithAdapter, dateDataToCode, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForLog, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, exhaustive, extendQuery, filterResult, foreignKeyArgumentToCode, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getDefaultLanguage, getFreeAlias, getFreeSetAlias, getFullColumnTable, getImportPath, getPrimaryKeys, getQueryAs, getQueryParsers, getShapeFromSelect, getSqlText, getStackTrace, getValueKey, handleResult, identityToCode, indexInnerToCode, indexToCode, isDefaultTimeStamp, isExpression, isInUserTransaction, isIterable, isObjectEmpty, isQueryReturnsAll, isRawSQL, isRelationQuery, isSelectingCount, isTemplateLiteralArgs, joinSubQuery, joinTruthy, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeFnExpression, moveQueryValueToWith, newDelayedRelationSelect, noop, numberDataToCode, objectHasValues, omit, parseRecord, parseTableData, parseTableDataInput, pathToLog, performQuery, pick, pluralize, postgisTypmodToSql, primaryKeyInnerToCode, processComputedBatches, processComputedResult, processSelectArg, pushColumnData, pushLimitSQL, pushOrNewArray, pushOrNewArrayToObjectImmutable, pushQueryArrayImmutable, pushQueryOn, pushQueryOnForOuter, pushQueryOrOn, pushQueryValueImmutable, pushTableDataCode, queryColumnNameToKey, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quoteObjectKey, raw, referencesArgsToCode, requirePrimaryKeys, resolveSubQueryCallbackV2, returnArg, rollbackSql, saveAliasedShape, setColumnData, setColumnDefaultParse, setColumnEncode, setColumnParse, setColumnParseNull, setConnectRetryConfig, setCurrentColumnName, setDataValue, setDefaultLanguage, setDefaultNowFn, setDelayedRelation, setObjectValueImmutable, setParserForSelectedString, setParserToQuery, setQueryObjectValueImmutable, setQueryOperators, simplifyColumnDefault, singleQuote, singleQuoteArray, snakeCaseKey, spreadObjectValues, sqlFn, sqlQueryArgsToExpression, stringDataToCode, tableDataMethods, templateLiteralSQLToCode, templateLiteralToSQL, testTransaction, throwIfJoinLateral, throwIfNoWhere, timestampHelpers, toArray, toCamelCase, toPascalCase, toSQL, toSnakeCase, toSubSqlText, wrapAdapterFnWithConnectRetry };