pqb 0.67.6 → 0.68.0

package/dist/internal.d.ts

@@ -1,4 +1,4 @@
-import { Adapter, AdapterClass, AdapterConfigBase, AdapterParams, AdapterSchemaConfigOptions, AfterCommitStandaloneHook, AfterHook, ArrayColumn, ArrayColumnValue, ArrayData, AsyncState, BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, Code, Codes, Column, ColumnFromDbParams, ColumnSchemaConfig, ColumnSchemaGetterColumns, ColumnSchemaGetterTableClass, ColumnToCodeCtx, ColumnTypeSchemaArg, ColumnsByType, ColumnsShape, ComputedColumnsFromOptions, ComputedOptionsConfig, ComputedOptionsFactory, CreateCtx, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, CustomTypeColumn, DateColumn, DateColumnData, DbDomainArg, DbExtension, DbOptions, DbResult, DbSharedOptions, DbSqlMethod, DbStructureDomainsMap, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultPrivileges, DefaultSchemaConfig, DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, DriverAdapter, DynamicRawSQL, EmptyObject, EmptyTuple, EnumColumn, Expression, ExpressionData, FromArg, FromResult, GeneratorIgnore, HookSelectValue, InetColumn, IntegerColumn, IntervalColumn, IsQuery, IsolationLevel, JSONColumn, JSONTextColumn, JoinQueryMethod, JoinedShapes, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MaybeArray, MaybePromise, MergeQuery, MoneyColumn, NoPrimaryKeyOption, NonUniqDataItem, NumberColumnData, Operators, OperatorsArray, OperatorsJson, OperatorsOrdinalText, Ord, PathColumn, PickQueryInputType, PickQueryInternal, PickQueryQ, PickQueryRelations, PickQuerySelectableRelations, PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryHookUtils, QueryHooks, QueryInternal, QueryLogObject, QueryLogOptions, QueryLogger, QueryManyTake, QueryManyTakeOptional, QueryOrExpression, QueryResult, QueryResultRow, QueryReturnType, QuerySchema, QueryScopes, RawSql, RawSqlBase, RealColumn, RecordKeyTrue, RecordOptionalString, RecordString, RecordStringOrNumber, RecordUnknown, RelationConfigBase, RelationJoinQuery, RelationsBase, Rls, RlsPolicy, SchemaConfigFnWithOptions, SearchWeight, SelectableFromShape, SerialColumn, SerialColumnData, ShallowSimplify, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SingleSql, SingleSqlItem, SmallIntColumn, SmallSerialColumn, Sql, SqlFn, SqlSessionState, StorageOptions, StringColumn, StringData, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TemplateLiteralArgs, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, Timestamps, ToSQLCtx, ToSqlValues, TransactionAdapter, TransactionAdapterClass, TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, UniqueConstraints, UniqueTableDataItem, UnknownColumn, UpdateData, UpsertData, UpsertThis, VarCharColumn, VirtualColumn, WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry } from "./index.d.ts";
+import { Adapter, AdapterClass, AdapterConfigBase, AdapterParams, AdapterSchemaConfigOptions, AfterCommitStandaloneHook, AfterHook, ArrayColumn, ArrayColumnValue, ArrayData, AsyncState, BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, Code, Codes, Column, ColumnFromDbParams, ColumnSchemaConfig, ColumnSchemaGetterColumns, ColumnSchemaGetterTableClass, ColumnToCodeCtx, ColumnTypeSchemaArg, ColumnsByType, ColumnsShape, ComputedColumnsFromOptions, ComputedOptionsConfig, ComputedOptionsFactory, CreateCtx, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, CustomTypeColumn, DateColumn, DateColumnData, DbDomainArg, DbExtension, DbOptions, DbResult, DbSharedOptions, DbSqlMethod, DbStructureDomainsMap, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultPrivileges, DefaultSchemaConfig, DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, DriverAdapter, DynamicRawSQL, EmptyObject, EmptyTuple, EnumColumn, Expression, ExpressionData, FromArg, FromResult, GeneratorIgnore, HookSelectValue, InetColumn, IntegerColumn, IntervalColumn, IsQuery, IsolationLevel, JSONColumn, JSONTextColumn, JoinQueryMethod, JoinedShapes, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MaybeArray, MaybePromise, MergeQuery, MoneyColumn, NoPrimaryKeyOption, NonUniqDataItem, NumberColumnData, Operators, OperatorsArray, OperatorsJson, OperatorsOrdinalText, OperatorsText, Ord, PathColumn, PickQueryInputType, PickQueryInternal, PickQueryQ, PickQueryRelations, PickQuerySelectableRelations, PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryHookUtils, QueryHooks, QueryInternal, QueryLogObject, QueryLogOptions, QueryLogger, QueryManyTake, QueryManyTakeOptional, QueryOrExpression, QueryResult, QueryResultRow, QueryReturnType, QuerySchema, QueryScopes, RawSql, RawSqlBase, RealColumn, RecordKeyTrue, RecordOptionalString, RecordString, RecordStringOrNumber, RecordUnknown, RelationConfigBase, RelationJoinQuery, RelationsBase, Rls, RlsPolicy, SchemaConfigFnWithOptions, SearchWeight, SelectableFromShape, SerialColumn, SerialColumnData, ShallowSimplify, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SingleSql, SingleSqlItem, SmallIntColumn, SmallSerialColumn, Sql, SqlFn, SqlSessionState, StorageOptions, StringColumn, StringData, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TemplateLiteralArgs, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, Timestamps, ToSQLCtx, ToSqlValues, TransactionAdapter, TransactionAdapterClass, TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, UniqueConstraints, UniqueTableDataItem, UnknownColumn, UpdateData, UpsertData, UpsertThis, VarCharColumn, VirtualColumn, WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry } from "./index.d.ts";
 import { AsyncLocalStorage } from "node:async_hooks";
 interface RelationJoinQuery$1 {
   (joiningQuery: IsQuery$1, baseQuery: IsQuery$1): IsQuery$1;
@@ -14,7 +14,6 @@ interface RelationConfigBase$1 extends IsQuery$1 {
   queryRelated(params: unknown): unknown;
   modifyRelatedQuery?(relatedQuery: IsQuery$1): (query: IsQuery$1) => void;
   omitForeignKeyInCreate: PropertyKey;
-  dataForCreate: unknown;
   dataForUpdate: unknown;
   dataForUpdateOne: unknown;
   primaryKeys: string[];
@@ -24,7 +23,13 @@ interface RelationConfigDataForCreate {
   nested: RecordUnknown$1;
 }
 interface RelationsBase$1 {
-  [K: string]: RelationConfigBase$1;
+  [relationName: string]: RelationConfigBase$1;
+}
+interface RelationsDataForCreateBase {
+  [relationName: string]: unknown;
+}
+interface RelationsDataForCreateOptionalBase {
+  [relationName: string]: unknown;
 }
 type RelationQueryMaybeSingle<T extends RelationConfigBase$1> = T['returnsOne'] extends true ? T['required'] extends true ? QueryManyTake$1<T['query']> : QueryManyTakeOptional$1<T['query']> : T['query'];
 interface SubQueryForSql extends ToSQLQuery {
@@ -34,6 +39,17 @@ interface HasBeforeAndBeforeSet {
   before?: QueryBeforeHook$1[];
   beforeSet?: QueryData$1['beforeSet'];
 }
+interface SqlJoinExpression<T extends Column$1.Pick.QueryColumn> extends Expression$1<T>, ExpressionTypeMethod {}
+declare class SqlJoinExpression<T extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn> extends Expression$1<T> {
+  items: readonly unknown[];
+  separator?: RawSqlBase$1 | undefined;
+  result: {
+    value: T;
+  };
+  q: ExpressionData$1;
+  constructor(items: readonly unknown[], separator?: RawSqlBase$1 | undefined);
+  makeSQL(ctx: ToSqlValues$1, quotedAs?: string): string;
+}
 /**
  * Expression for a SQL identifier reference.
  * Used to safely quote identifiers in raw SQL queries.
@@ -651,7 +667,7 @@ interface ColumnSchemaGetterTableClass$1 {
   createSchema(): unknown;
 }
 interface ColumnTypeSchemaArg$1 {
-  type: unknown;
+  __schemaType: unknown;
   nullable<T extends Column$1.Pick.ForNullable>(this: T): Column$1.Modifiers.Nullable<T, unknown, unknown, unknown>;
   encode: unknown;
   parse: unknown;
@@ -682,6 +698,7 @@ interface ColumnSchemaConfig$1<T extends Column$1.Pick.Data = Column$1.Pick.Data
   bit(max?: number): unknown;
   uuid(): unknown;
   json(): T;
+  jsonText(): T;
   inputSchema(this: ColumnSchemaGetterTableClass$1): unknown;
   outputSchema(this: ColumnSchemaGetterTableClass$1): unknown;
   querySchema(this: ColumnSchemaGetterTableClass$1): unknown;
@@ -928,16 +945,33 @@ interface NumberColumnData$1 extends BaseNumberData$1, Column$1.Data {
 interface SerialColumnData$1 extends NumberColumnData$1 {
   default: Expression$1;
 }
-declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig$1, SchemaType extends Schema['type']> extends Column$1<Schema, number, SchemaType, OperatorsNumber> {
+declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig$1, SchemaType extends Schema['__schemaType']> extends Column$1 {
+  __schema: Schema;
+  __type: number;
+  __inputType: number;
+  inputSchema: SchemaType;
   data: NumberColumnData$1;
+  __outputType: number;
+  outputSchema: SchemaType;
+  __queryType: number;
+  querySchema: SchemaType;
   operators: OperatorsNumber;
 }
 declare abstract class IntegerBaseColumn<Schema extends ColumnSchemaConfig$1> extends NumberBaseColumn<Schema, ReturnType<Schema['int']>> {
   data: NumberColumnData$1;
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
 }
-declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig$1, InputType = string | number> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber, InputType> {
+declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig$1, InputType = string | number> extends Column$1 {
+  __schema: Schema;
+  __type: string;
+  __inputType: InputType;
+  inputSchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsNumber;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: InputType;
+  querySchema: ReturnType<Schema['stringSchema']>;
   data: Column$1.Data;
   constructor(schema: Schema);
 }
@@ -947,6 +981,7 @@ interface DecimalColumnData$1 extends Column$1.Data {
 }
 declare class DecimalColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberAsStringBaseColumn<Schema> {
   data: DecimalColumnData$1;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsNumber;
   dataType: "numeric";
   constructor(schema: Schema, numericPrecision?: number, numericScale?: number);
@@ -956,35 +991,41 @@ declare class DecimalColumn$1<Schema extends ColumnSchemaConfig$1> extends Numbe
 type IdentityColumn<T extends Column$1.Pick.Data> = Column$1.Modifiers.Default<T, Expression$1>;
 declare class SmallIntColumn$1<Schema extends ColumnSchemaConfig$1> extends IntegerBaseColumn<Schema> {
   dataType: "int2";
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  identity<T extends Column$1>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
+  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
 }
 declare class IntegerColumn$1<Schema extends ColumnSchemaConfig$1> extends IntegerBaseColumn<Schema> {
   dataType: "int4";
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  identity<T extends Column$1>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
+  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
 }
 declare class BigIntColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberAsStringBaseColumn<Schema, string | number | bigint> {
   dataType: "int8";
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  identity<T extends Column$1>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
+  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
 }
 declare class RealColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
   dataType: "float4";
+  querySchema: ReturnType<Schema['number']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 declare class DoublePrecisionColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberAsStringBaseColumn<Schema> {
   dataType: "float8";
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 declare class SmallSerialColumn$1<Schema extends ColumnSchemaConfig$1> extends IntegerBaseColumn<Schema> {
   dataType: "int2";
   data: SerialColumnData$1;
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
@@ -992,6 +1033,7 @@ declare class SmallSerialColumn$1<Schema extends ColumnSchemaConfig$1> extends I
 declare class SerialColumn$1<Schema extends ColumnSchemaConfig$1> extends IntegerBaseColumn<Schema> {
   dataType: "int4";
   data: SerialColumnData$1;
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
@@ -999,14 +1041,23 @@ declare class SerialColumn$1<Schema extends ColumnSchemaConfig$1> extends Intege
 declare class BigSerialColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberAsStringBaseColumn<Schema> {
   dataType: "int8";
   data: SerialColumnData$1;
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 type DateColumnInput = string | number | Date;
-declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringNumberDate']>, OperatorsDate, DateColumnInput, string, ReturnType<Schema['stringSchema']>> {
+declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig$1> extends Column$1 {
   dateParsedByDriver?: boolean | undefined;
+  __schema: Schema;
+  __type: string;
+  __inputType: DateColumnInput;
+  inputSchema: ReturnType<Schema['stringNumberDate']>;
   data: DateColumnData$1;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: DateColumnInput;
+  querySchema: ReturnType<Schema['stringNumberDate']>;
   operators: OperatorsDate;
   asNumber: Schema['dateAsNumber'];
   asDate: Schema['dateAsDate'];
@@ -1036,42 +1087,66 @@ declare class TimestampTZColumn$1<Schema extends ColumnSchemaConfig$1> extends D
   baseDataType: "timestamp";
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class TimeColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsTime> {
+declare class TimeColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
+  __type: string;
+  __inputType: ReturnType<Schema['stringSchema']>;
+  inputSchema: ReturnType<Schema['stringSchema']>;
   data: DateColumnData$1 & {
     dateTimePrecision?: number;
   };
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   dataType: "time";
   operators: OperatorsTime;
   constructor(schema: Schema, dateTimePrecision?: number);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class IntervalColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, PostgresInterval, ReturnType<Schema['timeInterval']>, OperatorsDate, Partial<PostgresInterval>, PostgresInterval> {
+declare class IntervalColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
+  __type: PostgresInterval;
   data: Column$1.Data & {
     fields?: string;
     precision?: number;
   };
+  __inputType: Partial<PostgresInterval>;
+  inputSchema: ReturnType<Schema['timeInterval']>;
+  __outputType: PostgresInterval;
+  outputSchema: ReturnType<Schema['timeInterval']>;
+  __queryType: PostgresInterval;
+  querySchema: ReturnType<Schema['timeInterval']>;
   dataType: "interval";
   operators: OperatorsDate;
   constructor(schema: Schema, fields?: string, precision?: number, parse?: (input: string) => PostgresInterval);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
   toSQL(): string;
 }
-declare class EnumColumn$1<Schema extends ColumnTypeSchemaArg$1, SchemaType extends Schema['type'], const T extends readonly string[]> extends Column$1<Schema, T[number], SchemaType, OperatorsOrdinalText$1> {
+declare class EnumColumn$1<Schema extends ColumnTypeSchemaArg$1, SchemaType extends Schema['__schemaType'], const T extends readonly string[]> extends Column$1 {
   enumName: string;
   options: T;
+  __schema: Schema;
   operators: OperatorsOrdinalText$1;
+  __type: T[number];
+  __inputType: T[number];
+  inputSchema: SchemaType;
+  __outputType: T[number];
+  outputSchema: SchemaType;
+  __queryType: T[number];
+  querySchema: SchemaType;
   dataType: string;
   constructor(schema: Schema, enumName: string, options: T, schemaType: SchemaType);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
   toSQL(): string;
 }
 interface ArrayColumnValue$1 {
-  type: unknown;
+  __type: unknown;
   inputSchema: any;
-  inputType: unknown;
-  outputType: unknown;
+  __inputType: unknown;
+  __outputType: unknown;
   outputSchema: any;
-  queryType: any;
+  __queryType: any;
   querySchema: any;
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
@@ -1081,67 +1156,90 @@ interface ArrayData$1<Item extends ArrayColumnValue$1> extends Column$1.Data, Ar
   item: Item;
   arrayDims: number;
 }
-declare class ArrayColumn$1<Schema extends ColumnTypeSchemaArg$1, Item extends ArrayColumnValue$1, InputType, OutputType, QueryType> extends Column$1<Schema, Item['type'][], InputType, OperatorsArray$1<Item['queryType']>, Item['inputType'][], Item['outputType'][], OutputType, Item['queryType'][], QueryType> {
+declare class ArrayColumn$1<Schema extends ColumnTypeSchemaArg$1, Item extends ArrayColumnValue$1, InputType, OutputType, QueryType> extends Column$1 {
+  __schema: Schema;
   dataType: "array";
-  operators: OperatorsArray$1<Item["queryType"]>;
+  operators: OperatorsArray$1<Item["__queryType"]>;
   data: ArrayData$1<Item>;
-  constructor(schema: Schema, item: Item, inputType: InputType, defaultEncode?: (input: unknown) => unknown, outputType?: OutputType, queryType?: QueryType);
+  __type: Item['__type'][];
+  __inputType: Item['__type'][];
+  inputSchema: InputType;
+  __outputType: Item['__outputType'][];
+  outputSchema: OutputType;
+  __queryType: Item['__queryType'][];
+  querySchema: QueryType;
+  constructor(schema: Schema, item: Item, __inputType: InputType, defaultEncode?: (input: unknown) => unknown, __outputType?: OutputType, __queryType?: QueryType);
   toSQL(): string;
   toCode(this: ArrayColumn$1<ColumnSchemaConfig$1, ArrayColumnValue$1, unknown, unknown, unknown>, ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class JSONColumn$1<T, Schema extends ColumnTypeSchemaArg$1, InputSchema = Schema['type']> extends Column$1<Schema, T, InputSchema, OperatorsJson$1> {
+declare class JSONColumn$1<T, Schema extends ColumnTypeSchemaArg$1, InputSchema = Schema['__schemaType']> extends Column$1 {
+  __schema: Schema;
   dataType: "jsonb";
+  __type: T;
+  __inputType: T;
+  inputSchema: InputSchema;
+  __outputType: T;
+  outputSchema: InputSchema;
+  __queryType: T;
+  querySchema: InputSchema;
   operators: OperatorsJson$1;
-  constructor(schema: Schema, inputType: Schema['type'], encodedByDriver?: boolean);
+  constructor(schema: Schema, __inputType: InputSchema, encodedByDriver?: boolean);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class JSONTextColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, unknown, ReturnType<Schema['unknown']>, OperatorsText> {
+declare class JSONTextColumn$1<T, Schema extends ColumnTypeSchemaArg$1, InputSchema = Schema['__schemaType']> extends Column$1 {
+  __schema: Schema;
   dataType: "json";
-  operators: OperatorsText;
+  __type: T;
+  __inputType: T;
+  inputSchema: InputSchema;
+  __outputType: T;
+  outputSchema: InputSchema;
+  __queryType: T;
+  querySchema: InputSchema;
+  operators: OperatorsText$1;
   private static _instance;
-  static get instance(): JSONTextColumn$1<DefaultSchemaConfig$1>;
-  constructor(schema: Schema);
+  static get instance(): JSONTextColumn$1<unknown, DefaultSchemaConfig$1, unknown>;
+  constructor(schema: Schema, __inputType: InputSchema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 interface DefaultSchemaConfig$1 extends ColumnSchemaConfig$1<Column$1> {
-  parse<T extends Column$1.Pick.ForParse, Output>(this: T, fn: (input: T['type']) => Output): Column$1.Modifiers.Parse<T, unknown, Output>;
+  parse<T extends Column$1.Pick.ForParse, Output>(this: T, fn: (input: T['__type']) => Output): Column$1.Modifiers.Parse<T, unknown, Output>;
   parseNull<T extends Column$1.Pick.ForParseNull, Output>(this: T, fn: () => Output): Column$1.Modifiers.ParseNull<T, unknown, Output>;
-  encode<T extends {
-    type: unknown;
-  }, Input>(this: T, fn: (input: Input) => unknown): Column$1.Modifiers.Encode<T, unknown, Input>;
+  encode<T extends Column$1.Pick.Type, Input>(this: T, fn: (input: Input) => unknown): Column$1.Modifiers.Encode<T, unknown, Input>;
   /**
    * @deprecated use narrowType instead
    */
   asType<T, Types extends {
     type: unknown;
-    inputType: unknown;
-    outputType: unknown;
-    queryType: unknown;
+    __inputType: unknown;
+    __outputType: unknown;
+    __queryType: unknown;
   }>(this: T, _fn: (type: <Type, Input = Type, Output = Type, Query = Type>() => {
     type: Type;
-    inputType: Input;
-    outputType: Output;
-    queryType: Query;
-  }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K] };
-  narrowType<T extends Column$1.InputOutputQueryTypes, Types extends Column$1.InputOutputQueryTypes>(this: T, _fn: (type: <Type extends (T['inputType'] extends T['outputType'] & T['queryType'] ? T['outputType'] & T['queryType'] : T['inputType'] & T['outputType'] & T['queryType'])>() => {
-    inputType: T['inputType'] extends never ? never : Type;
-    outputType: Type;
-    queryType: Type;
+    __inputType: Input;
+    __outputType: Output;
+    __queryType: Query;
+  }) => Types): { [K in keyof T]: K extends '__type' ? Types['type'] : K extends keyof Types ? Types[K] : T[K] };
+  narrowType<T extends Column$1.InputOutputQueryTypes, Types extends Column$1.InputOutputQueryTypes>(this: T, _fn: (type: <Type extends (T['__inputType'] extends T['__outputType'] & T['__queryType'] ? T['__outputType'] & T['__queryType'] : T['__inputType'] & T['__outputType'] & T['__queryType'])>() => {
+    __inputType: T['__inputType'] extends never ? never : Type;
+    __outputType: Type;
+    __queryType: Type;
   }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K] };
   narrowAllTypes<T extends Column$1.InputOutputQueryTypes, Types extends Column$1.InputOutputQueryTypes>(this: T, _fn: (type: <Types extends {
-    input?: T['inputType'];
-    output?: T['outputType'];
-    query?: T['queryType'];
+    input?: T['__inputType'];
+    output?: T['__outputType'];
+    query?: T['__queryType'];
   }>() => {
-    inputType: undefined extends Types['input'] ? T['inputType'] : Types['input'];
-    outputType: undefined extends Types['output'] ? T['outputType'] : Types['output'];
-    queryType: undefined extends Types['query'] ? T['queryType'] : Types['query'];
+    __inputType: undefined extends Types['input'] ? T['__inputType'] : Types['input'];
+    __outputType: undefined extends Types['output'] ? T['__outputType'] : Types['output'];
+    __queryType: undefined extends Types['query'] ? T['__queryType'] : Types['query'];
   }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K] };
-  dateAsNumber<T extends Column$1>(this: T): Column$1.Modifiers.Parse<T, unknown, number>;
-  dateAsDate<T extends Column$1>(this: T): Column$1.Modifiers.Parse<T, unknown, Date>;
+  dateAsNumber<T extends Column$1.Pick.ForParse>(this: T): Column$1.Modifiers.Parse<T, unknown, number>;
+  dateAsDate<T extends Column$1.Pick.ForParse>(this: T): Column$1.Modifiers.Parse<T, unknown, Date>;
   enum<const T extends readonly [string, ...string[]]>(dataType: string, type: T): EnumColumn$1<DefaultSchemaConfig$1, unknown, T>;
   array<Item extends ArrayColumnValue$1>(item: Item): ArrayColumn$1<DefaultSchemaConfig$1, Item, unknown, unknown, unknown>;
   json<T>(): JSONColumn$1<unknown extends T ? MaybeArray$1<string | number | boolean | object> : T, DefaultSchemaConfig$1>;
+  jsonText<T>(): JSONTextColumn$1<unknown extends T ? MaybeArray$1<string | number | boolean | object> : T, DefaultSchemaConfig$1>;
   inputSchema(): undefined;
   outputSchema(): undefined;
   querySchema(): undefined;
@@ -1166,8 +1264,16 @@ interface DefaultSchemaConfig$1 extends ColumnSchemaConfig$1<Column$1> {
   timestamp(precision?: number): TimestampTZColumn$1<DefaultSchemaConfig$1>;
 }
 type TextColumnData = StringData$1;
-declare abstract class TextBaseColumn<Schema extends ColumnSchemaConfig$1, Ops = OperatorsText> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, Ops> {
+declare abstract class TextBaseColumn<Schema extends ColumnSchemaConfig$1, Ops = OperatorsText$1> extends Column$1 {
+  __schema: Schema;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
   data: TextColumnData;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: Ops;
   constructor(schema: Schema, schemaType?: ReturnType<Schema['stringSchema']>);
 }
@@ -1193,93 +1299,206 @@ declare class TextColumn$1<Schema extends ColumnSchemaConfig$1> extends TextBase
     minArg?: number;
     maxArg?: number;
   };
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   private static _instance;
   static get instance(): TextColumn$1<DefaultSchemaConfig$1>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class ByteaColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['buffer']>, OperatorsOrdinalText$1, Buffer, Buffer, ReturnType<Schema['buffer']>, string, ReturnType<Schema['stringSchema']>> {
+declare class ByteaColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "bytea";
   operators: OperatorsOrdinalText$1;
+  __type: string;
+  __inputType: Buffer;
+  inputSchema: ReturnType<Schema['buffer']>;
+  __outputType: Buffer;
+  outputSchema: ReturnType<Schema['buffer']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class PointColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class PointColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "point";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class LineColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class LineColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "line";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class LsegColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class LsegColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "lseg";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class BoxColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class BoxColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "box";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class PathColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class PathColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "path";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class PolygonColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class PolygonColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "polygon";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class CircleColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class CircleColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "circle";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class MoneyColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['number']>, OperatorsNumber, string | number, number, ReturnType<Schema['number']>, string | number> {
+declare class MoneyColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "money";
+  __type: string;
   data: NumberColumnData$1;
+  __inputType: string | number;
+  inputSchema: ReturnType<Schema['number']>;
+  __outputType: number;
+  outputSchema: ReturnType<Schema['number']>;
+  __queryType: string | number;
+  querySchema: ReturnType<Schema['number']>;
   operators: OperatorsNumber;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class CidrColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class CidrColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "cidr";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class InetColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText$1> {
+declare class InetColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "inet";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class MacAddrColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText$1> {
+declare class MacAddrColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "macaddr";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class MacAddr8Column$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText$1> {
+declare class MacAddr8Column$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "macaddr8";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class BitColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['bit']>, OperatorsOrdinalText$1> {
+declare class BitColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "bit";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['bit']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['bit']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['bit']>;
   operators: OperatorsOrdinalText$1;
   data: Column$1.Data & {
     length: number;
@@ -1288,8 +1507,16 @@ declare class BitColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
   toSQL(): string;
 }
-declare class BitVaryingColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['bit']>, OperatorsOrdinalText$1> {
+declare class BitVaryingColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "varbit";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['bit']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['bit']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['bit']>;
   operators: OperatorsOrdinalText$1;
   data: Column$1.Data & {
     length?: number;
@@ -1299,9 +1526,17 @@ declare class BitVaryingColumn$1<Schema extends ColumnSchemaConfig$1> extends Co
   toSQL(): string;
 }
 type TsVectorGeneratedColumns = string[] | SearchWeightRecord;
-declare class TsVectorColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText$1> {
+declare class TsVectorColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
   defaultLanguage: string;
+  __schema: Schema;
   dataType: "tsvector";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema, defaultLanguage?: string);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
@@ -1331,14 +1566,30 @@ declare class TsVectorColumn$1<Schema extends ColumnSchemaConfig$1> extends Colu
    */
   generated<T extends Column$1.Pick.Data>(this: T, ...args: StaticSQLArgs | [language: string, columns: TsVectorGeneratedColumns] | [columns: TsVectorGeneratedColumns]): Column$1.Modifiers.Generated<T>;
 }
-declare class TsQueryColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText$1> {
+declare class TsQueryColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "tsquery";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class UUIDColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['uuid']>, OperatorsOrdinalText$1> {
+declare class UUIDColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "uuid";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['uuid']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['uuid']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['uuid']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema);
   /**
@@ -1353,27 +1604,45 @@ declare class UUIDColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1
   };
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class XMLColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class XMLColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "xml";
-  operators: OperatorsText;
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
+  operators: OperatorsText$1;
   private static _instance;
   static get instance(): XMLColumn$1<DefaultSchemaConfig$1>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 declare class CitextColumn$1<Schema extends ColumnSchemaConfig$1> extends TextBaseColumn<Schema, OperatorsOrdinalText$1> {
+  __schema: Schema;
   dataType: "citext";
   data: TextColumnData & {
     minArg?: number;
     maxArg?: number;
   };
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText$1;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
-declare class BooleanColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
+declare class BooleanColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: "bool";
   operators: OperatorsBoolean;
+  __type: boolean;
+  __inputType: boolean;
+  inputSchema: ReturnType<Schema['boolean']>;
+  __outputType: boolean;
+  outputSchema: ReturnType<Schema['boolean']>;
+  __queryType: boolean;
+  querySchema: ReturnType<Schema['boolean']>;
   private static _instance;
   static get instance(): BooleanColumn$1<DefaultSchemaConfig$1>;
   constructor(schema: Schema);
@@ -1397,20 +1666,29 @@ interface TimestampHelpers {
     timestampNoTZ(): T;
   }): Timestamps$1<T>;
 }
-declare class CustomTypeColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, unknown, ReturnType<Schema['unknown']>, OperatorsAny> {
+declare class CustomTypeColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
   typeName: string;
   typeSchema?: string | undefined;
+  __schema: Schema;
   operators: OperatorsAny;
+  __type: unknown;
+  __inputType: unknown;
+  inputSchema: ReturnType<Schema['unknown']>;
+  __outputType: unknown;
+  outputSchema: ReturnType<Schema['unknown']>;
+  __queryType: unknown;
+  querySchema: ReturnType<Schema['unknown']>;
+  data: Column$1.Data;
   dataType: string;
   constructor(schema: Schema, typeName: string, typeSchema?: string | undefined, extension?: string);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
   as<T extends {
-    inputType: unknown;
-    outputType: unknown;
+    __inputType: unknown;
+    __outputType: unknown;
     data: Column$1.Data;
   }, C extends {
-    inputType: T['inputType'];
-    outputType: T['outputType'];
+    __inputType: T['__inputType'];
+    __outputType: T['__outputType'];
   }>(this: T, column: C): C;
 }
 declare class DomainColumn$1<Schema extends ColumnSchemaConfig$1> extends CustomTypeColumn$1<Schema> {
@@ -1421,8 +1699,16 @@ interface PostgisPoint {
   lat: number;
   srid?: number;
 }
-declare class PostgisGeographyPointColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1<Schema, PostgisPoint, ReturnType<Schema['geographyPointSchema']>, OperatorsAny> {
+declare class PostgisGeographyPointColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1 {
+  __schema: Schema;
   dataType: string;
+  __type: PostgisPoint;
+  __inputType: PostgisPoint;
+  inputSchema: ReturnType<Schema['geographyPointSchema']>;
+  __outputType: PostgisPoint;
+  outputSchema: ReturnType<Schema['geographyPointSchema']>;
+  __queryType: PostgisPoint;
+  querySchema: ReturnType<Schema['geographyPointSchema']>;
   operators: OperatorsAny;
   static encode: ({
     srid,
@@ -1480,7 +1766,7 @@ interface DefaultColumnTypes$1<SchemaConfig extends ColumnSchemaConfig$1> extend
   uuid(): UUIDColumn$1<SchemaConfig>;
   xml(): XMLColumn$1<SchemaConfig>;
   json: SchemaConfig['json'];
-  jsonText(): JSONTextColumn$1<SchemaConfig>;
+  jsonText: SchemaConfig['jsonText'];
   type(dataType: string): CustomTypeColumn$1<SchemaConfig>;
   domain(dataType: string): DomainColumn$1<SchemaConfig>;
   geography: {
@@ -1801,6 +2087,37 @@ declare class DynamicRawSQL$1<T extends Column$1.Pick.QueryColumn, ColumnTypes =
 }
 interface SqlFn$1 {
   <T, Args extends TemplateLiteralArgs$1 | [sql: string] | [values: RecordUnknown$1, sql?: string]>(this: T, ...args: Args): Args extends [RecordUnknown$1] ? (...sql: TemplateLiteralArgs$1) => RawSql$1<Column$1.Pick.QueryColumn, T> : RawSql$1<Column$1.Pick.QueryColumn, T>;
+  /**
+   * `sql.join` builds a SQL list from values and expressions.
+   * Plain values are bound as query parameters, while SQL expressions render as SQL.
+   *
+   * Use it for SQL constructs such as `ARRAY[...]`, `IN (...)`, function arguments,
+   * or tuple lists. The default separator is `, `. Provide a SQL expression as the
+   * custom separator when a different separator is needed.
+   *
+   * ```ts
+   * await db.user.whereSql`"id" IN (${sql.join([1, 2, 3])})`;
+   * ```
+   *
+   * ```ts
+   * await db.user.whereSql`
+   *   (${sql.join([sql.ref('name'), sql.ref('age')])}) IN (${sql.join(
+   *     users.map((user) => sql`(${user.name}, ${user.age})`),
+   *   )})
+   * `;
+   * ```
+   *
+   * ```ts
+   * await db.user.select({
+   *   displayName: (q) =>
+   *     sql<string>`concat(${sql.join(
+   *       [q.column('firstName'), q.column('lastName')],
+   *       sql` || ' ' || `,
+   *     )})`,
+   * });
+   * ```
+   */
+  join<T = unknown>(items: readonly unknown[], separator?: RawSqlBase$1): SqlJoinExpression<Column$1.Pick.QueryColumnOfType<T>>;
   /**
    * `sql.ref` quotes a SQL identifier such as a table name, column name, or schema name.
    * Use it when you need to dynamically reference an identifier in raw SQL.
@@ -1855,8 +2172,8 @@ interface QueryThen<T> {
 type QueryThenShallowSimplify<T> = QueryThen<ShallowSimplify$1<T>>;
 type QueryThenShallowSimplifyArr<T> = QueryThen<ShallowSimplify$1<T>[]>;
 type QueryThenShallowSimplifyOptional<T> = QueryThen<ShallowSimplify$1<T> | undefined>;
-type QueryThenByQuery<T extends PickQueryReturnType, Result extends Column$1.QueryColumns> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape$1.Output<Result>> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<Result>> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape$1.Output<Result>> : T['returnType'] extends 'value' ? QueryThen<Result['value']['outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<Result['value']['outputType']> : T['returnType'] extends 'rows' ? QueryThen<ColumnsShape$1.Output<Result>[keyof Result][][]> : T['returnType'] extends 'pluck' ? QueryThen<Result['pluck']['outputType'][]> : QueryThen<void>;
-type QueryThenByReturnType<T extends QueryReturnType$1, Result extends Column$1.QueryColumns> = T extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape$1.Output<Result>> : T extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<Result>> : T extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape$1.Output<Result>> : T extends 'value' ? QueryThen<Result['value']['outputType'] | undefined> : T extends 'valueOrThrow' ? QueryThen<Result['value']['outputType']> : T extends 'rows' ? QueryThen<ColumnsShape$1.Output<Result>[keyof Result][][]> : T extends 'pluck' ? QueryThen<Result['pluck']['outputType'][]> : QueryThen<void>;
+type QueryThenByQuery<T extends PickQueryReturnType, Result extends Column$1.QueryColumns> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape$1.Output<Result>> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<Result>> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape$1.Output<Result>> : T['returnType'] extends 'value' ? QueryThen<Result['value']['__outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<Result['value']['__outputType']> : T['returnType'] extends 'rows' ? QueryThen<ColumnsShape$1.Output<Result>[keyof Result][][]> : T['returnType'] extends 'pluck' ? QueryThen<Result['pluck']['__outputType'][]> : QueryThen<void>;
+type QueryThenByReturnType<T extends QueryReturnType$1, Result extends Column$1.QueryColumns> = T extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape$1.Output<Result>> : T extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<Result>> : T extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape$1.Output<Result>> : T extends 'value' ? QueryThen<Result['value']['__outputType'] | undefined> : T extends 'valueOrThrow' ? QueryThen<Result['value']['__outputType']> : T extends 'rows' ? QueryThen<ColumnsShape$1.Output<Result>[keyof Result][][]> : T extends 'pluck' ? QueryThen<Result['pluck']['__outputType'][]> : QueryThen<void>;
 interface QueryCatch {
   <Q, TResult = never>(this: {
     then: (onfulfilled?: (value: Q) => any) => any;
@@ -2742,7 +3059,7 @@ declare namespace Order {
   export type Arg<T extends ArgThis> = ArgKey<T> | ArgTsQuery<T> | { [K in ArgKey<T> | ArgTsQuery<T>]?: K extends ArgTsQuery<T> ? OrderTsQueryConfig : SortDir } | Expression$1;
   export type Args<T extends ArgThis> = Arg<T>[];
   type ArgTsQuery<T extends ArgThis> = string | undefined extends T['__tsQuery'] ? never : Exclude<T['__tsQuery'], undefined>;
-  type ArgKey<T extends ArgThis> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['queryType'] extends undefined ? never : K }[keyof T['__selectable']] | { [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K }[keyof T['result']];
+  type ArgKey<T extends ArgThis> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['__queryType'] extends undefined ? never : K }[keyof T['__selectable']] | { [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K }[keyof T['result']];
   export {};
 }
 declare class QueryOrder {
@@ -2848,40 +3165,40 @@ interface ColumnsShape$1 {
 }
 declare namespace ColumnsShape$1 {
   export type DefaultSelectKeys<S extends Column$1.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
-  export type DefaultOutput<Set extends Column$1.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['outputType'] };
-  export type Input<Shape extends Column$1.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'] };
-  export type InputPartial<Shape extends Column$1.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['inputType'] };
-  export type Output<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
-  export type DefaultSelectOutput<Shape extends Column$1.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['outputType'] };
+  export type DefaultOutput<Set extends Column$1.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
+  export type Input<Shape extends Column$1.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'] };
+  export type InputPartial<Shape extends Column$1.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
+  export type Output<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  export type DefaultSelectOutput<Shape extends Column$1.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['__outputType'] };
   export interface MapToObjectColumn<Shape extends Column$1.QueryColumns> {
     dataType: 'object';
-    type: { [K in keyof Shape]: Shape[K]['type'] };
-    outputType: ShallowSimplify$1<ObjectOutput<Shape>>;
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] };
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify$1<ObjectOutput<Shape>>;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
     operators: OperatorsAny;
   }
   export interface MapToNullableObjectColumn<Shape extends Column$1.QueryColumns> {
     dataType: 'object';
-    type: { [K in keyof Shape]: Shape[K]['type'] };
-    outputType: ShallowSimplify$1<ObjectOutput<Shape>> | undefined;
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] } | null;
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify$1<ObjectOutput<Shape>> | undefined;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
     operators: OperatorsAny;
   }
   export interface MapToPluckColumn<Shape extends Column$1.QueryColumns> {
     dataType: 'array';
-    type: Shape['pluck']['type'][];
-    outputType: Shape['pluck']['outputType'][];
-    queryType: Shape['pluck']['queryType'][];
+    __type: Shape['pluck']['__type'][];
+    __outputType: Shape['pluck']['__outputType'][];
+    __queryType: Shape['pluck']['__queryType'][];
     operators: OperatorsAny;
   }
   export interface MapToObjectArrayColumn<Shape extends Column$1.QueryColumns> {
     dataType: 'array';
-    type: { [K in keyof Shape]: Shape[K]['type'] }[];
-    outputType: ShallowSimplify$1<ObjectOutput<Shape>>[];
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] }[];
+    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
+    __outputType: ShallowSimplify$1<ObjectOutput<Shape>>[];
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
     operators: OperatorsAny;
   }
-  type ObjectOutput<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
+  type ObjectOutput<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
   export {};
 }
 interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape$1, PickQueryRelations$1, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
@@ -3306,16 +3623,16 @@ interface OperatorsCount extends OperatorsNumber {
 type CountColumn = Column$1.Pick.QueryColumnOfTypeAndOps<'int8', number, OperatorsCount>;
 type CountReturn<T> = SetQueryReturnsColumnOrThrow<T, CountColumn> & OperatorsCount;
 type SelectableDataType<T extends PickQuerySelectable, DataType extends string> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends DataType ? K : never }[keyof T['__selectable']] | Expression$1<Column$1.Pick.QueryColumnOfDataType<DataType>>;
-type NumericReturn<T extends PickQuerySelectable, Arg> = Arg extends keyof T['__selectable'] ? SetQueryReturnsColumnOrThrow<T, Column$1.Pick.QueryColumnOfTypeAndOps<T['__selectable'][Arg]['column']['dataType'], T['__selectable'][Arg]['column']['type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression$1 ? SetQueryReturnsColumnOrThrow<T, Column$1.Pick.QueryColumnOfTypeAndOps<Arg['result']['value']['dataType'], Arg['result']['value']['type'] | null, OperatorsNumber>> & OperatorsNumber : never;
+type NumericReturn<T extends PickQuerySelectable, Arg> = Arg extends keyof T['__selectable'] ? SetQueryReturnsColumnOrThrow<T, Column$1.Pick.QueryColumnOfTypeAndOps<T['__selectable'][Arg]['column']['dataType'], T['__selectable'][Arg]['column']['__type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression$1 ? SetQueryReturnsColumnOrThrow<T, Column$1.Pick.QueryColumnOfTypeAndOps<Arg['result']['value']['dataType'], Arg['result']['value']['__type'] | null, OperatorsNumber>> & OperatorsNumber : never;
 type NullableNumberReturn<T, DataType> = SetQueryReturnsColumnOrThrow<T, Column$1.Pick.QueryColumnOfTypeAndOps<DataType, number | null, OperatorsNumber>> & OperatorsNumber;
 type BooleanQueryColumn = Column$1.Pick.QueryColumnOfTypeAndOps<'bool', boolean, OperatorsBoolean>;
 type BooleanNullable = Column$1.Pick.QueryColumnOfTypeAndOps<'bool', boolean | null, OperatorsBoolean>;
 type NullableBooleanReturn<T> = SetQueryReturnsColumnOrThrow<T, BooleanNullable> & OperatorsBoolean;
 type NullableJSONAggReturn<T extends PickQuerySelectable, Arg extends SelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
   dataType: 'json';
-  type: (ExpressionOutput<T, Arg>['type'] | null)[] | null;
-  outputType: (ExpressionOutput<T, Arg>['outputType'] | null)[] | null;
-  queryType: (ExpressionOutput<T, Arg>['queryType'] | null)[] | null;
+  __type: (ExpressionOutput<T, Arg>['__type'] | null)[] | null;
+  __outputType: (ExpressionOutput<T, Arg>['__outputType'] | null)[] | null;
+  __queryType: (ExpressionOutput<T, Arg>['__queryType'] | null)[] | null;
   operators: OperatorsArray$1<never>;
 }> & OperatorsArray$1<never>;
 interface RecordSelectableOrExpression<T extends PickQuerySelectable> {
@@ -3323,14 +3640,14 @@ interface RecordSelectableOrExpression<T extends PickQuerySelectable> {
 }
 type NullableJSONObjectReturn<T extends PickQuerySelectable, Obj extends RecordSelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
   dataType: 'json';
-  type: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'] } | null;
-  outputType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['outputType'] } | null;
-  queryType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['queryType'] } | null;
+  __type: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__type'] } | null;
+  __outputType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__outputType'] } | null;
+  __queryType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__queryType'] } | null;
   operators: OperatorsAny;
 }> & OperatorsAny;
-type StringColumn$1 = Column$1.Pick.QueryColumnOfTypeAndOps<string, string, OperatorsText>;
-type StringNullable = Column$1.Pick.QueryColumnOfTypeAndOps<string, string | null, OperatorsText>;
-type NullableStringReturn<T> = SetQueryReturnsColumnOrThrow<T, StringNullable> & OperatorsText;
+type StringColumn$1 = Column$1.Pick.QueryColumnOfTypeAndOps<string, string, OperatorsText$1>;
+type StringNullable = Column$1.Pick.QueryColumnOfTypeAndOps<string, string | null, OperatorsText$1>;
+type NullableStringReturn<T> = SetQueryReturnsColumnOrThrow<T, StringNullable> & OperatorsText$1;
 interface AggregateArgTypes {
   minMax: 'citext' | 'date' | 'float4' | 'float8' | 'inet' | 'int2' | 'int4' | 'int8' | 'interval' | 'money' | 'numeric' | 'text' | 'time' | 'timestamp' | 'timestamptz';
   sum: 'float4' | 'float8' | 'int2' | 'int4' | 'int8' | 'interval' | 'money' | 'numeric';
@@ -3762,11 +4079,11 @@ declare class OrExpression extends Expression$1<BooleanQueryColumn> {
 interface QueryReturnsFnAdd<T extends PickQueryColumTypes> extends PickQueryHasSelect {
   type<C extends Column$1.Pick.QueryColumn>(fn: (types: T['columnTypes']) => C): { [K in keyof T]: K extends 'result' ? {
     value: C;
-  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['outputType']> : T[K] } & C['operators'];
+  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['__outputType']> : T[K] } & C['operators'];
 }
 type SetQueryReturnsFn<T extends PickQueryColumTypes, C extends Column$1.Pick.OutputType> = { [K in keyof T]: K extends 'result' ? {
   value: C;
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['outputType']> : T[K] } & QueryReturnsFnAdd<T>;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['__outputType']> : T[K] } & QueryReturnsFnAdd<T>;
 declare class QueryExpressions {
   /**
    * `column` references a table column, this can be used in raw SQL or when building a column expression.
@@ -3859,16 +4176,16 @@ declare class QueryExpressions {
 type WhereArg$1<T extends PickQuerySelectableRelations$1> = { [K in keyof T['__selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? WhereArg$1<T> | WhereArgs<T> : K extends 'OR' ? (WhereArg$1<T> | WhereArgs<T>)[] : K extends 'IN' ? MaybeArray$1<{
   columns: (keyof T['__selectable'])[];
   values: unknown[][] | IsQuery$1 | Expression$1;
-}> : T['__selectable'][K]['column']['queryType'] | null | { [O in keyof T['__selectable'][K]['column']['operators']]?: T['__selectable'][K]['column']['operators'][O]['_opType'] } | {
+}> : T['__selectable'][K]['column']['__queryType'] | null | { [O in keyof T['__selectable'][K]['column']['operators']]?: T['__selectable'][K]['column']['operators'][O]['_opType'] } | {
   result: {
     value: {
-      queryType: T['__selectable'][K]['column']['queryType'] | null;
+      __queryType: T['__selectable'][K]['column']['__queryType'] | null;
     };
   };
 } | ((q: T) => {
   result: {
     value: {
-      queryType: T['__selectable'][K]['column']['queryType'] | null;
+      __queryType: T['__selectable'][K]['column']['__queryType'] | null;
     };
   };
 }) } | ((q: WhereQueryBuilder<T>) => QueryOrExpressionBooleanOrNullResult | WhereQueryBuilder<T>);
@@ -3884,12 +4201,12 @@ type WhereQueryBuilder<T extends PickQueryRelations$1> = EmptyObject$1 extends T
 type WhereArgs<T extends PickQuerySelectableRelations$1> = WhereArg$1<T>[];
 type WhereNotArgs<T extends PickQuerySelectableRelations$1> = [WhereArg$1<T>];
 type WhereInColumn<T extends PickQuerySelectableRelations$1> = keyof T['__selectable'] | [keyof T['__selectable'], ...(keyof T['__selectable'])[]];
-type WhereInValues<T extends PickQuerySelectableRelations$1, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['queryType']> | IsQuery$1 | Expression$1 : ({ [I in keyof Column]: Column[I] extends keyof T['__selectable'] ? T['__selectable'][Column[I]]['column']['queryType'] : never } & {
+type WhereInValues<T extends PickQuerySelectableRelations$1, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['__queryType']> | IsQuery$1 | Expression$1 : ({ [I in keyof Column]: Column[I] extends keyof T['__selectable'] ? T['__selectable'][Column[I]]['column']['__queryType'] : never } & {
   length: Column extends {
     length: number;
   } ? Column['length'] : never;
 })[] | IsQuery$1 | Expression$1;
-type WhereInArg<T extends PickQuerySelectableRelations$1> = { [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['queryType']> | IsQuery$1 | Expression$1 };
+type WhereInArg<T extends PickQuerySelectableRelations$1> = { [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['__queryType']> | IsQuery$1 | Expression$1 };
 interface QueryHasWhere$1 {
   __hasWhere: true;
 }
@@ -4715,7 +5032,7 @@ interface OperatorToSQL {
 interface Operator<Value, Column extends Column.Pick.OutputTypeAndOperators = Column.Pick.OutputTypeAndOperators> {
   <T extends PickQueryResult>(this: T, arg: Value): { [K in Exclude<keyof T, keyof T['result']['value']['operators']>]: K extends 'result' ? {
     value: Column;
-  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['outputType']> : T[K] } & Column['operators'];
+  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['__outputType']> : T[K] } & Column['operators'];
   _opType: Value;
 }
 interface Base$1<Value> {
@@ -4742,7 +5059,7 @@ interface OperatorsBoolean extends Ord$1<boolean> {
   and: Operator<OperatorsBooleanSelf, BooleanQueryColumn>;
   or: Operator<OperatorsBooleanSelf, BooleanQueryColumn>;
 }
-interface OperatorsText extends Base$1<string> {
+interface OperatorsText$1 extends Base$1<string> {
   contains: Operator<string | IsQuery$1 | Expression$1, BooleanQueryColumn>;
   containsSensitive: Operator<string | IsQuery$1 | Expression$1, BooleanQueryColumn>;
   startsWith: Operator<string | IsQuery$1 | Expression$1, BooleanQueryColumn>;
@@ -4750,7 +5067,7 @@ interface OperatorsText extends Base$1<string> {
   endsWith: Operator<string | IsQuery$1 | Expression$1, BooleanQueryColumn>;
   endsWithSensitive: Operator<string | IsQuery$1 | Expression$1, BooleanQueryColumn>;
 }
-interface OperatorsOrdinalText$1 extends Ord$1<string>, OperatorsText {}
+interface OperatorsOrdinalText$1 extends Ord$1<string>, OperatorsText$1 {}
 interface JsonPathQueryOptions {
   vars?: RecordUnknown$1;
   silent?: boolean;
@@ -5080,7 +5397,7 @@ interface PickQueryUniqueProperties {
   };
 }
 interface PickQueryInputType$1 {
-  inputType: RecordUnknown$1;
+  __inputType: RecordUnknown$1;
 }
 interface PickQueryWithData {
   withData: WithDataItems;
@@ -5091,6 +5408,12 @@ interface PickQueryWindows {
 interface PickQueryRelations$1 {
   relations: RelationsBase$1;
 }
+interface PickQueryRelationsDataForCreate {
+  relationsDataForCreate: RelationsDataForCreateBase;
+}
+interface PickQueryRelationsDataForCreateOptional {
+  relationsDataForCreateOptional: RelationsDataForCreateOptionalBase;
+}
 interface PickQueryColumTypes {
   columnTypes: unknown;
 }
@@ -5426,7 +5749,7 @@ declare class CteQuery {
 }
 interface FromQuerySelf extends PickQuerySelectable, PickQueryShape$1, PickQueryReturnType, PickQueryWithData, PickQueryAs, PickQueryHasSelect {}
 type FromArg$1<T extends FromQuerySelf> = IsQuery$1 | Exclude<keyof T['withData'], symbol | number>;
-type FromResult$1<T extends FromQuerySelf, Arg extends MaybeArray$1<FromArg$1<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? { [K in keyof T]: K extends '__selectable' ? SelectableFromShape$1<T['withData'][Arg]['shape'], Arg> : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThenByQuery<T, T['withData'][Arg]['shape']> : T[K] } : SetQueryTableAlias<T, Arg> : Arg extends PickQuerySelectableResultInputTypeAs ? { [K in keyof T]: K extends '__defaultSelect' ? keyof Arg['result'] : K extends '__selectable' ? SelectableFromShape$1<Arg['result'], Arg['__as']> : K extends '__as' ? Arg['__as'] : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'inputType' ? Arg['inputType'] : K extends 'then' ? QueryThenByQuery<T, Arg['result']> : T[K] } : Arg extends (infer A)[] ? { [K in keyof T]: K extends '__selectable' ? UnionToIntersection<A extends string ? T['withData'] extends WithDataItems ? { [K in keyof T['withData'][A]['shape'] & string as `${A}.${K}`]: {
+type FromResult$1<T extends FromQuerySelf, Arg extends MaybeArray$1<FromArg$1<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? { [K in keyof T]: K extends '__selectable' ? SelectableFromShape$1<T['withData'][Arg]['shape'], Arg> : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThenByQuery<T, T['withData'][Arg]['shape']> : T[K] } : SetQueryTableAlias<T, Arg> : Arg extends PickQuerySelectableResultInputTypeAs ? { [K in keyof T]: K extends '__defaultSelect' ? keyof Arg['result'] : K extends '__selectable' ? SelectableFromShape$1<Arg['result'], Arg['__as']> : K extends '__as' ? Arg['__as'] : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends '__inputType' ? Arg['__inputType'] : K extends 'then' ? QueryThenByQuery<T, Arg['result']> : T[K] } : Arg extends (infer A)[] ? { [K in keyof T]: K extends '__selectable' ? UnionToIntersection<A extends string ? T['withData'] extends WithDataItems ? { [K in keyof T['withData'][A]['shape'] & string as `${A}.${K}`]: {
   as: K;
   column: T['withData'][A]['shape'][K];
 } } : never : A extends PickQueryResultAs ? { [K in keyof A['result'] & string as `${A['__as']}.${K}`]: K extends string ? {
@@ -5699,13 +6022,14 @@ declare class QueryCreateFrom {
    */
   insertForEachFrom<T extends CreateSelf$1>(this: T, query: IsQuery$1): InsertManyFromResult<T>;
 }
-interface CreateSelf$1 extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations$1, PickQueryWithData, PickQueryReturnType, PickQueryShape$1, PickQueryUniqueProperties, PickQueryInputType$1, Query.Pick.IsNotReadOnly {}
+interface CreateSelf$1 extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations$1, PickQueryRelationsDataForCreate, PickQueryRelationsDataForCreateOptional, PickQueryWithData, PickQueryReturnType, PickQueryShape$1, PickQueryUniqueProperties, PickQueryInputType$1, Query.Pick.IsNotReadOnly {}
 type CreateData$1<T extends CreateSelf$1> = EmptyObject$1 extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
-type CreateDataWithDefaults<T extends CreateSelf$1, Defaults extends PropertyKey> = { [K in keyof T['inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['inputType'] ? CreateColumn<T, K> : never };
-type CreateDataWithDefaultsForRelations<T extends CreateSelf$1, Defaults extends keyof T['inputType'], OmitFKeys extends PropertyKey> = { [K in keyof T['inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T, K> } & { [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K> };
-type CreateColumn<T extends CreateSelf$1, K extends keyof T['inputType']> = T['inputType'][K] | ((q: T) => QueryOrExpression$1<T['inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf$1> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
-type CreateRelationsDataOmittingFKeys<T extends CreateSelf$1, Union> = (Union extends RelationConfigDataForCreate ? (u: Union['columns'] extends keyof T['__defaults'] ? Pick<CreateDataWithDefaults<T, keyof T['__defaults']>, Union['columns']> & Partial<Union['nested']> : (Pick<{ [P in keyof T['inputType']]: CreateColumn<T, P> }, Union['columns'] & keyof T['inputType']> & { [K in keyof Union['nested']]?: never }) | Union['nested']) => void : (u: Union) => void) extends ((u: infer Obj) => void) ? Obj : never;
+type CreateDataWithDefaults<T extends CreateSelf$1, Defaults extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['__inputType'] ? CreateColumn<T, K> : never };
+type CreateDataWithDefaultsForRelations<T extends CreateSelf$1, Defaults extends keyof T['__inputType'], OmitFKeys extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T, K> } & { [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K> };
+type CreateColumn<T extends CreateSelf$1, K extends keyof T['__inputType']> = T['__inputType'][K] | ((q: T) => QueryOrExpression$1<T['__inputType'][K]>);
+type CreateRelationsData<T extends CreateSelf$1> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relationsDataForCreate']> & T['relationsDataForCreateOptional'];
+type CreateRelationsDataOmittingFKeys<T extends CreateSelf$1, Data> = EmptyObject$1 extends Data ? EmptyObject$1 : { [K in keyof Data]: CreateRelationDataOmittingFKeys<T, Data[K]> }[keyof Data] extends ((u: infer Obj) => void) ? Obj : never;
+type CreateRelationDataOmittingFKeys<T extends CreateSelf$1, Union> = (u: Union extends RelationConfigDataForCreate ? Union['columns'] extends keyof T['__defaults'] ? Pick<CreateDataWithDefaults<T, keyof T['__defaults']>, Union['columns']> & Partial<Union['nested']> : (Pick<{ [P in keyof T['__inputType']]: CreateColumn<T, P> }, Union['columns'] & keyof T['__inputType']> & { [K in keyof Union['nested']]?: never }) | Union['nested'] : Union) => void;
 type CreateResult<T extends CreateSelf$1, Data> = T extends {
   isCount: true;
 } ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneResult<T, NarrowCreateResult<T, Data>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnResult<T, NarrowCreateResult<T, Data>> : SetQueryResult<T, NarrowCreateResult<T, Data>>;
@@ -5720,13 +6044,13 @@ type InsertManyResult<T extends CreateSelf$1> = T['__hasSelect'] extends true ?
  *
  * 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$1, Data> = EmptyObject$1 extends T['relations'] ? T['result'] : { [K in keyof T['result']]: true extends { [R in keyof T['relations']]: K extends T['relations'][R]['omitForeignKeyInCreate'] ? R extends keyof Data ? true : T['relations'][R]['omitForeignKeyInCreate'] extends keyof Data ? null | undefined extends Data[T['relations'][R]['omitForeignKeyInCreate']] ? never : true : never : never }[keyof T['relations']] ? Column$1.Pick.QueryColumnOfTypeAndOps<string, Exclude<T['result'][K]['outputType'], null>, T['result'][K]['operators']> : T['result'][K] };
+type NarrowCreateResult<T extends CreateSelf$1, Data> = EmptyObject$1 extends T['relations'] ? T['result'] : { [K in keyof T['result']]: true extends { [R in keyof T['relations']]: K extends T['relations'][R]['omitForeignKeyInCreate'] ? R extends keyof Data ? true : T['relations'][R]['omitForeignKeyInCreate'] extends keyof Data ? null | undefined extends Data[T['relations'][R]['omitForeignKeyInCreate']] ? never : true : never : never }[keyof T['relations']] ? Column$1.Pick.QueryColumnOfTypeAndOps<string, Exclude<T['result'][K]['__outputType'], null>, T['result'][K]['operators']> : T['result'][K] };
 type IgnoreResult<T extends CreateSelf$1> = T['returnType'] extends 'oneOrThrow' ? QueryTakeOptional<T> : T['returnType'] extends 'valueOrThrow' ? SetQueryReturnsColumnOptional<T, T['result']['value']> : T;
 type OnConflictArg<T extends PickQueryUniqueProperties> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'] | Expression$1 | {
   constraint: T['internal']['uniqueConstraints'];
 };
 type AddQueryDefaults<T extends CreateSelf$1, DefaultKeys extends PropertyKey> = { [K in keyof T]: K extends '__defaults' ? { [K in keyof T['__defaults'] | DefaultKeys]: true } : T[K] };
-type ExtraPropertiesAreNotAllowed<T extends CreateSelf$1, Data> = keyof Data extends keyof T['inputType'] | keyof T['relations'] ? Data : `Extra properties are not allowed: ${Exclude<keyof Data, keyof T['inputType'] | keyof T['relations']> & string}`;
+type ExtraPropertiesAreNotAllowed<T extends CreateSelf$1, Data> = keyof Data extends keyof T['__inputType'] | keyof T['relations'] ? Data : `Extra properties are not allowed: ${Exclude<keyof Data, keyof T['__inputType'] | keyof T['relations']> & string}`;
 declare class QueryCreate {
   /**
    * `create` and `insert` create a single record.
@@ -6000,7 +6324,7 @@ declare class QueryCreate {
    */
   onConflictDoNothing<T extends CreateSelf$1, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): IgnoreResult<T>;
 }
-type OnConflictSet$1<T extends CreateSelf$1> = { [K in keyof T['inputType']]?: T['inputType'][K] | (() => QueryOrExpression$1<T['inputType'][K]>) };
+type OnConflictSet$1<T extends CreateSelf$1> = { [K in keyof T['__inputType']]?: T['__inputType'][K] | (() => QueryOrExpression$1<T['__inputType'][K]>) };
 declare class OnConflictQueryBuilder<T extends CreateSelf$1, Arg extends OnConflictArg<T> | undefined> {
   private query;
   private onConflict;
@@ -6731,14 +7055,14 @@ declare class QueryTransform {
     value: Column$1.Pick.QueryColumnOfType<Result>;
   } : K extends 'then' ? QueryThen<Result> : T[K] };
 }
-type AfterHook$1<Select extends PropertyKey[], Shape extends Column$1.QueryColumns> = QueryAfterHook$1<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['outputType'] : never }[]>;
+type AfterHook$1<Select extends PropertyKey[], Shape extends Column$1.QueryColumns> = QueryAfterHook$1<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['__outputType'] : never }[]>;
 type HookSelectArg<T extends PickQueryShape$1> = (keyof T['shape'] & string)[];
 declare class QueryHookUtils$1<T extends PickQueryInputType$1> {
   query: IsQuery$1;
   columns: string[];
   private key;
   constructor(query: IsQuery$1, columns: string[], key: 'hookCreateSet' | 'hookUpdateSet');
-  set: (data: { [K in keyof T["inputType"]]?: T["inputType"][K] | (() => QueryOrExpression$1<T["inputType"][K]>) }) => void;
+  set: (data: { [K in keyof T["__inputType"]]?: T["__inputType"][K] | (() => QueryOrExpression$1<T["__inputType"][K]>) }) => void;
 }
 declare abstract class QueryHooks$1 {
   /**
@@ -6895,7 +7219,7 @@ interface ColumnDataSelectSqlProp {
 interface SelectSqlCallback {
   (column: ColumnRefExpression<Column$1.Pick.QueryColumn>): Expression$1;
 }
-type SelectSqlColumn<T extends Column$1.Pick.DataAndDataType, Expr extends Expression$1> = unknown extends Expr['result']['value']['outputType'] ? T : { [K in keyof T]: K extends 'outputType' ? Expr['result']['value']['outputType'] : T[K] };
+type SelectSqlColumn<T extends Column$1.Pick.DataAndDataType, Expr extends Expression$1> = unknown extends Expr['result']['value']['__outputType'] ? T : { [K in keyof T]: K extends '__outputType' ? Expr['result']['value']['__outputType'] : T[K] };
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 type MaybeArray$1<T> = T | T[];
 type MaybePromise$1<T> = T | Promise<T>;
@@ -6926,9 +7250,9 @@ declare namespace Column$1 {
         unique: Name;
       };
     };
-    export type Nullable<T extends Column$1.Pick.ForNullable, 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' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' ? Operator<T | null> : T['operators'][K] } : T[K] };
-    export type QueryColumnToNullable<C> = { [K in keyof C]: K extends 'outputType' | 'queryType' ? C[K] | null : C[K] };
-    export type QueryColumnToOptional<C> = { [K in keyof C]: K extends 'outputType' ? C[K] | undefined : C[K] };
+    export type Nullable<T extends Column$1.Pick.ForNullable, 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' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' ? Operator<T | null> : T['operators'][K] } : T[K] };
+    export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K] };
+    export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K] };
     interface DataNullable {
       isNullable: true;
       optional: true;
@@ -6937,9 +7261,9 @@ declare namespace Column$1 {
       equals: Operator<T | null>;
       not: Operator<T | null>;
     }
-    export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends 'inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
-    export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends 'outputType' ? null extends T['type'] ? (Output extends null ? never : Output) | (unknown extends T['nullType'] ? null : T['nullType']) : Output : K extends 'outputSchema' ? null extends T['type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
-    export type ParseNull<T extends Column$1.Pick.ForParseNull, 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] };
+    export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
+    export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
+    export type ParseNull<T extends Column$1.Pick.ForParseNull, 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] };
     type DefaultData<T extends Column$1.Data, Value> = { [K in keyof T]: K extends 'default' ? Value extends null ? never : Value : K extends 'optional' ? true : T[K] };
     export type Default<T extends Column$1.Pick.Data, Value> = { [K in keyof T]: K extends 'data' ? DefaultData<T['data'], Value> : T[K] };
     type DefaultSelectData<T extends Column$1.Data, Value> = { [K in keyof T]: K extends 'explicitSelect' ? Value extends true ? false : true : T[K] };
@@ -6949,7 +7273,7 @@ declare namespace Column$1 {
         appReadOnly: true;
       };
     }
-    export type Generated<T extends Column$1.Pick.Data> = { [K in keyof T]: K extends 'data' ? { [K in keyof T['data']]: K extends 'default' ? true : T['data'][K] } : K extends 'inputType' ? never : T[K] };
+    export type Generated<T extends Column$1.Pick.Data> = { [K in keyof T]: K extends 'data' ? { [K in keyof T['data']]: K extends 'default' ? true : T['data'][K] } : K extends '__inputType' ? never : T[K] };
     export {};
   }
   export namespace Pick {
@@ -6957,17 +7281,17 @@ declare namespace Column$1 {
       data: Column$1.Data;
     }
     interface Type {
-      type: unknown;
+      __type: unknown;
     }
     interface OutputType {
-      outputType: unknown;
+      __outputType: unknown;
     }
     interface InputType {
-      inputType: unknown;
+      __inputType: unknown;
     }
     interface DataAndInputType extends Data, InputType {}
     interface NullType {
-      nullType: unknown;
+      __nullType: unknown;
     }
     interface OutputTypeAndOperators extends OutputType {
       operators: unknown;
@@ -6977,22 +7301,22 @@ declare namespace Column$1 {
     }
     interface QueryColumn extends OutputType {
       dataType: string;
-      type: unknown;
-      queryType: unknown;
+      __type: unknown;
+      __queryType: unknown;
       operators: any;
     }
     interface QueryColumnOfType<T> {
       dataType: string;
-      type: T;
-      outputType: T;
-      queryType: T;
+      __type: T;
+      __outputType: T;
+      __queryType: T;
       operators: any;
     }
     interface QueryColumnOfTypeAndOps<DataType, T, Ops> {
       dataType: DataType;
-      type: T;
-      outputType: T;
-      queryType: T;
+      __type: T;
+      __outputType: T;
+      __queryType: T;
       operators: Ops;
     }
     interface QueryColumnOfDataType<T extends string> extends QueryColumn {
@@ -7012,8 +7336,8 @@ declare namespace Column$1 {
       querySchema: any;
     }
     interface ForNullable extends Data, Type, InputType, OutputType, TypeSchemas {
-      nullType: unknown;
-      queryType: unknown;
+      __nullType: unknown;
+      __queryType: unknown;
       operators: unknown;
     }
     interface ForParse extends Type, NullType, NullSchema {}
@@ -7063,9 +7387,9 @@ declare namespace Column$1 {
     type StringOrMessage = string | Message;
   }
   export interface InputOutputQueryTypes {
-    inputType: unknown;
-    outputType: unknown;
-    queryType: unknown;
+    __inputType: unknown;
+    __outputType: unknown;
+    __queryType: unknown;
   }
   export interface InputOutputQueryTypesWithSchemas extends InputOutputQueryTypes {
     inputSchema: unknown;
@@ -7156,24 +7480,24 @@ declare namespace Column$1 {
   export type AsTypeArg<Schema> = AsTypeArgWithType<Schema> | AsTypeArgWithoutType<Schema>;
   export {};
 }
-declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTypeSchemaArg$1, Type = unknown, InputSchema = any, Ops = any, InputType = Type, OutputType = Type, OutputSchema = InputSchema, QueryType = InputType, QuerySchema = InputSchema> {
-  inputSchema: InputSchema;
-  outputSchema: OutputSchema;
-  querySchema: QuerySchema;
+declare abstract class Column$1 {
+  abstract __schema: ColumnTypeSchemaArg$1;
   abstract dataType: string;
-  abstract operators: Ops;
+  abstract operators: any;
   abstract toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  type: Type;
-  inputType: InputType;
-  outputType: OutputType;
-  queryType: QueryType;
-  nullType: unknown;
+  abstract __type: unknown;
+  abstract __inputType: unknown;
+  abstract __outputType: unknown;
+  abstract __queryType: unknown;
+  __nullType: unknown;
   nullSchema: unknown;
-  isNullable: boolean;
+  abstract inputSchema: unknown;
+  abstract outputSchema: unknown;
+  abstract querySchema: unknown;
   data: Column.Data;
-  error: Schema['error'];
+  error: this['__schema']['error'];
   _parse?: (input: unknown) => unknown;
-  constructor(schema: ColumnTypeSchemaArg$1, inputSchema: InputSchema, outputSchema?: OutputSchema, querySchema?: QuerySchema);
+  constructor(schema: ColumnTypeSchemaArg$1, inputSchema: unknown, outputSchema?: unknown, querySchema?: unknown);
   /**
    * Set a default value to a column. Columns that have defaults become optional when creating a record.
    *
@@ -7200,7 +7524,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    *
    * @param value - default value or a function returning a value
    */
-  default<T extends Column.Pick.DataAndInputType, Value extends T['inputType'] | null | RawSqlBase$1 | (() => T['inputType'])>(this: T, value: Value): Column.Modifiers.Default<T, Value>;
+  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase$1 | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.Default<T, Value>;
   /**
    * Use `hasDefault` to let the column be omitted when creating records.
    *
@@ -7246,7 +7570,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * }
    * ```
    */
-  nullable: Schema['nullable'];
+  nullable: this['__schema']['nullable'];
   /**
    * Set a custom function to process value for the column when creating or updating a record.
    *
@@ -7282,7 +7606,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    *
    * @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'];
+  encode: this['__schema']['encode'];
   /**
    * Set a custom function to process value after loading it from a database.
    *
@@ -7320,7 +7644,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    *
    * @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'];
+  parse: this['__schema']['parse'];
   /**
    * Use `parseNull` to specify runtime defaults at selection time.
    *
@@ -7365,7 +7689,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * })
    * ```
    */
-  parseNull: Schema['parseNull'];
+  parseNull: this['__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`.
@@ -7385,17 +7709,17 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * @param column - other column type to inherit from
    */
   as<T extends {
-    inputType: unknown;
-    outputType: unknown;
+    __inputType: unknown;
+    __outputType: unknown;
     data: Column.Data;
   }, C extends {
-    inputType: T['inputType'];
-    outputType: T['outputType'];
+    __inputType: T['__inputType'];
+    __outputType: T['__outputType'];
   }>(this: T, column: C): C;
   /**
    * @deprecated use narrowType instead
    */
-  asType: Schema['asType'];
+  asType: this['__schema']['asType'];
   /**
    * `narrowType` narrows TypeScript types of a column. It sets input, output, query type altogether.
    *
@@ -7438,8 +7762,10 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * // size will be typed as 'small' | 'medium' | 'large'
    * const size = await db.table.get('size');
    * ```
+   *
+   * @deprecated use `type` instead
    */
-  narrowType: Schema['narrowType'];
+  narrowType: this['__schema']['narrowType'];
   /**
    * Allows to narrow different TypeScript types of a column granularly.
    *
@@ -7495,17 +7821,19 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * // size will be typed as 'small' | 'medium' | 'large'
    * const size = await db.table.get('size');
    * ```
+   *
+   * @deprecated use `type`, `inputType`, `outputType`, `queryType` instead
    */
-  narrowAllTypes: Schema['narrowAllTypes'];
+  narrowAllTypes: this['__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] };
+  }, InputSchema extends this['__schema']['__schemaType']>(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] };
+  }, OutputSchema extends this['__schema']['__schemaType']>(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] };
+  }, QuerySchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['querySchema']) => QuerySchema): { [K in keyof T]: K extends 'querySchema' ? QuerySchema : T[K] };
   /**
    * Set a database column name.
    *
@@ -7599,7 +7927,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * }
    * ```
    */
-  setOnCreate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils$1<PickQueryInputType$1>) => T['inputType'] | void): T;
+  setOnCreate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils$1<PickQueryInputType$1>) => T['__inputType'] | void): T;
   /**
    * Set a column value when updating a record.
    * This works for [readOnly](#readonly) columns as well.
@@ -7616,7 +7944,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * }
    * ```
    */
-  setOnUpdate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils$1<PickQueryInputType$1>) => T['inputType'] | void): T;
+  setOnUpdate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils$1<PickQueryInputType$1>) => T['__inputType'] | void): T;
   /**
    * Set a column value when creating or updating a record.
    * This works for [readOnly](#readonly) columns as well.
@@ -7633,7 +7961,7 @@ declare abstract class Column$1<Schema extends ColumnTypeSchemaArg$1 = ColumnTyp
    * }
    * ```
    */
-  setOnSave<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils$1<PickQueryInputType$1>) => T['inputType'] | void): T;
+  setOnSave<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils$1<PickQueryInputType$1>) => T['__inputType'] | void): T;
   /**
    * Mark the column as a primary key.
    * This column type becomes an argument of the `.find` method.
@@ -8213,7 +8541,7 @@ interface ToSQLQuery extends IsQuery$1 {
 }
 type UnionArgs<T extends PickQueryResult> = ({
   result: { [K in keyof T['result']]: {
-    queryType: T['result'][K]['queryType'];
+    __queryType: T['result'][K]['__queryType'];
   } };
 } | ((q: T) => Expression$1))[];
 declare class Union {
@@ -8337,7 +8665,7 @@ declare class Clear {
 type HavingArgFn<T> = (q: T) => {
   result: {
     value: {
-      outputType: boolean;
+      __outputType: boolean;
     };
   };
 };
@@ -8410,7 +8738,7 @@ interface QueryPluckSelf extends PickQuerySelectable, PickQueryRelationsWithData
 type PluckArg<T extends QueryPluckSelf> = SelectableOrExpression<T> | ((q: SelectAsFnArg<T>) => Expression$1 | Query.Pick.SingleValueResult);
 type PluckResult<T extends QueryPluckSelf, S extends PluckArg<T>> = S extends ((q: never) => infer R) ? R extends Expression$1 ? SetQueryReturnsPluck<T, R> : R extends Query.Pick.SingleValueResult ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
   pluck: R['result']['value'];
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<R['result']['value']['outputType'][]> : T[K] } : never : S extends SelectableOrExpression<T> ? SetQueryReturnsPluck<T, S> : never;
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<R['result']['value']['__outputType'][]> : T[K] } : never : S extends SelectableOrExpression<T> ? SetQueryReturnsPluck<T, S> : never;
 declare class QueryPluck {
   /**
    * `.pluck` returns a single array of a single selected column values:
@@ -8582,15 +8910,15 @@ interface QueryHelper<T extends PickQueryTableMetaShapeTableAs, Args extends any
 interface NarrowTypeSelf extends PickQueryResultReturnType {
   returnType: undefined | 'all' | 'one' | 'oneOrThrow' | 'value' | 'valueOrThrow' | 'pluck';
 }
-type NarrowInvalidKeys<T extends PickQueryResult, Narrow> = { [K in keyof Narrow]: K extends keyof T['result'] ? Narrow[K] extends T['result'][K]['outputType'] ? never : K : K }[keyof Narrow];
+type NarrowInvalidKeys<T extends PickQueryResult, Narrow> = { [K in keyof Narrow]: K extends keyof T['result'] ? Narrow[K] extends T['result'][K]['__outputType'] ? never : K : K }[keyof Narrow];
 interface NarrowValueTypeResult<T extends PickQueryResultReturnType, Narrow> extends Column$1.QueryColumns {
-  value: { [K in keyof T['result']['value']]: K extends 'outputType' ? Narrow : T['result']['value'][K] };
+  value: { [K in keyof T['result']['value']]: K extends '__outputType' ? Narrow : T['result']['value'][K] };
 }
 interface NarrowPluckTypeResult<T extends PickQueryResultReturnType, Narrow> extends Column$1.QueryColumns {
-  pluck: { [K in keyof T['result']['pluck']]: K extends 'outputType' ? Narrow extends unknown[] ? Narrow[number] : Narrow : T['result']['pluck'][K] };
+  pluck: { [K in keyof T['result']['pluck']]: K extends '__outputType' ? Narrow extends unknown[] ? Narrow[number] : Narrow : T['result']['pluck'][K] };
 }
 type QueryIfResult<T extends PickQueryResultReturnType, R extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? { [K in keyof T['result'] | keyof R['result']]: K extends keyof T['result'] ? K extends keyof R['result'] ? R['result'][K] | T['result'][K] : T['result'][K] : Column$1.Modifiers.QueryColumnToOptional<R['result'][K]> } : K extends 'then' ? QueryIfResultThen<T, R> : T[K] };
-type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'] }> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'] }> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'] }> : T['returnType'] extends 'value' ? QueryThen<T['result']['value']['outputType'] | R['result']['value']['outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<T['result']['value']['outputType'] | R['result']['value']['outputType']> : T['returnType'] extends 'rows' ? QueryThen<(T['result'][keyof T['result']]['outputType'] | R['result'][keyof R['result']]['outputType'])[][]> : T['returnType'] extends 'pluck' ? QueryThen<(T['result']['pluck']['outputType'] | R['result']['pluck']['outputType'])[]> : QueryThen<void>;
+type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'value' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType']> : T['returnType'] extends 'rows' ? QueryThen<(T['result'][keyof T['result']]['__outputType'] | R['result'][keyof R['result']]['__outputType'])[][]> : T['returnType'] extends 'pluck' ? QueryThen<(T['result']['pluck']['__outputType'] | R['result']['pluck']['__outputType'])[]> : QueryThen<void>;
 interface QueryMethods<ColumnTypes> extends QueryClone, QueryAsMethods, AggregateMethods, QueryDistinct, Select, FromMethods, QueryJoin, QueryLimitOffset, CteQuery, Union, QueryJsonMethods, QueryCreate, QueryCreateFrom, QueryUpdate, QueryDelete, QueryStorage, QueryTransaction, QueryTruncate, For, Where, SearchMethods, Clear, Having, QueryCatchers, QueryLog, QueryOrder, QueryWithSchema, QueryHooks$1, QueryUpsert, QueryOrCreate, QueryGet, QueryPluck, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow {}
 declare class QueryMethods<ColumnTypes> {
   /**
@@ -9021,10 +9349,10 @@ declare class QueryMethods<ColumnTypes> {
    * ```
    */
   narrowType<T extends NarrowTypeSelf>(this: T): <Narrow>() => T['returnType'] extends undefined | 'all' | 'one' | 'oneOrThrow' ? [NarrowInvalidKeys<T, Narrow>] extends [never] ? { [K in keyof T]: K extends 'result' ? T['result'] & { [K in keyof Narrow]: {
-    outputType: Narrow[K];
+    __outputType: Narrow[K];
   } } : K extends 'then' ? QueryThenByQuery<T, T['result'] & { [K in keyof Narrow]: {
-    outputType: Narrow[K];
-  } }> : T[K] } : `narrowType() error: provided type does not extend the '${NarrowInvalidKeys<T, Narrow> & string}' column type` : (T['returnType'] extends 'pluck' ? Narrow extends unknown[] ? Narrow[number] : Narrow : Narrow) extends (T['returnType'] extends 'pluck' ? T['result']['pluck']['outputType'] : T['result']['value']['outputType']) ? { [K in keyof T]: K extends 'result' ? T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow> : K extends 'then' ? QueryThenByQuery<T, T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow>> : T[K] } : 'narrowType() error: provided type does not extend the returning column column type';
+    __outputType: Narrow[K];
+  } }> : T[K] } : `narrowType() error: provided type does not extend the '${NarrowInvalidKeys<T, Narrow> & string}' column type` : (T['returnType'] extends 'pluck' ? Narrow extends unknown[] ? Narrow[number] : Narrow : Narrow) extends (T['returnType'] extends 'pluck' ? T['result']['pluck']['__outputType'] : T['result']['value']['__outputType']) ? { [K in keyof T]: K extends 'result' ? T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow> : K extends 'then' ? QueryThenByQuery<T, T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow>> : T[K] } : 'narrowType() error: provided type does not extend the returning column column type';
   if<T extends PickQueryResultReturnType, R extends PickQueryResult>(this: T, condition: boolean | null | undefined, fn: (q: T) => R & {
     returnType: T['returnType'];
   }): QueryIfResult<T, R>;
@@ -9098,12 +9426,14 @@ interface Query extends IsQuery$1, PickQueryTable, PickQueryShape$1, PickQuerySe
   returnType: QueryReturnType$1;
   qb: QueryBuilder;
   columnTypes: unknown;
-  inputType: RecordUnknown$1;
+  __inputType: RecordUnknown$1;
   q: QueryData$1;
   then: QueryThen<unknown>;
   catch: QueryCatch;
   windows: EmptyObject$1;
   relations: RelationsBase$1;
+  relationsDataForCreate: RelationsDataForCreateBase;
+  relationsDataForCreateOptional: RelationsDataForCreateOptionalBase;
   relationQueries: IsQueries;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError;
   __readOnly: true | undefined;
@@ -9135,43 +9465,43 @@ declare namespace Query {
     }
   }
 }
-type SelectableOfType<T extends PickQuerySelectable, Type> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['type'] extends Type | null ? K : never }[keyof T['__selectable']];
-type SelectableOrExpressionOfType<T extends PickQuerySelectable, C extends Column$1.Pick.Type> = SelectableOfType<T, C['type']> | Expression$1<Column$1.Pick.QueryColumnOfType<C['type'] | null>>;
+type SelectableOfType<T extends PickQuerySelectable, Type> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['__type'] extends Type | null ? K : never }[keyof T['__selectable']];
+type SelectableOrExpressionOfType<T extends PickQuerySelectable, C extends Column$1.Pick.Type> = SelectableOfType<T, C['__type']> | Expression$1<Column$1.Pick.QueryColumnOfType<C['__type'] | null>>;
 type SetQueryReturnsAll<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThenShallowSimplifyArr<ColumnsShape$1.Output<T['result']>> : T[K] } & QueryHasWhere$1;
 type SetQueryReturnsAllResult<T extends PickQueryResult, Result extends Column$1.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K] } & QueryHasWhere$1;
-type QueryTakeOptional<T extends PickQueryResultReturnType> = T['returnType'] extends 'value' | 'pluck' | 'void' ? T : T['returnType'] extends 'valueOrThrow' ? { [K in keyof T]: K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<T['result']['value']['outputType'] | undefined> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<T['result']>> : T[K] };
+type QueryTakeOptional<T extends PickQueryResultReturnType> = T['returnType'] extends 'value' | 'pluck' | 'void' ? T : T['returnType'] extends 'valueOrThrow' ? { [K in keyof T]: K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'] | undefined> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<T['result']>> : T[K] };
 type QueryManyTakeOptional$1<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape$1.Output<T['result']>> : T[K] };
-type QueryTake<T extends PickQueryResultReturnType> = T['returnType'] extends 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['outputType'], undefined>> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape$1.Output<T['result']>> : T[K] };
+type QueryTake<T extends PickQueryResultReturnType> = T['returnType'] extends 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape$1.Output<T['result']>> : T[K] };
 type QueryManyTake$1<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape$1.Output<T['result']>> : T[K] };
 type SetQueryReturnsOne<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape$1.Output<T['result']>> : T[K] };
 type SetQueryReturnsOneResult<T extends PickQueryResult, Result extends Column$1.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape$1.Output<Result>> : T[K] };
 type SetQueryReturnsRows<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnsShape$1.Output<T['result']>[keyof T['result']][][]> : T[K] };
 type SetQueryReturnsPluck<T extends PickQuerySelectable, S extends keyof T['__selectable'] | Expression$1> = S extends keyof T['__selectable'] ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
   pluck: T['__selectable'][S]['column'];
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['__selectable'][S]['column']['outputType'][]> : T[K] } : { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['__selectable'][S]['column']['__outputType'][]> : T[K] } : { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
   pluck: S extends Expression$1 ? S['result']['value'] : never;
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression$1 ? S['result']['value']['outputType'] : never)[]> : T[K] };
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression$1 ? S['result']['value']['__outputType'] : never)[]> : T[K] };
 type SetValueQueryReturnsPluckColumn<T extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? {
   pluck: T['result']['value'];
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'][]> : T[K] } & QueryHasSelect;
 type SetQueryReturnsPluckColumnResult<T extends PickQueryResult, Result extends Column$1.QueryColumns> = { [K in keyof T]: K extends 'result' ? {
   pluck: T['result']['value'];
-} : K extends 'returnType' ? 'pluck' : K extends 'result' ? Result : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'pluck' : K extends 'result' ? Result : K extends 'then' ? QueryThen<T['result']['value']['__outputType'][]> : T[K] } & QueryHasSelect;
 type SetQueryReturnsValueOrThrow<T extends PickQuerySelectable, Arg extends keyof T['__selectable']> = SetQueryReturnsColumnOrThrow<T, T['__selectable'][Arg]['column']> & T['__selectable'][Arg]['column']['operators'];
-type SetValueQueryReturnsValueOrThrow<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['value']['outputType']> : T[K] };
-type SetQueryReturnsValueOptional<T extends PickQuerySelectable, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, { [K in keyof T['__selectable'][Arg]['column']]: K extends 'outputType' ? T['__selectable'][Arg]['column'][K] | undefined : T['__selectable'][Arg]['column'][K] }> & Omit<T['__selectable'][Arg]['column']['operators'], 'equals' | 'not'> & Column$1.Modifiers.OperatorsNullable<T['__selectable'][Arg]['column']>;
+type SetValueQueryReturnsValueOrThrow<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['value']['__outputType']> : T[K] };
+type SetQueryReturnsValueOptional<T extends PickQuerySelectable, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, { [K in keyof T['__selectable'][Arg]['column']]: K extends '__outputType' ? T['__selectable'][Arg]['column'][K] | undefined : T['__selectable'][Arg]['column'][K] }> & Omit<T['__selectable'][Arg]['column']['operators'], 'equals' | 'not'> & Column$1.Modifiers.OperatorsNullable<T['__selectable'][Arg]['column']>;
 type SetQueryReturnsColumnOrThrow<T, Column extends Column.Pick.OutputType> = { [K in keyof T]: K extends 'result' ? {
   value: Column;
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['outputType']> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['__outputType']> : T[K] } & QueryHasSelect;
 type SetQueryReturnsColumnOptional<T, Column extends Column.Pick.OutputType> = { [K in keyof T]: K extends 'result' ? {
   value: Column;
-} : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['outputType'] | undefined> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['__outputType'] | undefined> : T[K] } & QueryHasSelect;
 type SetQueryReturnsColumn<T extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? {
   value: T['result']['pluck'];
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['outputType']> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['__outputType']> : T[K] } & QueryHasSelect;
 type SetQueryReturnsColumnResult<T extends PickQueryResult, Result extends Column$1.QueryColumns> = { [K in keyof T]: K extends 'result' ? {
   value: T['result']['pluck'];
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThen<Result['pluck']['outputType']> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThen<Result['pluck']['__outputType']> : T[K] } & QueryHasSelect;
 type SetQueryReturnsRowCount<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
   value: Column$1.Pick.QueryColumnOfType<number>;
 } : K extends 'then' ? QueryThen<number> : T[K] };
@@ -9186,11 +9516,11 @@ interface QueryOrExpressionBooleanOrNullResult {
   };
 }
 interface UpdateSelf extends PickQuerySelectable, PickQueryResult, PickQueryRelations$1, PickQueryWithData, PickQueryReturnType, PickQueryShape$1, PickQueryInputType$1, PickQueryAs, PickQueryHasSelect, PickQueryHasWhere, Query.Pick.IsNotReadOnly {}
-type UpdateData$1<T extends UpdateSelf> = { [K in keyof T['inputType'] | keyof T['relations']]?: K extends keyof T['inputType'] ? T['inputType'][K] | ((q: { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never }) => QueryOrExpression$1<T['inputType'][K]>) : T['returnType'] extends undefined | 'all' ? T['relations'][K]['dataForUpdate'] : T['relations'][K]['dataForUpdateOne'] };
+type UpdateData$1<T extends UpdateSelf> = { [K in keyof T['__inputType'] | keyof T['relations']]?: K extends keyof T['__inputType'] ? T['__inputType'][K] | ((q: { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never }) => QueryOrExpression$1<T['__inputType'][K]>) : T['returnType'] extends undefined | 'all' ? T['relations'][K]['dataForUpdate'] : T['relations'][K]['dataForUpdateOne'] };
 type UpdateArg<T extends UpdateSelf> = T['__hasWhere'] extends true ? UpdateData$1<T> : 'Update statement must have where conditions. To update all prefix `update` with `all()`';
 type UpdateResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T> : SetQueryReturnsRowCount<T>;
-type NumericColumns<T extends UpdateSelf> = { [K in keyof T['inputType']]: Exclude<T['shape'][K]['queryType'], string> extends number | bigint | null ? K : never }[keyof T['inputType']];
-type ChangeCountArg<T extends UpdateSelf> = NumericColumns<T> | { [K in NumericColumns<T>]?: T['shape'][K]['type'] extends number | null ? number : number | string | bigint };
+type NumericColumns<T extends UpdateSelf> = { [K in keyof T['__inputType']]: Exclude<T['shape'][K]['__queryType'], string> extends number | bigint | null ? K : never }[keyof T['__inputType']];
+type ChangeCountArg<T extends UpdateSelf> = NumericColumns<T> | { [K in NumericColumns<T>]?: T['shape'][K]['__type'] extends number | null ? number : number | string | bigint };
 interface UpdateManyBySelf extends UpdateSelf {
   internal: {
     uniqueColumns: unknown;
@@ -9199,10 +9529,10 @@ interface UpdateManyBySelf extends UpdateSelf {
     uniqueConstraints: unknown;
   };
 }
-type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column$1.Modifiers.IsPrimaryKey<string> ? K : never]: T['shape'][K]['queryType'] | Expression$1 } & { [P in keyof T['inputType']]?: T['inputType'][P] | Expression$1 })[];
+type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column$1.Modifiers.IsPrimaryKey<string> ? K : never]: T['shape'][K]['__queryType'] | Expression$1 } & { [P in keyof T['__inputType']]?: T['__inputType'][P] | Expression$1 })[];
 type UpdateManyByKeys<T extends UpdateManyBySelf> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'];
 type UpdateManyByKeyColumns<K> = K extends string[] ? K[number] : K;
-type UpdateManyByData<T extends UpdateSelf, K> = ({ [P in K & keyof T['inputType']]: T['inputType'][P] } & { [P in keyof T['inputType']]?: P extends K ? T['inputType'][P] : T['inputType'][P] | Expression$1 })[];
+type UpdateManyByData<T extends UpdateSelf, K> = ({ [P in K & keyof T['__inputType']]: T['__inputType'][P] } & { [P in keyof T['__inputType']]?: P extends K ? T['__inputType'][P] : T['__inputType'][P] | Expression$1 })[];
 type UpdateManyResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllResult<T, T['result']> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnResult<T, T['result']> : SetQueryResult<T, T['result']> : SetQueryReturnsRowCountMany<T>;
 declare class QueryUpdate {
   /**
@@ -9647,4 +9977,4 @@ declare class QueryUpdate {
    */
   updateManyByOptional<T extends UpdateManyBySelf, Keys extends UpdateManyByKeys<T>, K = UpdateManyByKeyColumns<Keys>>(this: T, keys: Keys, data: UpdateManyByData<T, K>): UpdateManyResult<T> & QueryHasWhere$1;
 }
-export { type Adapter, AdapterClass, type AdapterConfigBase, type AdapterParams, type AdapterSchemaConfigOptions, type AfterCommitStandaloneHook, type AfterHook, ArrayColumn, type ArrayColumnValue, type ArrayData, type AsyncState, type BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CannotMutateReadOnlyTableError, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, type ColumnsShape, type ComputedColumnsFromOptions, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateColumn, type DateColumnData, type DbDomainArg, type DbExtension, type DbOptions, type DbResult, type DbSharedOptions, type DbSqlMethod, type DbStructureDomainsMap, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultPrivileges, type DefaultSchemaConfig, type DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, type DriverAdapter, DynamicRawSQL, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionData, type FromArg, type FromResult, type GeneratorIgnore, type Grant, type HookSelectValue, InetColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinQueryMethod, type JoinedShapes, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, OrchidOrmError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, type QueryHasWhere, QueryHookUtils, QueryHooks, type QueryInternal, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, type QueryOrExpression, type QueryResult, type QueryResultRow, type QueryReturnType, type QuerySchema, type QueryScopes, RawSql, type RawSqlBase, RealColumn, type RecordKeyTrue, type RecordOptionalString, type RecordString, type RecordStringOrNumber, type RecordUnknown, type RelationConfigBase, type RelationJoinQuery, type RelationsBase, type Rls, type RlsPolicy, type SchemaConfigFnWithOptions, type SearchWeight, type SelectableFromShape, SerialColumn, type SerialColumnData, type ShallowSimplify, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type Sql, type SqlFn, type SqlSessionState, type StorageOptions, StringColumn, type StringData, type TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TemplateLiteralArgs, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSqlValues, type TransactionAdapter, TransactionAdapterClass, type TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, type UniqueConstraints, type UniqueTableDataItem, UnknownColumn, type UpdateData, type UpdateSelf, type UpsertData, type UpsertThis, VarCharColumn, VirtualColumn, type WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };
+export { type Adapter, AdapterClass, type AdapterConfigBase, type AdapterParams, type AdapterSchemaConfigOptions, type AfterCommitStandaloneHook, type AfterHook, ArrayColumn, type ArrayColumnValue, type ArrayData, type AsyncState, type BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CannotMutateReadOnlyTableError, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, type ColumnsShape, type ComputedColumnsFromOptions, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateColumn, type DateColumnData, type DbDomainArg, type DbExtension, type DbOptions, type DbResult, type DbSharedOptions, type DbSqlMethod, type DbStructureDomainsMap, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultPrivileges, type DefaultSchemaConfig, type DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, type DriverAdapter, DynamicRawSQL, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionData, type FromArg, type FromResult, type GeneratorIgnore, type Grant, type HookSelectValue, InetColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinQueryMethod, type JoinedShapes, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, type OperatorsText, OrchidOrmError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, type QueryHasWhere, QueryHookUtils, QueryHooks, type QueryInternal, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, type QueryOrExpression, type QueryResult, type QueryResultRow, type QueryReturnType, type QuerySchema, type QueryScopes, RawSql, type RawSqlBase, RealColumn, type RecordKeyTrue, type RecordOptionalString, type RecordString, type RecordStringOrNumber, type RecordUnknown, type RelationConfigBase, type RelationJoinQuery, type RelationsBase, type Rls, type RlsPolicy, type SchemaConfigFnWithOptions, type SearchWeight, type SelectableFromShape, SerialColumn, type SerialColumnData, type ShallowSimplify, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type Sql, type SqlFn, type SqlSessionState, type StorageOptions, StringColumn, type StringData, type TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TemplateLiteralArgs, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSqlValues, type TransactionAdapter, TransactionAdapterClass, type TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, type UniqueConstraints, type UniqueTableDataItem, UnknownColumn, type UpdateData, type UpdateSelf, type UpsertData, type UpsertThis, VarCharColumn, VirtualColumn, type WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };