pqb 0.16.4 → 0.16.6

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, SQLQueryArgs, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, Expression, ColumnTypeBase, MaybeArray, TemplateLiteralArgs, ColumnsParsers, getValueKey, StringKey, NullableColumn, EmptyTuple, SetOptional, MergeObjects, RawSQLBase, RawSQLValues, RawSQLArgs, Spread, ColumnOperatorBase, ColumnOperatorFnBase, Code, ArrayMethodsData, arrayTypeMethods, JSONType, JSONUnknown, JSONTypes, StringTypeData, PrimaryKeyColumn, stringTypeMethods, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, NumberTypeMethods, ColumnWithDefault, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ValidationContext, ErrorMessage, ColumnDataBase } from 'orchid-core';
+import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, SQLQueryArgs, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, ColumnTypeBase, Expression, MaybeArray, TemplateLiteralArgs, ColumnsParsers, getValueKey, StringKey, NullableColumn, EmptyTuple, SetOptional, MergeObjects, RawSQLBase, RawSQLValues, RawSQLArgs, Spread, ColumnOperatorBase, ColumnOperatorFnBase, Code, ArrayMethodsData, arrayTypeMethods, JSONType, JSONUnknown, JSONTypes, StringTypeData, PrimaryKeyColumn, stringTypeMethods, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, NumberTypeMethods, ColumnWithDefault, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ValidationContext, ErrorMessage, ColumnDataBase } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -125,12 +125,11 @@ type DbTableOptions = {
     snakeCase?: boolean;
     language?: string;
 } & QueryLogOptions;
-declare const anyShape: Record<string, ColumnType<unknown, BaseOperators, unknown>>;
+declare const anyShape: Record<string, ColumnType<unknown, BaseOperators, unknown, unknown, unknown>>;
 interface Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes, Data = Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]> extends DbBase<Adapter, Table, Shape, CT>, QueryMethods<CT> {
     new (adapter: Adapter, queryBuilder: Db<Table, Shape, Relations, CT>, table?: Table, shape?: Shape, options?: DbTableOptions): this;
     internal: Query['internal'];
     queryBuilder: Db;
-    whereQueryBuilder: Query['whereQueryBuilder'];
     onQueryBuilder: Query['onQueryBuilder'];
     primaryKeys: Query['primaryKeys'];
     q: QueryData;
@@ -258,13 +257,24 @@ declare abstract class QueryBase implements QueryBaseCommon {
     relations: RelationsBase;
     withData: WithDataBase;
     baseQuery: Query;
-    internal: QueryInternal & {
-        selectQueryBuilder?: SelectQueryBuilder<Query>;
-    };
+    internal: QueryInternal;
     meta: QueryMetaBase;
     returnType: QueryReturnType;
 }
 
+/**
+ * Used to build relation sub queries where agg methods such as `count` can be chained with column operators such as `gt`, `lt`.
+ * See {@link RelationSubQueries}.
+ */
+type SubQueryBuilder<T extends Query, Agg = SelectAggMethods<T>> = Omit<T, keyof Agg> & Agg;
+/**
+ * Build and memoize a query builder to use in the argument of select callback.
+ * See {@link SubQueryBuilder}
+ *
+ * @param q - query object to base the query builder upon
+ */
+declare const getSubQueryBuilder: <T extends Query>(q: T) => SubQueryBuilder<T, SelectAggMethods<T>>;
+
 type BaseRelation = {
     type: string;
     key: string;
@@ -353,6 +363,52 @@ type RelationQuery<Name extends PropertyKey = string, Params extends Record<stri
     };
     join<T extends Query>(this: T): T;
 };
+/**
+ * Map relations into a Record where each relation aggregate methods can be chained with column operators.
+ * Used in `where` callback argument, see {@link WhereQueryBuilder}.
+ */
+type RelationSubQueries<T extends QueryBase> = {
+    [K in keyof T['relations']]: T[K] extends Query ? SubQueryBuilder<T[K]> : never;
+};
+
+type AggregateOptions<T extends Query> = {
+    distinct?: boolean;
+    order?: OrderArg<T> | OrderArg<T>[];
+    filter?: WhereArg<T>;
+    filterOr?: WhereArg<T>[];
+    withinGroup?: boolean;
+    over?: Over<T>;
+};
+type Over<T extends Query> = keyof T['windows'] | WindowArgDeclaration<T>;
+declare class FnExpression<Q extends Query, T extends ColumnTypeBase> extends Expression<T> {
+    q: Q;
+    fn: string;
+    args: (SelectableOrExpression<Q> | {
+        pairs: Record<string, SelectableOrExpression<Q>>;
+    } | {
+        value: unknown;
+    })[];
+    options: AggregateOptions<Q>;
+    _type: T;
+    _mods: unknown[];
+    constructor(q: Q, fn: string, args: (SelectableOrExpression<Q> | {
+        pairs: Record<string, SelectableOrExpression<Q>>;
+    } | {
+        value: unknown;
+    })[], options: AggregateOptions<Q>, _type: T);
+    modifySQL(sql: string, ctx: ToSqlCtx, quotedAs?: string): string;
+    toSQL(ctx: ToSqlCtx, quotedAs?: string): string;
+}
+type ColumnExpression<C extends ColumnTypeBase, Ops extends BaseOperators = C['operators']> = Expression<C> & {
+    [K in keyof Ops]: (arg: Parameters<Ops[K]>[1]) => ColumnExpression<BooleanNullable>;
+};
+declare const makeColumnFnClass: <T extends ColumnType<unknown, BaseOperators, unknown, unknown, unknown>>(column: T) => typeof FnExpression;
+type FnExpressionArg<Q extends Query> = SelectableOrExpression<Q> | {
+    pairs: Record<string, SelectableOrExpression<Q>>;
+} | {
+    value: unknown;
+};
+declare const makeColumnFn: <T extends ColumnType<unknown, BaseOperators, unknown, unknown, unknown>, Q extends Query>(column: T, q: Q, fn: string, args: FnExpressionArg<Q>[], options?: AggregateOptions<Q> | undefined) => ColumnExpression<T, T["operators"]>;
 
 declare const checkIfASimpleQuery: (q: Query) => boolean;
 type WithItem = [
@@ -467,7 +523,7 @@ type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query |
     EXISTS?: MaybeArray<SimpleJoinItem['args']>;
     ON?: WhereOnItem | WhereJsonPathEqualsItem;
     SEARCH?: MaybeArray<WhereSearchItem>;
-}) | ((q: unknown) => QueryBase) | Query | Expression;
+}) | ((q: unknown) => QueryBase | FnExpression<Query, ColumnTypeBase>) | Query | Expression;
 type WhereInItem = {
     columns: string[];
     values: unknown[][] | Query | Expression;
@@ -691,51 +747,18 @@ declare const resolveSubQueryCallback: (q: Query, cb: (q: Query) => Query) => Qu
  */
 declare const joinSubQuery: (q: Query, sub: Query) => Query;
 
-type AggregateOptions<T extends Query> = {
-    distinct?: boolean;
-    order?: OrderArg<T> | OrderArg<T>[];
-    filter?: WhereArg<T>;
-    filterOr?: WhereArg<T>[];
-    withinGroup?: boolean;
-    over?: Over<T>;
-};
-type Over<T extends Query> = keyof T['windows'] | WindowArgDeclaration<T>;
-declare class FnExpression<Q extends Query, T extends ColumnTypeBase> extends Expression<T> {
-    q: Q;
-    fn: string;
-    args: (SelectableOrExpression<Q> | {
-        pairs: Record<string, SelectableOrExpression<Q>>;
-    } | {
-        value: unknown;
-    })[];
-    options: AggregateOptions<Q>;
-    _type: T;
-    _mods: unknown[];
-    constructor(q: Q, fn: string, args: (SelectableOrExpression<Q> | {
-        pairs: Record<string, SelectableOrExpression<Q>>;
-    } | {
-        value: unknown;
-    })[], options: AggregateOptions<Q>, _type: T);
-    modifySQL(sql: string, ctx: ToSqlCtx, quotedAs?: string): string;
-    toSQL(ctx: ToSqlCtx, quotedAs?: string): string;
-}
-type ColumnExpression<C extends ColumnTypeBase, Ops extends BaseOperators = C['operators']> = Expression<C> & {
-    [K in keyof Ops]: (arg: Parameters<Ops[K]>[1]) => ColumnExpression<BooleanNullable>;
-};
-declare const makeColumnFnClass: <T extends ColumnType<unknown, BaseOperators, unknown>>(column: T) => typeof FnExpression;
-type FnExpressionArg<Q extends Query> = SelectableOrExpression<Q> | {
-    pairs: Record<string, SelectableOrExpression<Q>>;
-} | {
-    value: unknown;
-};
-declare const makeColumnFn: <T extends ColumnType<unknown, BaseOperators, unknown>, Q extends Query>(column: T, q: Q, fn: string, args: FnExpressionArg<Q>[], options?: AggregateOptions<Q> | undefined) => ColumnExpression<T, T["operators"]>;
-
 declare const isSelectingCount: (q: Query) => boolean;
 type NullableInteger = NullableColumn<IntegerColumn>;
 type NullableNumber = NullableColumn<NumberColumn>;
 type NullableJSONAgg<T extends Query, Arg extends SelectableOrExpression<T>> = NullableColumn<ArrayColumn<ExpressionOutput<T, Arg>>>;
-type NullableJSONObject<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>> = NullableColumn<ColumnType<{
-    [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+type NullableJSONObject<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>, Outputs extends Record<string, ColumnTypeBase> = {
+    [K in keyof Obj]: ExpressionOutput<T, Obj[K]>;
+}> = NullableColumn<ColumnType<{
+    [K in keyof Outputs]: Outputs[K]['type'];
+}, BaseOperators, {
+    [K in keyof Outputs]: Outputs[K]['inputType'];
+}, {
+    [K in keyof Outputs]: Outputs[K]['outputType'];
 }>>;
 type NullableText = NullableColumn<TextColumn>;
 declare class SelectAggMethods<T extends Query = Query> {
@@ -773,13 +796,6 @@ declare class SelectAggMethods<T extends Query = Query> {
      * @param type
      */
     fn<Type = unknown, C extends ColumnType = ColumnType<Type>>(fn: string, args: SelectableOrExpression<T>[], options?: AggregateOptions<T>, type?: (t: T['columnTypes']) => C): ColumnExpression<C>;
-    /**
-     * Combine two boolean expressions with `OR`.
-     *
-     * @param left - boolean expression such as `max('column').gt(10)`
-     * @param right - other boolean expression or a raw SQL
-     */
-    or(left: ColumnExpression<BooleanNullable>, right: Expression<BooleanNullable>): ColumnExpression<BooleanNullable>;
     /**
      * Count records with the `count` function:
      *
@@ -1383,8 +1399,25 @@ declare class CopyMethods {
 }
 
 type WithSelectable<T extends QueryBase, W extends keyof T['withData']> = T['withData'][W] extends WithDataItem ? StringKey<keyof T['withData'][W]['shape']> | `${T['withData'][W]['table']}.${StringKey<keyof T['withData'][W]['shape']>}` : never;
+/**
+ * The first argument of all `join` and `joinLateral` methods.
+ * See argument of {@link Join.join}.
+ */
 type JoinFirstArg<T extends QueryBase> = Query | keyof T['relations'] | keyof T['withData'] | ((q: Pick<T, keyof T['relations']>) => Query);
+/**
+ * Arguments of `join` methods (not `joinLateral`).
+ * See {@link Join.join}
+ */
 type JoinArgs<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg extends Query ? JoinQueryArgs<T, Arg> : Arg extends keyof T['relations'] ? EmptyTuple : Arg extends keyof T['withData'] ? JoinWithArgs<T, Arg> : never;
+/**
+ * Column names of the joined table that can be used to join.
+ * Derived from 'result', not from 'shape',
+ * because if the joined table has a specific selection, it will be wrapped like:
+ * ```sql
+ * JOIN (SELECT something FROM joined) joined ON joined.something = ...
+ * ```
+ * And the selection becomes available to use in the `ON` and to select from the joined table.
+ */
 type JoinSelectable<Q extends Query> = keyof Q['result'] | `${AliasOrTable<Q>}.${StringKey<keyof Q['result']>}`;
 type JoinQueryArgs<T extends QueryBase, Q extends Query> = [
     conditions: Record<JoinSelectable<Q>, Selectable<T> | Expression> | Expression | true
@@ -1406,6 +1439,15 @@ type JoinWithArgs<T extends QueryBase, W extends keyof T['withData']> = [
     op: string,
     rightColumn: Selectable<T> | Expression
 ];
+/**
+ * Result of all `join` methods, not `joinLateral`.
+ * Adds joined table columns from its 'result' to the 'selectable' of the query.
+ *
+ * @param T - query type to join to
+ * @param Arg - first arg of join, see {@link JoinFirstArg}
+ * @param RequireJoined - when false, joined table shape will be mapped to make all columns optional
+ * @param RequireMain - when false, main table shape will be mapped to make all columns optional (for right and full join)
+ */
 type JoinResult<T extends Query, Arg extends JoinFirstArg<T>, RequireJoined extends boolean, RequireMain extends boolean, Cb extends (q: never) => {
     meta: QueryMetaBase;
 } = () => {
@@ -1413,11 +1455,19 @@ type JoinResult<T extends Query, Arg extends JoinFirstArg<T>, RequireJoined exte
 }, J extends Pick<Query, 'result' | 'table' | 'meta'> = Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['table'] : Arg extends (q: never) => Query ? ReturnType<Arg> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
     table: T['withData'][Arg]['table'];
     result: T['withData'][Arg]['shape'];
-    meta: QueryMetaBase;
+    meta: QueryBase['meta'];
 } : never : never : never, Selectable extends SelectableBase = JoinResultSelectable<J, RequireJoined, ReturnType<Cb>>> = RequireMain extends true ? JoinAddSelectable<T, Selectable> : JoinOptionalMain<T, Selectable>;
-type JoinLateralResult<T extends Query, R extends QueryBase, RequireJoined extends boolean, RequireMain extends boolean, Selectable extends SelectableBase = JoinResultSelectable<R, RequireJoined, {
+/**
+ * Result of all `joinLateral` methods.
+ * Adds joined table columns from its 'result' to the 'selectable' of the query.
+ *
+ * @param T - query type to join to
+ * @param Arg - first arg of join, see {@link JoinFirstArg}
+ * @param RequireJoined - when false, joined table shape will be mapped to make all columns optional
+ */
+type JoinLateralResult<T extends Query, R extends QueryBase, RequireJoined extends boolean, Selectable extends SelectableBase = JoinResultSelectable<R, RequireJoined, {
     meta: QueryMetaBase;
-}>> = RequireMain extends true ? JoinAddSelectable<T, Selectable> : JoinOptionalMain<T, Selectable>;
+}>> = JoinAddSelectable<T, Selectable>;
 type JoinResultSelectable<J extends Pick<Query, 'result' | 'table' | 'meta'>, RequireJoined extends boolean, CbResult extends {
     meta: QueryMetaBase;
 }, Result extends ColumnsShapeBase = RequireJoined extends true ? J['result'] : {
@@ -1467,7 +1517,7 @@ type JoinWithArgToQuery<With extends WithDataItem, Selectable extends Selectable
     baseQuery: Query;
     relations: RelationsBase;
     withData: WithDataBase;
-    meta: QueryMetaBase;
+    meta: QueryBase['meta'];
     internal: QueryInternal;
     returnType: QueryReturnType;
 };
@@ -1475,6 +1525,12 @@ type JoinArgToQuery<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg exte
 type JoinCallback<T extends QueryBase, Arg extends JoinFirstArg<T>> = (q: OnQueryBuilder<T, JoinArgToQuery<T, Arg>>) => OnQueryBuilder;
 type JoinLateralCallback<T extends QueryBase, Arg extends JoinFirstArg<T>, R extends QueryBase, Q extends QueryBase = JoinArgToQuery<T, Arg>> = (q: Q & OnQueryBuilder<T, Q>) => R;
 declare class Join {
+    /**
+     * TODO: write docs
+     *
+     * @param arg - can be a query object, a name of a relation, a name of `with` table, or a callback to join a relation
+     * @param args - arguments depend on the first argument, it can be object with columns, list of columns, `true` literal.
+     */
     join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, true>;
     join<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, true, Cb>;
     _join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, true>;
@@ -1491,10 +1547,10 @@ declare class Join {
     fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, false, Cb>;
     _fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, false>;
     _fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, false, Cb>;
-    joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true, true>;
-    _joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true, true>;
-    leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false, true>;
-    _leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false, true>;
+    joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
+    _joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
+    leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
+    _leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
 }
 type OnArgs<Q extends {
     selectable: SelectableBase;
@@ -1513,10 +1569,15 @@ type OnJsonPathEqualsArgs<T extends QueryBase> = [
     rightColumn: keyof T['selectable'],
     rightPath: string
 ];
-declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBase = QueryBase> extends WhereQueryBuilder<J & {
-    selectable: Omit<S['selectable'], keyof S['shape']>;
-}> implements QueryBase {
-    constructor(q: QueryBase, data: Pick<QueryData, 'shape' | 'joinedShapes'>, joinTo: QueryBase);
+declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBase = QueryBase> extends WhereQueryBase {
+    selectable: J['selectable'] & Omit<S['selectable'], keyof S['shape']>;
+    relations: J['relations'];
+    result: J['result'];
+    shape: J['shape'];
+    baseQuery: Query;
+    withData: {};
+    internal: QueryInternal;
+    constructor(q: QueryBase, { shape, joinedShapes }: Pick<QueryData, 'shape' | 'joinedShapes'>, joinTo: QueryBase);
     on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
     _on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
     orOn<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
@@ -1525,23 +1586,32 @@ declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBas
     _onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
 }
 
-type WhereArg<T extends QueryBase> = {
+type WhereArg<T extends WhereQueryBase> = {
     [K in keyof T['selectable'] | 'NOT' | 'OR' | 'IN' | 'EXISTS']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
         columns: (keyof T['selectable'])[];
         values: unknown[][] | Query | Expression;
-    }> : K extends keyof T['selectable'] ? T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | Expression | Query : never;
-} | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
-type WhereArgs<T extends QueryBase> = WhereArg<T>[] | TemplateLiteralArgs;
+    }> : K extends keyof T['selectable'] ? T['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['selectable'], K> | Expression | Query : never;
+} | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => QueryBase | ColumnExpression<BooleanNullable>);
+/**
+ * Callback argument of `where`.
+ * It has `where` methods (`where`, `whereNot`, `whereExists`, etc.),
+ * and it has relations that you can aggregate and use a boolean comparison with, such as:
+ * ```ts
+ * db.table.where((q) => q.relation.count().equals(10))
+ * ```
+ */
+type WhereQueryBuilder<T extends WhereQueryBase> = Pick<T, keyof WhereQueryBase> & RelationSubQueries<T>;
+type WhereArgs<T extends WhereQueryBase> = WhereArg<T>[] | TemplateLiteralArgs;
 type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
-type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | Expression : ({
-    [I in keyof Column]: Column[I] extends keyof T['selectable'] ? T['selectable'][Column[I]]['column']['type'] : never;
+type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['queryType'][] | Query | 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;
 })[] | Query | Expression;
 type WhereInArg<T extends Pick<Query, 'selectable'>> = {
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | Expression;
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['queryType'][] | Query | Expression;
 };
 type WhereResult<T extends QueryBase> = T & {
     meta: {
@@ -1554,28 +1624,28 @@ type WhereResult<T extends QueryBase> = T & {
  * @param q - query object to add the data to
  * @param args - `where` arguments, may be a template literal
  */
-declare const addWhere: <T extends QueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+declare const addWhere: <T extends WhereQueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
  * Adds `where` arguments to query data with a `NOT` keyword: SQL template string is added as `RawSQL` object, other arguments are added as is.
  *
  * @param q - query object to add the data to
  * @param args - `where` arguments, may be a template literal
  */
-declare const addWhereNot: <T extends QueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+declare const addWhereNot: <T extends WhereQueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
  * Adds `where` arguments to query data. Arguments will be separated from each other with `OR`.
  *
  * @param q - query object to add the data to
  * @param args - `where` arguments, may be a template literal
  */
-declare const addOr: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addOr: <T extends WhereQueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
 /**
  * Adds `where` arguments to query data with a `NOT` keyword. Arguments will be separated from each other with `OR`.
  *
  * @param q - query object to add the data to
  * @param args - `where` arguments, may be a template literal
  */
-declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addOrNot: <T extends WhereQueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
 /**
  * Process arguments of `whereIn` to add them to query data properly.
  *
@@ -1586,7 +1656,7 @@ declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => Wher
  * @param not - adds the `NOT` keyword.
  */
 declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
-declare abstract class Where extends QueryBase {
+declare abstract class Where {
     /**
      * Constructing `WHERE` conditions:
      *
@@ -1677,7 +1747,47 @@ declare abstract class Where extends QueryBase {
      * );
      * ```
      *
-     * ### where special keys
+     * ## where sub query
+     *
+     * `where` handles a special callback where you can query a relation to get some value and filter by that value.
+     *
+     * It is useful for a faceted search. For instance, posts have tags, and we want to find all posts that have all the given tags.
+     *
+     * ```ts
+     * const givenTags = ['typescript', 'node.js'];
+     *
+     * const posts = await db.post.where(
+     *   (post) =>
+     *     post.tags // query tags of the post
+     *       .whereIn('tagName', givenTags) // where name of the tag is inside array
+     *       .count() // count how many such tags were found
+     *       .equals(wantedTags.length), // the count must be exactly the length of array
+     *   // if the post has ony `typescript` tag but not the `node.js` it will be omitted
+     * );
+     * ```
+     *
+     * This will produce an efficient SQL query:
+     *
+     * ```sql
+     * SELECT * FROM "post"
+     * WHERE (
+     *   SELECT count(*) = 3
+     *   FROM "tag" AS "tags"
+     *   WHERE "tag"."tagName" IN ('typescript', 'node.js')
+     *     -- join tags to the post via "postTag" table
+     *     AND EXISTS (
+     *       SELECT 1 FROM "postTag"
+     *       WHERE "postTag"."postId" = "post"."id"
+     *         AND "postTag"."tagId" = "tag"."id"
+     *     )
+     * )
+     * ```
+     *
+     * In the example above we use `count()`, you can also use any other aggregate method instead, such as `min`, `max`, `avg`.
+     *
+     * The `count()` is chained with `equals` to check for a strict equality, any other operation is also allowed, such as `not`, `lt`, `gt`.
+     *
+     * ## where special keys
      *
      * The object passed to `where` can contain special keys, each of the keys corresponds to its own method and takes the same value as the type of argument of the method.
      *
@@ -1697,7 +1807,7 @@ declare abstract class Where extends QueryBase {
      * });
      * ```
      *
-     * Using methods instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
+     * Using methods `whereNot`, `or`, `whereIn` instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
      *
      * ```ts
      * db.table.where({
@@ -1746,6 +1856,8 @@ declare abstract class Where extends QueryBase {
      * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
      *
      * ```ts
+     * import { sql } from 'orchid-orm';
+     *
      * db.table.where({
      *   numericColumn: {
      *     // lower than 5
@@ -1755,7 +1867,7 @@ declare abstract class Where extends QueryBase {
      *     lt: OtherTable.select('someNumber').take(),
      *
      *     // raw SQL expression produces WHERE "numericColumn" < "otherColumn" + 10
-     *     lt: db.table.sql`"otherColumn" + 10`,
+     *     lt: sql`"otherColumn" + 10`,
      *   },
      * });
      * ```
@@ -1766,15 +1878,15 @@ declare abstract class Where extends QueryBase {
      *
      * ```ts
      * db.table.where({
-     *   // this will fail because an object with operators is expected
+     *  // when searching for an exact same JSON value, this won't work:
      *   jsonColumn: someObject,
      *
-     *   // use this instead:
+     *   // use `{ equals: ... }` instead:
      *   jsonColumn: { equals: someObject },
      * });
      * ```
      *
-     * `not` is `!=` (or `<>`) not equal operator:
+     * `not` is `!=` (aka `<>`) not equal operator:
      *
      * ```ts
      * db.table.where({
@@ -1923,8 +2035,8 @@ declare abstract class Where extends QueryBase {
      *
      * @param args - {@link WhereArgs}
      */
-    where<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _where<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    where<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _where<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
      * `whereNot` takes the same arguments as `where` and prepends them with `NOT` in SQL
      *
@@ -1935,8 +2047,8 @@ declare abstract class Where extends QueryBase {
      *
      * @param args - {@link WhereArgs}
      */
-    whereNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _whereNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    whereNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _whereNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
      * `and` is an alias for {@link where} to make it look closer to SQL:
      *
@@ -1946,15 +2058,15 @@ declare abstract class Where extends QueryBase {
      *
      * @param args - {@link WhereArgs}
      */
-    and<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _and<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    and<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _and<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
      * `andNot` is an alias for `whereNot`.
      *
      * @param args - {@link WhereArgs}
      */
-    andNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _andNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    andNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _andNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
      * `or` is accepting the same arguments as {@link where}, joining arguments with `OR`.
      *
@@ -1976,15 +2088,15 @@ declare abstract class Where extends QueryBase {
      *
      * @param args - {@link WhereArgs} will be joined with `OR`
      */
-    or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    or<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _or<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
     /**
      * `orNot` takes the same arguments as {@link or}, and prepends each condition with `NOT` just as {@link whereNot} does.
      *
      * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
      */
-    orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    orNot<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _orNot<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
     /**
      * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
      *
@@ -2023,15 +2135,15 @@ declare abstract class Where extends QueryBase {
      * @param column - one column name, or array of column names
      * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    whereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
      * See {@link whereIn}.
      *
      * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    whereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _whereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
      * Takes the same arguments as {@link whereIn}.
      * Add a `WHERE IN` condition prefixed with `OR` to the query:
@@ -2043,15 +2155,15 @@ declare abstract class Where extends QueryBase {
      * @param column - one column name, or array of column names
      * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    orWhereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
      * See {@link orWhereIn}.
      *
      * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    orWhereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
      * Acts as `whereIn`, but negates the condition with `NOT`:
      *
@@ -2062,15 +2174,15 @@ declare abstract class Where extends QueryBase {
      * @param column - one column name, or array of column names
      * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    whereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
      * See {@link whereNotIn}.
      *
      * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    whereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _whereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
      * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
      *
@@ -2081,15 +2193,15 @@ declare abstract class Where extends QueryBase {
      * @param column - one column name, or array of column names
      * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    orWhereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
      * See {@link orWhereNotIn}.
      *
      * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    orWhereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
      * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
      *
@@ -2110,16 +2222,16 @@ declare abstract class Where extends QueryBase {
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
      */
-    whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
     /**
      * See {@link whereExists}.
      *
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param cb - callback with a query builder to join the table.
      */
-    whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
-    _whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    _whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     /**
      * Acts as `whereExists`, but prepends the condition with `OR`:
      *
@@ -2132,16 +2244,16 @@ declare abstract class Where extends QueryBase {
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
      */
-    orWhereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     /**
      * See {@link orWhereExists}.
      *
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param cb - callback with a query builder to join the table.
      */
-    orWhereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _orWhereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
-    _orWhereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     /**
      * Acts as `whereExists`, but negates the condition with `NOT`:
      *
@@ -2154,16 +2266,16 @@ declare abstract class Where extends QueryBase {
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
      */
-    whereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     /**
      * See {@link whereNotExists}.
      *
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param cb - callback with a query builder to join the table.
      */
-    whereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
-    _whereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     /**
      * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
      *
@@ -2176,26 +2288,20 @@ declare abstract class Where extends QueryBase {
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
      */
-    orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     /**
      * See {@link orWhereNotExists}.
      *
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param cb - callback with a query builder to join the table.
      */
-    orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
-    _orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
 }
-declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where implements QueryBase {
-    selectable: Q['selectable'];
-    relations: Q['relations'];
-    result: Q['result'];
-    shape: Q['shape'];
-    baseQuery: Query;
-    withData: {};
-    internal: Q['internal'];
-    constructor(q: QueryBase, { shape, joinedShapes }: Pick<QueryData, 'shape' | 'joinedShapes'>);
+interface WhereQueryBase extends Where, QueryBase {
+}
+declare abstract class WhereQueryBase extends QueryBase {
 }
 
 type CreateData<T extends Query, Data = SetOptional<{
@@ -2858,13 +2964,6 @@ declare class Having {
      * // HAVING (sum(column) = 5) OR (min(column) > 1 AND max(column) < 10)
      * ```
      *
-     * `or` method is also available on the `q` query builder:
-     *
-     * ```ts
-     * db.table.having((q) => q.or(q.min('column').gt(1), q.max('column').lt(10)));
-     * // HAVING (min(column) > 1) OR (max(column) < 10)
-     * ```
-     *
      * Aggregate functions are exactly the same functions described in [aggregate functions](#aggregate-functions), they can accept aggregation options:
      *
      * ```ts
@@ -2891,7 +2990,7 @@ declare class Having {
 }
 
 type AfterHook<Select extends PropertyKey[], Shape extends ColumnsShapeBase, Selected extends ColumnsShapeBase = Pick<Shape, StringKey<Select[number]>>, Item = {
-    [K in keyof Selected]: Selected[K]['type'];
+    [K in keyof Selected]: Selected[K]['outputType'];
 }> = QueryAfterHook<Item[]>;
 type HookSelect<T extends QueryBase> = (keyof T['shape'])[];
 type HookAction = 'Create' | 'Update' | 'Delete';
@@ -3261,7 +3360,7 @@ type SelectArg<T extends Query> = '*' | StringKey<keyof T['selectable']> | Selec
 type SelectAsArg<T extends Query> = Record<string, SelectAsValue<T>>;
 type SelectAsValue<T extends Query, SB = SelectQueryBuilder<T>> = StringKey<keyof T['selectable']> | Expression | ((q: SB) => QueryBase) | ((q: SB) => Expression) | ((q: SB) => QueryBase | Expression);
 type SelectQueryBuilder<T extends Query, Agg = SelectAggMethods<T>> = {
-    [K in keyof Agg | 'columnTypes' | 'sql' | keyof T['relations']]: K extends keyof Agg ? Agg[K] : K extends 'columnTypes' | 'sql' ? T[K] : K extends keyof T ? T[K] : never;
+    [K in keyof Agg | 'columnTypes' | 'sql' | 'baseQuery' | keyof T['relations']]: K extends keyof Agg ? Agg[K] : K extends keyof T ? T[K] : never;
 };
 type SelectObjectResultTuple = [ColumnsShapeBase, SelectableBase];
 type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectStringsResult extends ColumnsShapeBase = SelectStringArgsResult<T, Args>, StringsKeys extends keyof SelectStringsResult = keyof SelectStringsResult, SelectAsResult extends SelectObjectResultTuple = SpreadSelectObjectArgs<T, Args, [
@@ -3301,7 +3400,6 @@ type SelectSubQueryResult<Arg extends QueryBase & {
 }> = QueryReturnsAll<Arg['returnType']> extends true ? ArrayOfColumnsObjects<Arg['result']> : Arg['returnType'] extends 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? PluckResultColumnType<Arg['result']['pluck']> : Arg[isRequiredRelationKey] extends true ? ColumnsObject<Arg['result']> : NullableColumn<ColumnsObject<Arg['result']>>;
 declare const addParserForRawExpression: (q: Query, key: string | getValueKey, raw: Expression) => void;
 declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, arg: Query | SelectableOrExpression<T>) => string | Expression | Query;
-declare const getSelectQueryBuilder: <T extends Query>(q: T) => SelectAggMethods<T>;
 declare const processSelectArg: <T extends Query>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem;
 declare const getShapeFromSelect: (q: QueryBase, isSubQuery?: boolean) => ColumnsShapeBase;
 declare class Select {
@@ -4263,57 +4361,57 @@ declare class RawSQL<T extends ColumnTypeBase, CT extends ColumnTypesBase = Defa
         values: unknown[];
     }): string;
 }
-declare const raw: <T = unknown>(...args: RawSQLArgs) => RawSQL<ColumnTypeBase<T, orchid_core.BaseOperators, T, orchid_core.ColumnDataBase>, {
-    timestamps<T_1 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+declare const raw: <T = unknown>(...args: RawSQLArgs) => RawSQL<ColumnTypeBase<T, orchid_core.BaseOperators, T, T, T, orchid_core.ColumnDataBase>, {
+    timestamps<T_1 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestamp(): T_1;
         };
         timestamp(): T_1;
         timestampsSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
-    timestampsSnakeCase<T_2 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestampsSnakeCase<T_2 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestamp(): T_2;
         };
         timestamp(): T_2;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
-    timestampsNoTZ<T_3 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestampsNoTZ<T_3 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestampNoTZ(): T_3;
         };
         timestampNoTZ(): T_3;
         timestampsNoTZSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
-    timestampsNoTZSnakeCase<T_4 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestampsNoTZSnakeCase<T_4 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestampNoTZ(): T_4;
         };
         timestampNoTZ(): T_4;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_4, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_4, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_4, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_4, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
     name: typeof orchid_core.name;
     sql: {
-        (sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>;
-        (sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>;
-        (values: Record<string, unknown>, sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>;
-        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>;
+        (sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+        (sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+        (values: Record<string, unknown>, sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
     };
     smallint(): SmallIntColumn;
     integer(): IntegerColumn;
@@ -4376,7 +4474,7 @@ declare const raw: <T = unknown>(...args: RawSQLArgs) => RawSQL<ColumnTypeBase<T
         union: <T_12 extends orchid_core.JSONUnionArgs>(...types: T_12) => orchid_core.JSONUnion<T_12>;
     }) => Type) | undefined): JSONColumn<Type>;
     jsonText(): JSONTextColumn;
-    array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
+    array<Item extends ColumnType<unknown, BaseOperators, unknown, unknown, unknown>>(item: Item): ArrayColumn<Item>;
     type(dataType: string): CustomTypeColumn;
     domain(dataType: string): DomainColumn;
     primaryKey(columns: string[], options?: {
@@ -4388,14 +4486,14 @@ declare const raw: <T = unknown>(...args: RawSQLArgs) => RawSQL<ColumnTypeBase<T
     constraint<Table extends string | (() => orchid_core.ForeignKeyTable), Columns extends Table extends () => orchid_core.ForeignKeyTable ? [orchid_core.ColumnNameOfTable<ReturnType<Table>>, ...orchid_core.ColumnNameOfTable<ReturnType<Table>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
         name?: string | undefined;
         references?: [columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: ForeignKeyOptions | undefined] | undefined;
-        check?: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}> | undefined;
+        check?: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}> | undefined;
         dropMode?: DropMode | undefined;
     }): {};
     foreignKey<Table_1 extends string | (() => orchid_core.ForeignKeyTable), Columns_1 extends Table_1 extends () => orchid_core.ForeignKeyTable ? [orchid_core.ColumnNameOfTable<ReturnType<Table_1>>, ...orchid_core.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_1, foreignColumns: Columns_1, options?: (ForeignKeyOptions & {
         name?: string | undefined;
         dropMode?: DropMode | undefined;
     }) | undefined): {};
-    check(check: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>): {};
+    check(check: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>): {};
 }>;
 
 declare class RawSqlMethods<CT extends ColumnTypesBase> {
@@ -4636,7 +4734,7 @@ type OrderArg<T extends Query, TsQuery extends PropertyKey = string | undefined
     [K in Key]?: K extends TsQuery ? OrderTsQueryConfig : SortDir;
 } | Expression;
 type OrderArgs<T extends Query> = OrderArg<T>[] | TemplateLiteralArgs;
-type FindArgs<T extends Query> = [T['shape'][T['singlePrimaryKey']]['type'] | Expression] | TemplateLiteralArgs;
+type FindArgs<T extends Query> = [T['shape'][T['singlePrimaryKey']]['queryType'] | Expression] | TemplateLiteralArgs;
 type QueryHelper<T extends Query, Args extends unknown[], Result> = <Q extends {
     [K in keyof T]: K extends 'then' ? QueryThen<unknown> : K extends 'result' ? ColumnsShapeBase : T[K];
 }>(q: Q, ...args: Args) => Result extends Query ? MergeQuery<Q, Result> : Result;
@@ -5046,9 +5144,12 @@ type WithDataItem = {
 };
 type WithDataBase = Record<never, WithDataItem>;
 type Query = QueryBase & QueryMethods<ColumnTypesBase> & {
+    internal: {
+        selectQueryBuilder?: SelectQueryBuilder<Query>;
+        getWhereQueryBuilder(q: QueryData): WhereQueryBuilder<WhereQueryBase>;
+    };
     queryBuilder: Db;
     columnTypes: ColumnTypesBase;
-    whereQueryBuilder: typeof WhereQueryBuilder;
     onQueryBuilder: typeof OnQueryBuilder;
     table?: string;
     shape: ColumnsShape;
@@ -5083,11 +5184,11 @@ declare const isQueryReturnsAll: (q: Query) => boolean;
 type QueryReturnsAll<T extends QueryReturnType> = (QueryReturnType extends T ? 'all' : T) extends 'all' ? true : false;
 type GetQueryResult<ReturnType extends QueryReturnType, Result extends ColumnsShapeBase> = QueryReturnsAll<ReturnType> extends true ? ColumnShapeOutput<Result>[] : ReturnType extends 'one' ? ColumnShapeOutput<Result> | undefined : ReturnType extends 'oneOrThrow' ? ColumnShapeOutput<Result> : ReturnType extends 'value' ? Result extends {
     value: ColumnType;
-} ? Result['value']['type'] | undefined : never : ReturnType extends 'valueOrThrow' ? Result extends {
+} ? Result['value']['outputType'] | undefined : never : ReturnType extends 'valueOrThrow' ? Result extends {
     value: ColumnType;
-} ? Result['value']['type'] : never : ReturnType extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : ReturnType extends 'pluck' ? Result extends {
+} ? Result['value']['outputType'] : never : ReturnType extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : ReturnType extends 'pluck' ? Result extends {
     pluck: ColumnType;
-} ? Result['pluck']['type'][] : never : ReturnType extends 'rowCount' ? number : ReturnType extends 'void' ? void : never;
+} ? Result['pluck']['outputType'][] : never : ReturnType extends 'rowCount' ? number : ReturnType extends 'void' ? void : never;
 type AddQuerySelect<T extends Pick<Query, 'result' | 'meta' | 'returnType'>, Result extends ColumnsShapeBase, Data = GetQueryResult<T['returnType'], Result>> = T['meta']['hasSelect'] extends true ? MergeSelect<T, Result, Data> : SetSelect<T, Result, Data>;
 type MergeSelect<T extends Pick<Query, 'result'>, Result extends ColumnsShapeBase, Data, Merged extends ColumnsShapeBase = {
     [K in keyof T['result']]: K extends keyof Result ? unknown : T['result'][K];
@@ -5114,13 +5215,13 @@ type SetQueryReturnsPluck<T extends Query, S extends keyof T['selectable'] | Exp
         pluck: C;
     };
     returnType: 'pluck';
-    then: QueryThen<C['type'][]>;
-    catch: QueryCatch<C['type'][]>;
+    then: QueryThen<C['outputType'][]>;
+    catch: QueryCatch<C['outputType'][]>;
 };
 type SetQueryReturnsValueOptional<T extends Query, Arg extends GetStringArg<T>> = SetQueryReturnsValue<T, Arg, 'value'>;
 type SetQueryReturnsValue<T extends Query, Arg extends GetStringArg<T>, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow'> = SetQueryReturnsColumn<T, Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never, ReturnType>;
 type SetQueryReturnsColumnOptional<T extends QueryBase, Column extends ColumnTypeBase> = SetQueryReturnsColumn<T, Column, 'value'>;
-type SetQueryReturnsColumn<T extends QueryBase, Column extends ColumnTypeBase, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow', Data = ReturnType extends 'value' ? Column['type'] | undefined : Column['type']> = {
+type SetQueryReturnsColumn<T extends QueryBase, Column extends ColumnTypeBase, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow', Data = ReturnType extends 'value' ? Column['outputType'] | undefined : Column['outputType']> = {
     [K in keyof T]: K extends 'meta' ? T['meta'] & {
         hasSelect: true;
     } : K extends 'result' ? {
@@ -5161,61 +5262,61 @@ declare const Operators: {
     any: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     boolean: {
-        and: Operator<Expression<ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, orchid_core.ColumnDataBase>>>;
-        or: Operator<Expression<ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, orchid_core.ColumnDataBase>>>;
-        equals: Operator<boolean | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<boolean | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
+        and: Operator<Expression<ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, boolean | null, boolean | null, orchid_core.ColumnDataBase>>>;
+        or: Operator<Expression<ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, boolean | null, boolean | null, orchid_core.ColumnDataBase>>>;
+        equals: Operator<boolean | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<boolean | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
     };
     number: {
-        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query]>;
-        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query]>;
+        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
     };
     date: {
-        lt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        lte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        between: Operator<[Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
-        equals: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        not: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        lt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        lte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        between: Operator<[Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
+        equals: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        not: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
     };
     time: {
-        lt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        lte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        between: Operator<[Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
-        equals: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        not: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        lt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        lte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gt: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gte: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        between: Operator<[Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
+        equals: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        not: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
     };
     text: {
-        contains: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     json: {
         jsonPath: Operator<[path: string, op: string, value: unknown]>;
@@ -5223,14 +5324,14 @@ declare const Operators: {
         jsonSubsetOf: Operator<unknown>;
         equals: Operator<unknown>;
         not: Operator<unknown>;
-        in: Operator<unknown[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<unknown[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<unknown[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<unknown[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     array: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
 };
 
@@ -5239,8 +5340,8 @@ declare class CustomTypeColumn extends ColumnType<unknown, typeof Operators.any>
     operators: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     constructor(dataType: string);
     toCode(t: string): Code;
@@ -5253,15 +5354,15 @@ type ArrayData<Item extends ColumnTypeBase> = ColumnData & ArrayMethodsData & {
     item: Item;
 };
 type ArrayMethods = typeof arrayTypeMethods;
-interface ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array>, ArrayMethods {
+interface ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array, Item['inputType'][], Item['outputType'][], Item['queryType'][]>, ArrayMethods {
 }
-declare class ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array> {
+declare class ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array, Item['inputType'][], Item['outputType'][], Item['queryType'][]> {
     dataType: "array";
     operators: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     data: ArrayData<Item>;
     constructor(item: Item);
@@ -5280,8 +5381,8 @@ declare class JSONColumn<Type extends JSONType = JSONUnknown> extends ColumnType
         jsonSubsetOf: Operator<unknown>;
         equals: Operator<unknown>;
         not: Operator<unknown>;
-        in: Operator<unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     data: ColumnData & {
         schema: Type;
@@ -5292,16 +5393,16 @@ declare class JSONColumn<Type extends JSONType = JSONUnknown> extends ColumnType
 declare class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "json";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
@@ -5312,8 +5413,8 @@ declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]>
     operators: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     dataType: string;
     constructor(enumName: string, options: T);
@@ -5325,12 +5426,12 @@ declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean
     static instance: BooleanColumn;
     dataType: "boolean";
     operators: {
-        and: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, orchid_core.ColumnDataBase>>>;
-        or: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, orchid_core.ColumnDataBase>>>;
-        equals: Operator<boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
-        notIn: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
+        and: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, boolean | null, boolean | null, orchid_core.ColumnDataBase>>>;
+        or: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<boolean | null, orchid_core.BaseOperators, boolean | null, boolean | null, boolean | null, orchid_core.ColumnDataBase>>>;
+        equals: Operator<boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
+        notIn: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | boolean[]>;
     };
     toCode(t: string): Code;
     parseItem: (input: string) => boolean;
@@ -5345,16 +5446,16 @@ interface TextBaseColumn extends ColumnType<string, typeof Operators.text>, Text
 declare abstract class TextBaseColumn extends ColumnType<string, typeof Operators.text> {
     data: TextColumnData;
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
 }
 declare abstract class LimitedTextBaseColumn<Limit extends number | undefined = undefined> extends TextBaseColumn {
@@ -5385,128 +5486,128 @@ declare class TextColumn extends TextBaseColumn {
 declare class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
     dataType: "bytea";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class PointColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "point";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class LineColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "line";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class LsegColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "lseg";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class BoxColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "box";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class PathColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "path";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class PolygonColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "polygon";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class CircleColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "circle";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
@@ -5520,80 +5621,80 @@ declare class MoneyColumn extends NumberBaseColumn {
 declare class CidrColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "cidr";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class InetColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "inet";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "macaddr";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
     dataType: "macaddr8";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class BitColumn<Length extends number> extends ColumnType<string, typeof Operators.text> {
     dataType: "bit";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     data: ColumnData & {
         length: Length;
@@ -5605,16 +5706,16 @@ declare class BitColumn<Length extends number> extends ColumnType<string, typeof
 declare class BitVaryingColumn<Length extends number | undefined = undefined> extends ColumnType<string, typeof Operators.text> {
     dataType: "bit varying";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     data: ColumnData & {
         length: Length;
@@ -5628,16 +5729,16 @@ declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
     defaultLanguage: string;
     dataType: "tsvector";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     constructor(defaultLanguage?: string);
     toCode(t: string): Code;
@@ -5670,32 +5771,32 @@ declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
 declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "tsquery";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
 declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "uuid";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     primaryKey<T extends ColumnType>(this: T): PrimaryKeyColumn<T>;
     toCode(t: string): Code;
@@ -5703,16 +5804,16 @@ declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
 declare class XMLColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "xml";
     operators: {
-        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        containsSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        startsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWith: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        endsWithSensitive: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        equals: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(t: string): Code;
 }
@@ -5729,31 +5830,43 @@ declare class CitextColumn extends TextBaseColumn {
 type ColumnsShape = Record<string, ColumnType>;
 declare abstract class ColumnsObject<Shape extends ColumnsShapeBase> extends ColumnType<{
     [K in keyof Shape]: Shape[K]['type'];
-}, typeof Operators.any> {
+}, typeof Operators.any, {
+    [K in keyof Shape]: Shape[K]['inputType'];
+}, {
+    [K in keyof Shape]: Shape[K]['outputType'];
+}, {
+    [K in keyof Shape]: Shape[K]['queryType'];
+}> {
     shape: Shape;
     dataType: "object";
     operators: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     constructor(shape: Shape);
 }
 declare abstract class ArrayOfColumnsObjects<Shape extends ColumnsShapeBase> extends ColumnType<{
     [K in keyof Shape]: Shape[K]['type'];
-}[], typeof Operators.any> {
+}[], typeof Operators.any, {
+    [K in keyof Shape]: Shape[K]['inputType'];
+}[], {
+    [K in keyof Shape]: Shape[K]['outputType'];
+}[], {
+    [K in keyof Shape]: Shape[K]['queryType'];
+}[]> {
     shape: Shape;
     dataType: "array";
     operators: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     constructor(shape: Shape);
 }
-declare abstract class PluckResultColumnType<C extends ColumnTypeBase> extends ColumnTypeBase<C['type'][], typeof Operators.any> {
+declare abstract class PluckResultColumnType<C extends ColumnTypeBase> extends ColumnTypeBase<C['type'][], typeof Operators.any, C['inputType'][], C['outputType'][], C['queryType'][]> {
 }
 
 type ColumnTypes = typeof columnTypes;
@@ -5813,49 +5926,49 @@ declare function sql(values: Record<string, unknown>, sql: string): RawSQLBase;
 declare function sql(values: Record<string, unknown>): (...sql: TemplateLiteralArgs) => RawSQLBase;
 type DefaultColumnTypes = typeof columnTypes;
 declare const columnTypes: {
-    timestamps<T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestamps<T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestamp(): T;
         };
         timestamp(): T;
         timestampsSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
-    timestampsSnakeCase<T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestampsSnakeCase<T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestamp(): T_1;
         };
         timestamp(): T_1;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
-    timestampsNoTZ<T_2 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestampsNoTZ<T_2 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestampNoTZ(): T_2;
         };
         timestampNoTZ(): T_2;
         timestampsNoTZSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
-    timestampsNoTZSnakeCase<T_3 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+    timestampsNoTZSnakeCase<T_3 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
             timestampNoTZ(): T_3;
         };
         timestampNoTZ(): T_3;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
     };
     name: typeof name;
     sql: typeof sql;
@@ -5903,7 +6016,7 @@ declare const columnTypes: {
     xml(): XMLColumn;
     json<Type extends JSONType<unknown, {}> = JSONUnknown>(schemaOrFn?: Type | ((j: JSONTypes) => Type) | undefined): JSONColumn<Type>;
     jsonText(): JSONTextColumn;
-    array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
+    array<Item extends ColumnType<unknown, BaseOperators, unknown, unknown, unknown>>(item: Item): ArrayColumn<Item>;
     type(dataType: string): CustomTypeColumn;
     domain(dataType: string): DomainColumn;
     primaryKey(columns: string[], options?: {
@@ -5918,7 +6031,7 @@ declare const columnTypes: {
     constraint<Table extends string | (() => ForeignKeyTable), Columns extends Table extends () => ForeignKeyTable ? [ColumnNameOfTable<ReturnType<Table>>, ...ColumnNameOfTable<ReturnType<Table>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
         name?: string | undefined;
         references?: [columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: ForeignKeyOptions | undefined] | undefined;
-        check?: RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}> | undefined;
+        check?: RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}> | undefined;
         dropMode?: DropMode | undefined;
     }): EmptyObject;
     foreignKey<Table_1 extends string | (() => ForeignKeyTable), Columns_1 extends Table_1 extends () => ForeignKeyTable ? [ColumnNameOfTable<ReturnType<Table_1>>, ...ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_1, foreignColumns: Columns_1, options?: ForeignKeyOptions & {
@@ -5940,15 +6053,15 @@ interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>,
 declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
     data: NumberColumnData;
     operators: {
-        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query]>;
-        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query]>;
+        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
     };
 }
 declare abstract class IntegerBaseColumn extends NumberBaseColumn {
@@ -5957,15 +6070,15 @@ declare abstract class IntegerBaseColumn extends NumberBaseColumn {
 }
 declare abstract class NumberAsStringBaseColumn extends ColumnType<string, typeof Operators.number> {
     operators: {
-        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query]>;
-        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query]>;
+        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
     };
     data: ColumnData;
 }
@@ -5975,15 +6088,15 @@ declare class DecimalBaseColumn<Precision extends number | undefined = undefined
         numericScale: Scale;
     };
     operators: {
-        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query]>;
-        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
-        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        lt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        lte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gt: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        gte: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        between: Operator<[number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query]>;
+        equals: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        not: Operator<number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
+        notIn: Operator<Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | number[]>;
     };
     dataType: "decimal";
     constructor(numericPrecision?: Precision, numericScale?: Scale);
@@ -6042,20 +6155,20 @@ declare class BigSerialColumn extends NumberAsStringBaseColumn {
     toCode(t: string): Code;
 }
 
-interface DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date>, DateTypeMethods {
+interface DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date, string, string | number | Date>, DateTypeMethods {
 }
-declare abstract class DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date> {
+declare abstract class DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date, string, string | number | Date> {
     data: DateColumnData;
     operators: {
-        lt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        lte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        between: Operator<[orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
-        equals: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        not: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        in: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
-        notIn: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        lt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        lte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        between: Operator<[orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query, orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
+        equals: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        not: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        in: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        notIn: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
     };
     encodeFn: (input: string | number | Date) => Date;
     asNumber(): EncodeColumn<IntegerColumn, string | number | Date>;
@@ -6104,15 +6217,15 @@ declare class IntervalColumn<Fields extends string | undefined = undefined, Prec
         precision: Precision;
     };
     operators: {
-        lt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        lte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        gte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        between: Operator<[orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
-        equals: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        not: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
-        in: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
-        notIn: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        lt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        lte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gt: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        gte: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        between: Operator<[orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query, orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query]>;
+        equals: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        not: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Date | Query>;
+        in: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
+        notIn: Operator<orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query | Date[]>;
     };
     constructor(fields?: Fields, precision?: Precision);
     toCode(t: string): Code;
@@ -6190,57 +6303,57 @@ type ColumnFromDbParams = {
     numericScale?: number;
     dateTimePrecision?: number;
 };
-declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {
-    timestamps<T extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
+declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {
+    timestamps<T extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>>(this: {
         name(name: string): {
             timestamp(): T;
         };
         timestamp(): T;
         timestampsSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
     };
-    timestampsSnakeCase<T_1 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
+    timestampsSnakeCase<T_1 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>>(this: {
         name(name: string): {
             timestamp(): T_1;
         };
         timestamp(): T_1;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
     };
-    timestampsNoTZ<T_2 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
+    timestampsNoTZ<T_2 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>>(this: {
         name(name: string): {
             timestampNoTZ(): T_2;
         };
         timestampNoTZ(): T_2;
         timestampsNoTZSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
     };
-    timestampsNoTZSnakeCase<T_3 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
+    timestampsNoTZSnakeCase<T_3 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>>(this: {
         name(name: string): {
             timestampNoTZ(): T_3;
         };
         timestampNoTZ(): T_3;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>>;
     };
     name: typeof orchid_core.name;
     sql: {
-        (sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
-        (sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
-        (values: Record<string, unknown>, sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
-        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
+        (sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>;
+        (sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>;
+        (values: Record<string, unknown>, sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>;
+        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>;
     };
     smallint(): SmallIntColumn;
     integer(): IntegerColumn;
@@ -6303,7 +6416,7 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
         union: <T_11 extends orchid_core.JSONUnionArgs>(...types: T_11) => orchid_core.JSONUnion<T_11>;
     }) => Type) | undefined): JSONColumn<Type>;
     jsonText(): JSONTextColumn;
-    array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
+    array<Item extends ColumnType<unknown, BaseOperators, unknown, unknown, unknown>>(item: Item): ArrayColumn<Item>;
     type(dataType: string): CustomTypeColumn;
     domain(dataType: string): DomainColumn;
     primaryKey(columns: string[], options?: {
@@ -6315,17 +6428,17 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
     constraint<Table extends string | (() => ForeignKeyTable), Columns extends Table extends () => ForeignKeyTable ? [ColumnNameOfTable<ReturnType<Table>>, ...ColumnNameOfTable<ReturnType<Table>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
         name?: string | undefined;
         references?: [columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: ForeignKeyOptions | undefined] | undefined;
-        check?: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}> | undefined;
+        check?: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}> | undefined;
         dropMode?: DropMode | undefined;
     }): {};
     foreignKey<Table_1 extends string | (() => ForeignKeyTable), Columns_1 extends Table_1 extends () => ForeignKeyTable ? [ColumnNameOfTable<ReturnType<Table_1>>, ...ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_1, foreignColumns: Columns_1, options?: (ForeignKeyOptions & {
         name?: string | undefined;
         dropMode?: DropMode | undefined;
     }) | undefined): {};
-    check(check: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>): {};
+    check(check: RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, ColumnDataBase>, {}>): {};
 }> | undefined;
 declare const instantiateColumn: (klass: new (...args: never[]) => ColumnType, params: ColumnFromDbParams) => ColumnType;
-declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = BaseOperators, InputType = Type> extends ColumnTypeBase<Type, Ops, InputType, ColumnData> {
+declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = BaseOperators, InputType = Type, OutputType = Type, QueryType = Type> extends ColumnTypeBase<Type, Ops, InputType, OutputType, QueryType, ColumnData> {
     primaryKey<T extends ColumnType>(this: T): PrimaryKeyColumn<T>;
     foreignKey<T extends ColumnType, Table extends ForeignKeyTable, Column extends ColumnNameOfTable<Table>>(this: T, fn: () => Table, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
         foreignKeyData: ForeignKey<InstanceType<Table>['table'], [Column]>;
@@ -6385,18 +6498,18 @@ declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = Ba
     searchIndex<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'tsVector'>): T;
     unique<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column' | 'unique'>): T;
     comment<T extends ColumnType>(this: T, comment: string): T;
-    validationDefault<T extends ColumnType>(this: T, value: T['type']): T;
+    validationDefault<T extends ColumnType>(this: T, value: T['inputType']): T;
     compression<T extends ColumnType>(this: T, compression: string): T;
     collate<T extends ColumnType>(this: T, collate: string): T;
     modifyQuery<T extends ColumnType>(this: T, cb: (q: Query) => void): T;
-    transform<T extends ColumnType, Transformed>(this: T, fn: (input: T['type'], ctx: ValidationContext) => Transformed): Omit<T, 'type'> & {
-        type: Transformed;
+    transform<T extends ColumnType, Transformed>(this: T, fn: (input: T['inputType'], ctx: ValidationContext) => Transformed): Omit<T, 'inputType'> & {
+        inputType: Transformed;
     };
-    to<T extends ColumnType, ToType extends ColumnType>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
-    refine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown, params?: ErrorMessage): T & {
+    to<T extends ColumnType, ToType extends ColumnType>(this: T, fn: (input: T['inputType']) => ToType['inputType'] | undefined, type: ToType): ToType;
+    refine<T extends ColumnType, RefinedOutput extends T['inputType']>(this: T, check: (arg: T['inputType']) => unknown, params?: ErrorMessage): T & {
         type: RefinedOutput;
     };
-    superRefine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
+    superRefine<T extends ColumnType, RefinedOutput extends T['inputType']>(this: T, check: (arg: T['inputType'], ctx: ValidationContext) => unknown): T & {
         type: RefinedOutput;
     };
     /**
@@ -6422,8 +6535,8 @@ declare abstract class VirtualColumn extends ColumnType<unknown, typeof Operator
     operators: {
         equals: Operator<any>;
         not: Operator<any>;
-        in: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
-        notIn: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
+        in: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
+        notIn: Operator<any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
     toCode(): never;
     create?(q: Query, ctx: CreateCtx, item: Record<string, unknown>, rowIndex: number): void;
@@ -6503,4 +6616,4 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseOperators, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanNullable, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArg, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, SearchArg, SearchMethods, SearchWeight, Select, SelectAggMethods, SelectArg, SelectItem, SelectQueryBuilder, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, createOperator, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getSelectQueryBuilder, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnFn, makeColumnFnClass, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, saveSearchAlias, setQueryObjectValue, simplifyColumnDefault, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSql, toSqlCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseOperators, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanNullable, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArg, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationSubQueries, RelationsBase, SearchArg, SearchMethods, SearchWeight, Select, SelectAggMethods, SelectArg, SelectItem, SelectQueryBuilder, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, SubQueryBuilder, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBase, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, createOperator, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getSubQueryBuilder, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnFn, makeColumnFnClass, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, saveSearchAlias, setQueryObjectValue, simplifyColumnDefault, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSql, toSqlCacheKey };