pqb 0.67.5 → 0.67.7

package/dist/index.d.ts

@@ -630,7 +630,7 @@ interface ColumnSchemaGetterTableClass {
 }
 type ColumnSchemaGetterColumns<T extends ColumnSchemaGetterTableClass> = T['prototype']['columns']['shape'];
 interface ColumnTypeSchemaArg {
-  type: unknown;
+  __schemaType: unknown;
   nullable<T extends Column.Pick.ForNullable>(this: T): Column.Modifiers.Nullable<T, unknown, unknown, unknown>;
   encode: unknown;
   parse: unknown;
@@ -664,6 +664,7 @@ interface ColumnSchemaConfig<T extends Column.Pick.Data = Column.Pick.Data> exte
   bit(max?: number): unknown;
   uuid(): unknown;
   json(): T;
+  jsonText(): T;
   inputSchema(this: ColumnSchemaGetterTableClass): unknown;
   outputSchema(this: ColumnSchemaGetterTableClass): unknown;
   querySchema(this: ColumnSchemaGetterTableClass): unknown;
@@ -956,7 +957,7 @@ interface TableDataMethods<Key extends PropertyKey> {
   sql: SqlFn;
 }
 type TableDataItemsUniqueColumns<Shape extends Column.QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, T> : T extends unknown[] ? { [Item in T[number] as PropertyKey]: Item extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, Item> : never }[PropertyKey] : never;
-type ItemUniqueColumns<Shape extends Column.QueryColumns, T extends UniqueTableDataItem<Shape>> = { [Column in T['columns'][number]]: UniqueQueryTypeOrExpression<Shape[Column]['queryType']> };
+type ItemUniqueColumns<Shape extends Column.QueryColumns, T extends UniqueTableDataItem<Shape>> = { [Column in T['columns'][number]]: UniqueQueryTypeOrExpression<Shape[Column]['__queryType']> };
 type TableDataItemsUniqueColumnTuples<Shape extends Column.QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? T['columns'] : T extends TableDataItem[] ? Exclude<T[number]['columns'], []> : never;
 type UniqueQueryTypeOrExpression<T> = T | Expression<Column.Pick.QueryColumnOfType<T>>;
 type TableDataItemsUniqueConstraints<T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem ? T['name'] : T extends UniqueTableDataItem[] ? T[number]['name'] : never;
@@ -1054,16 +1055,33 @@ interface NumberColumnData extends BaseNumberData, Column.Data {
 interface SerialColumnData extends NumberColumnData {
   default: Expression;
 }
-declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig, SchemaType extends Schema['type']> extends Column<Schema, number, SchemaType, OperatorsNumber> {
+declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig, SchemaType extends Schema['__schemaType']> extends Column {
+  __schema: Schema;
+  __type: number;
+  __inputType: number;
+  inputSchema: SchemaType;
   data: NumberColumnData;
+  __outputType: number;
+  outputSchema: SchemaType;
+  __queryType: number;
+  querySchema: SchemaType;
   operators: OperatorsNumber;
 }
 declare abstract class IntegerBaseColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['int']>> {
   data: NumberColumnData;
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
 }
-declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig, InputType = string | number> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber, InputType> {
+declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig, InputType = string | number> extends Column {
+  __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.Data;
   constructor(schema: Schema);
 }
@@ -1073,6 +1091,7 @@ interface DecimalColumnData extends Column.Data {
 }
 declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
   data: DecimalColumnData;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsNumber;
   dataType: "numeric";
   constructor(schema: Schema, numericPrecision?: number, numericScale?: number);
@@ -1082,35 +1101,41 @@ declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends NumberAsS
 type IdentityColumn<T extends Column.Pick.Data> = Column.Modifiers.Default<T, Expression>;
 declare class SmallIntColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
   dataType: "int2";
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): IdentityColumn<T>;
 }
 declare class IntegerColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
   dataType: "int4";
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): IdentityColumn<T>;
 }
 declare class BigIntColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema, string | number | bigint> {
   dataType: "int8";
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): IdentityColumn<T>;
 }
 declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
   dataType: "float4";
+  querySchema: ReturnType<Schema['number']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class DoublePrecisionColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
   dataType: "float8";
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class SmallSerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
   dataType: "int2";
   data: SerialColumnData;
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1118,6 +1143,7 @@ declare class SmallSerialColumn<Schema extends ColumnSchemaConfig> extends Integ
 declare class SerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
   dataType: "int4";
   data: SerialColumnData;
+  querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1125,6 +1151,7 @@ declare class SerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBas
 declare class BigSerialColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
   dataType: "int8";
   data: SerialColumnData;
+  querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toSQL(): string;
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1138,9 +1165,17 @@ declare const getDateAsDateFn: (column: {
   data: Column.Data;
   dateParsedByDriver?: boolean;
 }) => (value: unknown) => Date;
-declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringNumberDate']>, OperatorsDate, DateColumnInput, string, ReturnType<Schema['stringSchema']>> {
+declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends Column {
   dateParsedByDriver?: boolean | undefined;
+  __schema: Schema;
+  __type: string;
+  __inputType: DateColumnInput;
+  inputSchema: ReturnType<Schema['stringNumberDate']>;
   data: DateColumnData;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: DateColumnInput;
+  querySchema: ReturnType<Schema['stringNumberDate']>;
   operators: OperatorsDate;
   asNumber: Schema['dateAsNumber'];
   asDate: Schema['dateAsDate'];
@@ -1170,42 +1205,66 @@ declare class TimestampTZColumn<Schema extends ColumnSchemaConfig> extends DateT
   baseDataType: "timestamp";
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class TimeColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsTime> {
+declare class TimeColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
+  __type: string;
+  __inputType: ReturnType<Schema['stringSchema']>;
+  inputSchema: ReturnType<Schema['stringSchema']>;
   data: DateColumnData & {
     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, key: string): Code;
 }
-declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, PostgresInterval, ReturnType<Schema['timeInterval']>, OperatorsDate, Partial<PostgresInterval>, PostgresInterval> {
+declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
+  __type: PostgresInterval;
   data: Column.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, key: string): Code;
   toSQL(): string;
 }
-declare class EnumColumn<Schema extends ColumnTypeSchemaArg, SchemaType extends Schema['type'], const T extends readonly string[]> extends Column<Schema, T[number], SchemaType, OperatorsOrdinalText> {
+declare class EnumColumn<Schema extends ColumnTypeSchemaArg, SchemaType extends Schema['__schemaType'], const T extends readonly string[]> extends Column {
   enumName: string;
   options: T;
+  __schema: Schema;
   operators: OperatorsOrdinalText;
+  __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, key: string): Code;
   toSQL(): string;
 }
 interface ArrayColumnValue {
-  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, key: string): Code;
@@ -1215,67 +1274,90 @@ interface ArrayData<Item extends ArrayColumnValue> extends Column.Data, ArrayMet
   item: Item;
   arrayDims: number;
 }
-declare class ArrayColumn<Schema extends ColumnTypeSchemaArg, Item extends ArrayColumnValue, InputType, OutputType, QueryType> extends Column<Schema, Item['type'][], InputType, OperatorsArray<Item['queryType']>, Item['inputType'][], Item['outputType'][], OutputType, Item['queryType'][], QueryType> {
+declare class ArrayColumn<Schema extends ColumnTypeSchemaArg, Item extends ArrayColumnValue, InputType, OutputType, QueryType> extends Column {
+  __schema: Schema;
   dataType: "array";
-  operators: OperatorsArray<Item["queryType"]>;
+  operators: OperatorsArray<Item["__queryType"]>;
   data: ArrayData<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<ColumnSchemaConfig, ArrayColumnValue, unknown, unknown, unknown>, ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class JSONColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema = Schema['type']> extends Column<Schema, T, InputSchema, OperatorsJson> {
+declare class JSONColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema = Schema['__schemaType']> extends Column {
+  __schema: Schema;
   dataType: "jsonb";
+  __type: T;
+  __inputType: T;
+  inputSchema: InputSchema;
+  __outputType: T;
+  outputSchema: InputSchema;
+  __queryType: T;
+  querySchema: InputSchema;
   operators: OperatorsJson;
-  constructor(schema: Schema, inputType: Schema['type'], encodedByDriver?: boolean);
+  constructor(schema: Schema, __inputType: InputSchema, encodedByDriver?: boolean);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class JSONTextColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, unknown, ReturnType<Schema['unknown']>, OperatorsText> {
+declare class JSONTextColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema = Schema['__schemaType']> extends Column {
+  __schema: Schema;
   dataType: "json";
+  __type: T;
+  __inputType: T;
+  inputSchema: InputSchema;
+  __outputType: T;
+  outputSchema: InputSchema;
+  __queryType: T;
+  querySchema: InputSchema;
   operators: OperatorsText;
   private static _instance;
-  static get instance(): JSONTextColumn<DefaultSchemaConfig>;
-  constructor(schema: Schema);
+  static get instance(): JSONTextColumn<unknown, DefaultSchemaConfig, unknown>;
+  constructor(schema: Schema, __inputType: InputSchema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
-  parse<T extends Column.Pick.ForParse, Output>(this: T, fn: (input: T['type']) => Output): Column.Modifiers.Parse<T, unknown, Output>;
+  parse<T extends Column.Pick.ForParse, Output>(this: T, fn: (input: T['__type']) => Output): Column.Modifiers.Parse<T, unknown, Output>;
   parseNull<T extends Column.Pick.ForParseNull, Output>(this: T, fn: () => Output): Column.Modifiers.ParseNull<T, unknown, Output>;
-  encode<T extends {
-    type: unknown;
-  }, Input>(this: T, fn: (input: Input) => unknown): Column.Modifiers.Encode<T, unknown, Input>;
+  encode<T extends Column.Pick.Type, Input>(this: T, fn: (input: Input) => unknown): Column.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.InputOutputQueryTypes, Types extends Column.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.InputOutputQueryTypes, Types extends Column.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.InputOutputQueryTypes, Types extends Column.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>(this: T): Column.Modifiers.Parse<T, unknown, number>;
-  dateAsDate<T extends Column>(this: T): Column.Modifiers.Parse<T, unknown, Date>;
+  dateAsNumber<T extends Column.Pick.ForParse>(this: T): Column.Modifiers.Parse<T, unknown, number>;
+  dateAsDate<T extends Column.Pick.ForParse>(this: T): Column.Modifiers.Parse<T, unknown, Date>;
   enum<const T extends readonly [string, ...string[]]>(dataType: string, type: T): EnumColumn<DefaultSchemaConfig, unknown, T>;
   array<Item extends ArrayColumnValue>(item: Item): ArrayColumn<DefaultSchemaConfig, Item, unknown, unknown, unknown>;
   json<T>(): JSONColumn<unknown extends T ? MaybeArray<string | number | boolean | object> : T, DefaultSchemaConfig>;
+  jsonText<T>(): JSONTextColumn<unknown extends T ? MaybeArray<string | number | boolean | object> : T, DefaultSchemaConfig>;
   inputSchema(): undefined;
   outputSchema(): undefined;
   querySchema(): undefined;
@@ -1302,8 +1384,16 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
 declare const defaultSchemaConfig: (options?: AdapterSchemaConfigOptions) => DefaultSchemaConfig;
 declare const internalSchemaConfig: DefaultSchemaConfig;
 type TextColumnData = StringData;
-declare abstract class TextBaseColumn<Schema extends ColumnSchemaConfig, Ops = OperatorsText> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, Ops> {
+declare abstract class TextBaseColumn<Schema extends ColumnSchemaConfig, Ops = OperatorsText> extends Column {
+  __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']>);
 }
@@ -1329,93 +1419,206 @@ declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColu
     minArg?: number;
     maxArg?: number;
   };
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText;
   private static _instance;
   static get instance(): TextColumn<DefaultSchemaConfig>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['buffer']>, OperatorsOrdinalText, Buffer, Buffer, ReturnType<Schema['buffer']>, string, ReturnType<Schema['stringSchema']>> {
+declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "bytea";
   operators: OperatorsOrdinalText;
+  __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, key: string): Code;
 }
-declare class PointColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class PointColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "point";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class LineColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class LineColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "line";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class LsegColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class LsegColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "lseg";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class BoxColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class BoxColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "box";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class PathColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class PathColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "path";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "polygon";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class CircleColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class CircleColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "circle";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['number']>, OperatorsNumber, string | number, number, ReturnType<Schema['number']>, string | number> {
+declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "money";
+  __type: string;
   data: NumberColumnData;
+  __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, key: string): Code;
 }
-declare class CidrColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class CidrColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "cidr";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class InetColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText> {
+declare class InetColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText> {
+declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText> {
+declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class BitColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['bit']>, OperatorsOrdinalText> {
+declare class BitColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   data: Column.Data & {
     length: number;
@@ -1424,8 +1627,16 @@ declare class BitColumn<Schema extends ColumnSchemaConfig> extends Column<Schema
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
   toSQL(): string;
 }
-declare class BitVaryingColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['bit']>, OperatorsOrdinalText> {
+declare class BitVaryingColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   data: Column.Data & {
     length?: number;
@@ -1435,9 +1646,17 @@ declare class BitVaryingColumn<Schema extends ColumnSchemaConfig> extends Column
   toSQL(): string;
 }
 type TsVectorGeneratedColumns = string[] | SearchWeightRecord;
-declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText> {
+declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends Column {
   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;
   constructor(schema: Schema, defaultLanguage?: string);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1467,14 +1686,30 @@ declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends Column<S
    */
   generated<T extends Column.Pick.Data>(this: T, ...args: StaticSQLArgs | [language: string, columns: TsVectorGeneratedColumns] | [columns: TsVectorGeneratedColumns]): Column.Modifiers.Generated<T>;
 }
-declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsOrdinalText> {
+declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['uuid']>, OperatorsOrdinalText> {
+declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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;
   constructor(schema: Schema);
   /**
@@ -1489,8 +1724,16 @@ declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column<Schem
   };
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class XMLColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
+declare class XMLColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __schema: Schema;
   dataType: "xml";
+  __type: string;
+  __inputType: string;
+  inputSchema: ReturnType<Schema['stringSchema']>;
+  __outputType: string;
+  outputSchema: ReturnType<Schema['stringSchema']>;
+  __queryType: string;
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsText;
   private static _instance;
   static get instance(): XMLColumn<DefaultSchemaConfig>;
@@ -1498,18 +1741,28 @@ declare class XMLColumn<Schema extends ColumnSchemaConfig> extends Column<Schema
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema, OperatorsOrdinalText> {
+  __schema: Schema;
   dataType: "citext";
   data: TextColumnData & {
     minArg?: number;
     maxArg?: number;
   };
+  querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsOrdinalText;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
-declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
+declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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<DefaultSchemaConfig>;
   constructor(schema: Schema);
@@ -1533,20 +1786,29 @@ interface TimestampHelpers {
     timestampNoTZ(): T;
   }): Timestamps<T>;
 }
-declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, unknown, ReturnType<Schema['unknown']>, OperatorsAny> {
+declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends Column {
   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.Data;
   dataType: string;
   constructor(schema: Schema, typeName: string, typeSchema?: string | undefined, extension?: string);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
   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;
 }
 declare class DomainColumn<Schema extends ColumnSchemaConfig> extends CustomTypeColumn<Schema> {
@@ -1557,8 +1819,16 @@ interface PostgisPoint {
   lat: number;
   srid?: number;
 }
-declare class PostgisGeographyPointColumn<Schema extends ColumnSchemaConfig> extends Column<Schema, PostgisPoint, ReturnType<Schema['geographyPointSchema']>, OperatorsAny> {
+declare class PostgisGeographyPointColumn<Schema extends ColumnSchemaConfig> extends Column {
+  __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,
@@ -1617,7 +1887,7 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
   uuid(): UUIDColumn<SchemaConfig>;
   xml(): XMLColumn<SchemaConfig>;
   json: SchemaConfig['json'];
-  jsonText(): JSONTextColumn<SchemaConfig>;
+  jsonText: SchemaConfig['jsonText'];
   type(dataType: string): CustomTypeColumn<SchemaConfig>;
   domain(dataType: string): DomainColumn<SchemaConfig>;
   geography: {
@@ -1700,8 +1970,8 @@ interface QueryThen<T> {
 type QueryThenShallowSimplify<T> = QueryThen<ShallowSimplify<T>>;
 type QueryThenShallowSimplifyArr<T> = QueryThen<ShallowSimplify<T>[]>;
 type QueryThenShallowSimplifyOptional<T> = QueryThen<ShallowSimplify<T> | undefined>;
-type QueryThenByQuery<T extends PickQueryReturnType, Result extends Column.QueryColumns> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<Result>> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<Result>> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape.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.Output<Result>[keyof Result][][]> : T['returnType'] extends 'pluck' ? QueryThen<Result['pluck']['outputType'][]> : QueryThen<void>;
-type QueryThenByReturnType<T extends QueryReturnType, Result extends Column.QueryColumns> = T extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<Result>> : T extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<Result>> : T extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T extends 'value' ? QueryThen<Result['value']['outputType'] | undefined> : T extends 'valueOrThrow' ? QueryThen<Result['value']['outputType']> : T extends 'rows' ? QueryThen<ColumnsShape.Output<Result>[keyof Result][][]> : T extends 'pluck' ? QueryThen<Result['pluck']['outputType'][]> : QueryThen<void>;
+type QueryThenByQuery<T extends PickQueryReturnType, Result extends Column.QueryColumns> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<Result>> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<Result>> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape.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.Output<Result>[keyof Result][][]> : T['returnType'] extends 'pluck' ? QueryThen<Result['pluck']['__outputType'][]> : QueryThen<void>;
+type QueryThenByReturnType<T extends QueryReturnType, Result extends Column.QueryColumns> = T extends undefined | 'all' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<Result>> : T extends 'one' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<Result>> : T extends 'oneOrThrow' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T extends 'value' ? QueryThen<Result['value']['__outputType'] | undefined> : T extends 'valueOrThrow' ? QueryThen<Result['value']['__outputType']> : T extends 'rows' ? QueryThen<ColumnsShape.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;
@@ -2595,7 +2865,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;
   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 {
@@ -2701,40 +2971,40 @@ interface ColumnsShape {
 }
 declare namespace ColumnsShape {
   export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
-  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['outputType'] };
-  export type Input<Shape extends Column.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.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['inputType'] };
-  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
-  export type DefaultSelectOutput<Shape extends Column.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.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
+  export type Input<Shape extends Column.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.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
+  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  export type DefaultSelectOutput<Shape extends Column.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.QueryColumns> {
     dataType: 'object';
-    type: { [K in keyof Shape]: Shape[K]['type'] };
-    outputType: ShallowSimplify<ObjectOutput<Shape>>;
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] };
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify<ObjectOutput<Shape>>;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
     operators: OperatorsAny;
   }
   export interface MapToNullableObjectColumn<Shape extends Column.QueryColumns> {
     dataType: 'object';
-    type: { [K in keyof Shape]: Shape[K]['type'] };
-    outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] } | null;
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
     operators: OperatorsAny;
   }
   export interface MapToPluckColumn<Shape extends Column.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.QueryColumns> {
     dataType: 'array';
-    type: { [K in keyof Shape]: Shape[K]['type'] }[];
-    outputType: ShallowSimplify<ObjectOutput<Shape>>[];
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] }[];
+    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
+    __outputType: ShallowSimplify<ObjectOutput<Shape>>[];
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
     operators: OperatorsAny;
   }
-  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
+  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
   export {};
 }
 interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
@@ -3162,16 +3432,16 @@ interface OperatorsCount extends OperatorsNumber {
 type CountColumn = Column.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<Column.Pick.QueryColumnOfDataType<DataType>>;
-type NumericReturn<T extends PickQuerySelectable, Arg> = Arg extends keyof T['__selectable'] ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<T['__selectable'][Arg]['column']['dataType'], T['__selectable'][Arg]['column']['type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Column.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.Pick.QueryColumnOfTypeAndOps<T['__selectable'][Arg]['column']['dataType'], T['__selectable'][Arg]['column']['__type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<Arg['result']['value']['dataType'], Arg['result']['value']['__type'] | null, OperatorsNumber>> & OperatorsNumber : never;
 type NullableNumberReturn<T, DataType> = SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<DataType, number | null, OperatorsNumber>> & OperatorsNumber;
 type BooleanQueryColumn = Column.Pick.QueryColumnOfTypeAndOps<'bool', boolean, OperatorsBoolean>;
 type BooleanNullable = Column.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<never>;
 }> & OperatorsArray<never>;
 interface RecordSelectableOrExpression<T extends PickQuerySelectable> {
@@ -3179,9 +3449,9 @@ 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.Pick.QueryColumnOfTypeAndOps<string, string, OperatorsText>;
@@ -3618,11 +3888,11 @@ declare class OrExpression extends Expression<BooleanQueryColumn> {
 interface QueryReturnsFnAdd<T extends PickQueryColumTypes> extends PickQueryHasSelect {
   type<C extends Column.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.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.
@@ -3715,16 +3985,16 @@ declare class QueryExpressions {
 type WhereArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? WhereArg<T> | WhereArgs<T> : K extends 'OR' ? (WhereArg<T> | WhereArgs<T>)[] : K extends 'IN' ? MaybeArray<{
   columns: (keyof T['__selectable'])[];
   values: unknown[][] | IsQuery | Expression;
-}> : 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>);
@@ -3740,12 +4010,12 @@ type WhereQueryBuilder<T extends PickQueryRelations> = EmptyObject extends T['re
 type WhereArgs<T extends PickQuerySelectableRelations> = WhereArg<T>[];
 type WhereNotArgs<T extends PickQuerySelectableRelations> = [WhereArg<T>];
 type WhereInColumn<T extends PickQuerySelectableRelations> = keyof T['__selectable'] | [keyof T['__selectable'], ...(keyof T['__selectable'])[]];
-type WhereInValues<T extends PickQuerySelectableRelations, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['queryType']> | IsQuery | Expression : ({ [I in keyof Column]: Column[I] extends keyof T['__selectable'] ? T['__selectable'][Column[I]]['column']['queryType'] : never } & {
+type WhereInValues<T extends PickQuerySelectableRelations, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['__queryType']> | IsQuery | Expression : ({ [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 | Expression;
-type WhereInArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['queryType']> | IsQuery | Expression };
+type WhereInArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['__queryType']> | IsQuery | Expression };
 interface QueryHasWhere {
   __hasWhere: true;
 }
@@ -4823,6 +5093,7 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
   comment?: string;
   readOnly?: boolean;
   materialized?: boolean;
+  generatorIgnored?: true;
   primaryKeys?: string[];
   singlePrimaryKey: SinglePrimaryKey;
   uniqueColumns: UniqueColumns;
@@ -4837,6 +5108,7 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
   tableRls?: Rls.TableConfig;
   tableGrants?: Grant.TableClassGrant[];
   viewData?: {
+    query?: Query;
     sql?: string | RawSqlBase;
     recursive?: boolean;
     checkOption?: 'LOCAL' | 'CASCADED';
@@ -4856,8 +5128,8 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
    */
   nestedCreateBatchMax: number;
 }
-type ShapeColumnPrimaryKeys<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never }[keyof Shape]]: UniqueQueryTypeOrExpression<Shape[K]['queryType']> };
-type ShapeUniqueColumns<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? { [C in K]: UniqueQueryTypeOrExpression<Shape[K]['queryType']> } : never }[keyof Shape];
+type ShapeColumnPrimaryKeys<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never }[keyof Shape]]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> };
+type ShapeUniqueColumns<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? { [C in K]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> } : never }[keyof Shape];
 type UniqueConstraints<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? string extends Shape[K]['data']['primaryKey'] ? never : Shape[K]['data']['primaryKey'] : Shape[K]['data']['unique'] extends string ? string extends Shape[K]['data']['unique'] ? never : Shape[K]['data']['unique'] : never }[keyof Shape];
 type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
 interface DbSharedOptions extends QueryLogOptions {
@@ -4928,6 +5200,10 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
    * Mark query objects as backed by a materialized relation.
    */
   materialized?: true | undefined;
+  /**
+   * Exclude a table-like definition from migration DDL generation.
+   */
+  generatorIgnore?: true | undefined;
   /**
    * Computed SQL or JS columns definitions
    */
@@ -4959,8 +5235,8 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   __defaultSelect: DefaultSelect;
   baseQuery: Query;
   columns: (keyof Shape)[];
-  outputType: ColumnsShape.DefaultSelectOutput<Shape>;
-  inputType: ColumnsShape.Input<Shape>;
+  __outputType: ColumnsShape.DefaultSelectOutput<Shape>;
+  __inputType: ColumnsShape.Input<Shape>;
   result: { [K in DefaultSelect]: Shape[K] };
   returnType: undefined;
   then: QueryThenShallowSimplifyArr<ColumnsShape.DefaultOutput<Shape>>;
@@ -5058,7 +5334,7 @@ type MapTableScopesOption<T> = T extends {
 } ? {
   nonDeleted: unknown;
 } : EmptyObject;
-interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, never, ColumnTypes>, DbTableConstructor<ColumnTypes> {
+interface DbResult<ColumnTypes> extends Db<undefined, EmptyObject, never, never, never, never, ColumnTypes, never, never>, DbTableConstructor<ColumnTypes> {
   adapterNotInTransaction: Adapter;
   adapter: Adapter;
   close: Adapter['close'];
@@ -5318,6 +5594,9 @@ interface BatchSql extends SqlCommonOptions {
 type Sql = SingleSql | BatchSql;
 declare const quoteTableWithSchema: (query: ToSQLQuery) => string;
 declare const getSqlText: (sql: Sql) => string;
+declare const queryToSql: (query: Query) => SingleSql;
+declare const rawSqlToSql: (sql: string | RawSqlBase) => SingleSql;
+declare const sqlToRawSql: (sql: SingleSql) => RawSqlBase;
 declare class QuerySql<ColumnTypes> {
   /**
    * @deprecated: use `sql` exported from the `createBaseTable` (see "define a base table" in the docs)
@@ -5504,7 +5783,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> {
@@ -6115,7 +6394,7 @@ interface SelectAsValue {
   [K: string]: string | Query | Expression | undefined;
 }
 declare const getShapeFromSelect: (q: IsQuery, isSubQuery?: boolean) => Column.QueryColumns;
-type AfterHook<Select extends PropertyKey[], Shape extends Column.QueryColumns> = QueryAfterHook<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['outputType'] : never }[]>;
+type AfterHook<Select extends PropertyKey[], Shape extends Column.QueryColumns> = QueryAfterHook<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['__outputType'] : never }[]>;
 type HookSelectArg<T extends PickQueryShape> = (keyof T['shape'] & string)[];
 declare const _hookSelectColumns: (query: Query, columns: string[], asFn: (as: string[]) => void) => void;
 declare class QueryHookUtils<T extends PickQueryInputType> {
@@ -6123,7 +6402,7 @@ declare class QueryHookUtils<T extends PickQueryInputType> {
   columns: string[];
   private key;
   constructor(query: IsQuery, columns: string[], key: 'hookCreateSet' | 'hookUpdateSet');
-  set: (data: { [K in keyof T["inputType"]]?: T["inputType"][K] | (() => QueryOrExpression<T["inputType"][K]>) }) => void;
+  set: (data: { [K in keyof T["__inputType"]]?: T["__inputType"][K] | (() => QueryOrExpression<T["__inputType"][K]>) }) => void;
 }
 declare const _queryHookAfterCreate: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T["shape"]>) => T;
 declare const _queryHookAfterUpdate: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T["shape"]>) => T;
@@ -6276,7 +6555,7 @@ interface ColumnDataSelectSqlProp {
 interface SelectSqlCallback {
   (column: ColumnRefExpression<Column.Pick.QueryColumn>): Expression;
 }
-type SelectSqlColumn<T extends Column.Pick.DataAndDataType, Expr extends Expression> = 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.Pick.DataAndDataType, Expr extends Expression> = unknown extends Expr['result']['value']['__outputType'] ? T : { [K in keyof T]: K extends '__outputType' ? Expr['result']['value']['__outputType'] : T[K] };
 declare namespace Column {
   export namespace Modifiers {
     export interface IsPrimaryKey<Name extends string> {
@@ -6289,9 +6568,9 @@ declare namespace Column {
         unique: Name;
       };
     };
-    export type Nullable<T extends Column.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.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;
@@ -6300,9 +6579,9 @@ declare namespace Column {
       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.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.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.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.Pick.Data, Value> = { [K in keyof T]: K extends 'data' ? DefaultData<T['data'], Value> : T[K] };
     type DefaultSelectData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'explicitSelect' ? Value extends true ? false : true : T[K] };
@@ -6312,7 +6591,7 @@ declare namespace Column {
         appReadOnly: true;
       };
     }
-    export type Generated<T extends Column.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.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 {
@@ -6320,17 +6599,17 @@ declare namespace Column {
       data: Column.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;
@@ -6340,22 +6619,22 @@ declare namespace Column {
     }
     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 {
@@ -6375,8 +6654,8 @@ declare namespace Column {
       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 {}
@@ -6426,9 +6705,9 @@ declare namespace Column {
     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;
@@ -6525,24 +6804,24 @@ declare const setDataValue: <T extends Column.Pick.Data, Key extends string, Val
 declare function setCurrentColumnName(name: string): void;
 declare const consumeColumnName: () => string | undefined;
 declare const setDefaultLanguage: (lang?: string) => void;
-declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSchemaArg, 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 {
+  abstract __schema: ColumnTypeSchemaArg;
   abstract dataType: string;
-  abstract operators: Ops;
+  abstract operators: any;
   abstract toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  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, inputSchema: InputSchema, outputSchema?: OutputSchema, querySchema?: QuerySchema);
+  constructor(schema: ColumnTypeSchemaArg, inputSchema: unknown, outputSchema?: unknown, querySchema?: unknown);
   /**
    * Set a default value to a column. Columns that have defaults become optional when creating a record.
    *
@@ -6569,7 +6848,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    *
    * @param value - default value or a function returning a value
    */
-  default<T extends Column.Pick.DataAndInputType, Value extends T['inputType'] | null | RawSqlBase | (() => T['inputType'])>(this: T, value: Value): Column.Modifiers.Default<T, Value>;
+  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.Default<T, Value>;
   /**
    * Use `hasDefault` to let the column be omitted when creating records.
    *
@@ -6615,7 +6894,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * }
    * ```
    */
-  nullable: Schema['nullable'];
+  nullable: this['__schema']['nullable'];
   /**
    * Set a custom function to process value for the column when creating or updating a record.
    *
@@ -6651,7 +6930,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    *
    * @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.
    *
@@ -6689,7 +6968,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    *
    * @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.
    *
@@ -6734,7 +7013,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * })
    * ```
    */
-  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`.
@@ -6754,17 +7033,17 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * @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.
    *
@@ -6807,8 +7086,10 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * // 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.
    *
@@ -6864,17 +7145,19 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * // 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.
    *
@@ -6968,7 +7251,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * }
    * ```
    */
-  setOnCreate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
+  setOnCreate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['__inputType'] | void): T;
   /**
    * Set a column value when updating a record.
    * This works for [readOnly](#readonly) columns as well.
@@ -6985,7 +7268,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * }
    * ```
    */
-  setOnUpdate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
+  setOnUpdate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['__inputType'] | void): T;
   /**
    * Set a column value when creating or updating a record.
    * This works for [readOnly](#readonly) columns as well.
@@ -7002,7 +7285,7 @@ declare abstract class Column<Schema extends ColumnTypeSchemaArg = ColumnTypeSch
    * }
    * ```
    */
-  setOnSave<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
+  setOnSave<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['__inputType'] | void): T;
   /**
    * Mark the column as a primary key.
    * This column type becomes an argument of the `.find` method.
@@ -7522,11 +7805,11 @@ declare class QueryCreateFrom {
 }
 interface CreateSelf extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType, Query.Pick.IsNotReadOnly {}
 type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
-type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = { [K in keyof T['inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['inputType'] ? CreateColumn<T, K> : never };
-type CreateDataWithDefaultsForRelations<T extends CreateSelf, 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, K extends keyof T['inputType']> = T['inputType'][K] | ((q: T) => QueryOrExpression<T['inputType'][K]>);
+type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['__inputType'] ? CreateColumn<T, K> : never };
+type CreateDataWithDefaultsForRelations<T extends CreateSelf, 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, K extends keyof T['__inputType']> = T['__inputType'][K] | ((q: T) => QueryOrExpression<T['__inputType'][K]>);
 type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
-type CreateRelationsDataOmittingFKeys<T extends CreateSelf, 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 CreateRelationsDataOmittingFKeys<T extends CreateSelf, 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 CreateResult<T extends CreateSelf, 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>>;
@@ -7541,7 +7824,7 @@ type InsertManyResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T[
  *
  * 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, Data> = EmptyObject 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.Pick.QueryColumnOfTypeAndOps<string, Exclude<T['result'][K]['outputType'], null>, T['result'][K]['operators']> : T['result'][K] };
+type NarrowCreateResult<T extends CreateSelf, Data> = EmptyObject 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.Pick.QueryColumnOfTypeAndOps<string, Exclude<T['result'][K]['__outputType'], null>, T['result'][K]['operators']> : T['result'][K] };
 type IgnoreResult<T extends CreateSelf> = T['returnType'] extends 'oneOrThrow' ? QueryTakeOptional<T> : T['returnType'] extends 'valueOrThrow' ? SetQueryReturnsColumnOptional<T, T['result']['value']> : T;
 type OnConflictArg<T extends PickQueryUniqueProperties> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'] | Expression | {
   constraint: T['internal']['uniqueConstraints'];
@@ -7568,7 +7851,7 @@ declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<Create
  */
 type CreateMethodsNames = 'create' | 'insert' | 'createMany' | 'insertMany' | CreateFromMethodNames;
 type CreateManyMethodsNames = 'createMany' | 'insertMany' | CreateManyFromMethodNames;
-type ExtraPropertiesAreNotAllowed<T extends CreateSelf, 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, 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.
@@ -7842,7 +8125,7 @@ declare class QueryCreate {
    */
   onConflictDoNothing<T extends CreateSelf, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): IgnoreResult<T>;
 }
-type OnConflictSet$1<T extends CreateSelf> = { [K in keyof T['inputType']]?: T['inputType'][K] | (() => QueryOrExpression<T['inputType'][K]>) };
+type OnConflictSet$1<T extends CreateSelf> = { [K in keyof T['__inputType']]?: T['__inputType'][K] | (() => QueryOrExpression<T['__inputType'][K]>) };
 declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflictArg<T> | undefined> {
   private query;
   private onConflict;
@@ -7911,11 +8194,11 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
   }): T;
 }
 interface UpdateSelf extends PickQuerySelectable, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryInputType, PickQueryAs, PickQueryHasSelect, PickQueryHasWhere, Query.Pick.IsNotReadOnly {}
-type UpdateData<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<T['inputType'][K]>) : T['returnType'] extends undefined | 'all' ? T['relations'][K]['dataForUpdate'] : T['relations'][K]['dataForUpdateOne'] };
+type UpdateData<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<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<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;
@@ -7924,10 +8207,10 @@ interface UpdateManyBySelf extends UpdateSelf {
     uniqueConstraints: unknown;
   };
 }
-type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column.Modifiers.IsPrimaryKey<string> ? K : never]: T['shape'][K]['queryType'] | Expression } & { [P in keyof T['inputType']]?: T['inputType'][P] | Expression })[];
+type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column.Modifiers.IsPrimaryKey<string> ? K : never]: T['shape'][K]['__queryType'] | Expression } & { [P in keyof T['__inputType']]?: T['__inputType'][P] | Expression })[];
 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 })[];
+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 })[];
 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 const _queryUpdate: <T extends UpdateSelf>(updateSelf: T, arg: UpdateArg<T>) => UpdateResult<T>;
 declare const _queryUpdateOrThrow: <T extends UpdateSelf>(q: T, arg: UpdateArg<T>) => UpdateResult<T>;
@@ -8374,8 +8657,16 @@ 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;
 }
-declare abstract class VirtualColumn<Schema extends ColumnSchemaConfig, InputSchema extends Schema['type'] = ReturnType<Schema['never']>> extends Column<Schema, unknown, InputSchema, OperatorsAny> {
+declare abstract class VirtualColumn<Schema extends ColumnSchemaConfig, InputSchema extends Schema['__schemaType'] = ReturnType<Schema['never']>> extends Column {
+  __schema: Schema;
   dataType: string;
+  __type: unknown;
+  __inputType: unknown;
+  inputSchema: InputSchema;
+  __outputType: unknown;
+  outputSchema: InputSchema;
+  __queryType: unknown;
+  querySchema: ReturnType<Schema['never']>;
   operators: OperatorsAny;
   constructor(schema: Schema, inputSchema?: InputSchema);
   toCode(): never;
@@ -8412,20 +8703,20 @@ interface ComputedOptionsConfig {
 type ComputedOptionsFactory<ColumnTypes, Shape extends Column.QueryColumns> = (t: ComputedMethods<ColumnTypes, Shape>) => ComputedOptionsConfig;
 interface RuntimeComputedQueryColumn<OutputType> extends Column.Pick.QueryColumn {
   dataType: 'runtimeComputed';
-  type: never;
-  outputType: OutputType;
-  queryType: undefined;
+  __type: never;
+  __outputType: OutputType;
+  __queryType: undefined;
   operators: {
     cannotQueryRuntimeComputed: never;
   };
 }
 interface ComputedMethods<ColumnTypes, Shape extends Column.QueryColumns> extends QueryComputedArg<ColumnTypes, Shape> {
-  computeAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['outputType'] }) => OutputType): {
+  computeAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['__outputType'] }) => OutputType): {
     result: {
       value: RuntimeComputedQueryColumn<OutputType>;
     };
   };
-  computeBatchAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['outputType'] }[]) => MaybePromise<OutputType[]>): {
+  computeBatchAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['__outputType'] }[]) => MaybePromise<OutputType[]>): {
     result: {
       value: RuntimeComputedQueryColumn<OutputType>;
     };
@@ -8831,7 +9122,7 @@ interface ToSQLQuery extends IsQuery {
 }
 interface FromQuerySelf extends PickQuerySelectable, PickQueryShape, PickQueryReturnType, PickQueryWithData, PickQueryAs, PickQueryHasSelect {}
 type FromArg<T extends FromQuerySelf> = IsQuery | Exclude<keyof T['withData'], symbol | number>;
-type FromResult<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? { [K in keyof T]: K extends '__selectable' ? SelectableFromShape<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<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<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? { [K in keyof T]: K extends '__selectable' ? SelectableFromShape<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<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 ? {
@@ -9172,7 +9463,7 @@ declare class CteQuery {
 }
 type UnionArgs<T extends PickQueryResult> = ({
   result: { [K in keyof T['result']]: {
-    queryType: T['result'][K]['queryType'];
+    __queryType: T['result'][K]['__queryType'];
   } };
 } | ((q: T) => Expression))[];
 declare class Union {
@@ -9296,7 +9587,7 @@ declare class Clear {
 type HavingArgFn<T> = (q: T) => {
   result: {
     value: {
-      outputType: boolean;
+      __outputType: boolean;
     };
   };
 };
@@ -9526,7 +9817,7 @@ interface QueryPluckSelf extends PickQuerySelectable, PickQueryRelationsWithData
 type PluckArg<T extends QueryPluckSelf> = SelectableOrExpression<T> | ((q: SelectAsFnArg<T>) => Expression | Query.Pick.SingleValueResult);
 type PluckResult<T extends QueryPluckSelf, S extends PluckArg<T>> = S extends ((q: never) => infer R) ? R extends Expression ? 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:
@@ -9799,15 +10090,15 @@ type QueryHelperResult<T extends IsQueryHelper> = T['__result'];
 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.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.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.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, QueryUpsert, QueryOrCreate, QueryGet, QueryPluck, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow {}
 declare class QueryMethods<ColumnTypes> {
   /**
@@ -10238,10 +10529,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>;
@@ -10315,7 +10606,7 @@ interface Query extends IsQuery, PickQueryTable, PickQueryShape, PickQuerySelect
   returnType: QueryReturnType;
   qb: QueryBuilder;
   columnTypes: unknown;
-  inputType: RecordUnknown;
+  __inputType: RecordUnknown;
   q: QueryData;
   then: QueryThen<unknown>;
   catch: QueryCatch;
@@ -10352,43 +10643,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.Pick.Type> = SelectableOfType<T, C['type']> | Expression<Column.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.Pick.Type> = SelectableOfType<T, C['__type']> | Expression<Column.Pick.QueryColumnOfType<C['__type'] | null>>;
 type SetQueryReturnsAll<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<T['result']>> : T[K] } & QueryHasWhere;
 type SetQueryReturnsAllResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K] } & QueryHasWhere;
-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.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.Output<T['result']>> : T[K] };
 type QueryManyTakeOptional<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.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.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.Output<T['result']>> : T[K] };
 type QueryManyTake<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
 type SetQueryReturnsOne<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
 type SetQueryReturnsOneResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T[K] };
 type SetQueryReturnsRows<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnsShape.Output<T['result']>[keyof T['result']][][]> : T[K] };
 type SetQueryReturnsPluck<T extends PickQuerySelectable, S extends keyof T['__selectable'] | Expression> = 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 ? S['result']['value'] : never;
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression ? S['result']['value']['outputType'] : never)[]> : T[K] };
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression ? 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.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.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.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.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.Pick.QueryColumnOfType<number>;
 } : K extends 'then' ? QueryThen<number> : T[K] };
@@ -10509,7 +10800,7 @@ interface PickQueryUniqueProperties {
   };
 }
 interface PickQueryInputType {
-  inputType: RecordUnknown;
+  __inputType: RecordUnknown;
 }
 interface PickQueryWithData {
   withData: WithDataItems;
@@ -10752,4 +11043,4 @@ declare const testTransaction: {
    */
   close(arg: Arg$1): Promise<void>;
 };
-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, 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, DateBaseColumn, DateColumn, type DateColumnData, DateTimeBaseClass, DateTimeTzBaseClass, Db, 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, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinQueryMethod, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, OrchidOrmInternalError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type Query, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, QueryError, type QueryHasWhere, type QueryHelperResult, 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 RefreshMaterializedViewOptions, 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, TextBaseColumn, 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 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, copyTableData, createDbWithAdapter, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, 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, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, referencesArgsToCode, refreshMaterializedView, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, tableDataMethods, testTransaction, 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, 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, DateBaseColumn, DateColumn, type DateColumnData, DateTimeBaseClass, DateTimeTzBaseClass, Db, 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, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinQueryMethod, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, type OperatorsText, OrchidOrmInternalError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type Query, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, QueryError, type QueryHasWhere, type QueryHelperResult, 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 RefreshMaterializedViewOptions, 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, TextBaseColumn, 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 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, copyTableData, createDbWithAdapter, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, 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, refreshMaterializedView, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, testTransaction, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };