pqb 0.13.3 → 0.14.1

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, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, RawExpression, ColumnTypeBase, MaybeArray, ColumnsParsers, getValueKey, StringKey, ColumnOutput, NullableColumn, TemplateLiteralArgs, EmptyTuple, SetOptional, MergeObjects, CoalesceString, QueryCommon, Spread, BaseNumberData, Code, ColumnWithDefault, numberTypeMethods, BaseStringData, PrimaryKeyColumn, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, JSONTypeAny, record, ArrayMethodsData, arrayMethods, ForeignKeyTable, name, ColumnNameOfTable, ColumnDataBase, BaseOperators, ValidationContext, MessageParam } from 'orchid-core';
+import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, Expression, ColumnTypeBase, MaybeArray, ColumnsParsers, getValueKey, StringKey, ColumnOutput, NullableColumn, TemplateLiteralArgs, EmptyTuple, SetOptional, MergeObjects, RawSQLBase, RawSQLArgs, CoalesceString, QueryCommon, Spread, Code, ArrayMethodsData, arrayMethods, JSONTypeAny, record, BaseStringData, PrimaryKeyColumn, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, ColumnWithDefault, numberTypeMethods, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ColumnDataBase, BaseOperators, ValidationContext, MessageParam } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -125,7 +125,7 @@ type DbTableOptions = {
     snakeCase?: boolean;
 } & QueryLogOptions;
 declare const anyShape: Record<string, ColumnType<unknown, orchid_core.BaseOperators, 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 {
+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;
     queryBuilder: Db;
     whereQueryBuilder: Query['whereQueryBuilder'];
@@ -293,7 +293,7 @@ declare const checkIfASimpleQuery: (q: Query) => boolean;
 type WithItem = [
     as: string,
     options: WithOptions,
-    query: Query | RawExpression
+    query: Query | Expression
 ];
 type WithOptions = {
     columns?: string[];
@@ -341,8 +341,8 @@ type JsonItem<As extends string = string, Type extends ColumnTypeBase = ColumnTy
     ];
 };
 type SelectItem = string | RelationQuery | AggregateItem | {
-    selectAs: Record<string, string | Query | RawExpression>;
-} | SelectFunctionItem | JsonItem | RawExpression;
+    selectAs: Record<string, string | Query | Expression>;
+} | SelectFunctionItem | JsonItem | Expression;
 type SelectFunctionItem = {
     function: string;
     arguments: SelectItem[];
@@ -353,31 +353,31 @@ type SimpleJoinItem = {
     type: string;
     args: [relation: string] | [
         arg: string | QueryWithTable,
-        conditions: Record<string, string | RawExpression> | RawExpression | ((q: unknown) => QueryBase) | true
+        conditions: Record<string, string | Expression> | Expression | ((q: unknown) => QueryBase) | true
     ] | [
         arg: string | QueryWithTable,
-        leftColumn: string | RawExpression,
-        rightColumn: string | RawExpression
+        leftColumn: string | Expression,
+        rightColumn: string | Expression
     ] | [
         arg: string | QueryWithTable,
-        leftColumn: string | RawExpression,
+        leftColumn: string | Expression,
         op: string,
-        rightColumn: string | RawExpression
+        rightColumn: string | Expression
     ];
     isSubQuery: boolean;
 };
 type JoinLateralItem = [type: string, joined: Query, as: string];
-type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | RawExpression> | RawExpression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
+type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | Expression> | Expression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
     NOT?: MaybeArray<WhereItem>;
     AND?: MaybeArray<WhereItem>;
     OR?: MaybeArray<WhereItem>[];
     IN?: MaybeArray<WhereInItem>;
     EXISTS?: MaybeArray<SimpleJoinItem['args']>;
     ON?: WhereOnItem | WhereJsonPathEqualsItem;
-}) | ((q: unknown) => QueryBase) | Query | RawExpression;
+}) | ((q: unknown) => QueryBase) | Query | Expression;
 type WhereInItem = {
     columns: string[];
-    values: unknown[][] | Query | RawExpression;
+    values: unknown[][] | Query | Expression;
 };
 type WhereJsonPathEqualsItem = [
     leftColumn: string,
@@ -407,8 +407,8 @@ type AggregateItemOptions = {
     window?: WindowItem;
 };
 type SortDir = 'ASC' | 'DESC' | 'ASC NULLS FIRST' | 'DESC NULLS LAST';
-type OrderItem = string | Record<string, SortDir> | RawExpression;
-type AggregateItemArg = Expression | Record<string, Expression> | [Expression, string];
+type OrderItem = string | Record<string, SortDir> | Expression;
+type AggregateItemArg = SelectableOrExpression | Record<string, SelectableOrExpression> | [SelectableOrExpression, string];
 type AggregateItem = {
     function: string;
     arg?: AggregateItemArg;
@@ -420,16 +420,16 @@ type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
 type HavingItemObject = Record<string, unknown>;
 type HavingItem = Record<string, HavingItemObject> | {
     count?: number | HavingItemObject;
-} | Query | RawExpression;
-type WindowItem = Record<string, WindowDeclaration | RawExpression>;
+} | Query | Expression;
+type WindowItem = Record<string, WindowDeclaration | Expression>;
 type WindowDeclaration = {
-    partitionBy?: Expression | Expression[];
+    partitionBy?: SelectableOrExpression | SelectableOrExpression[];
     order?: OrderItem;
 };
-type UnionItem = Query | RawExpression;
+type UnionItem = Query | Expression;
 type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
-type OnConflictItem = string | string[] | RawExpression;
-type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
+type OnConflictItem = string | string[] | Expression;
+type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | Expression;
 
 type JoinedShapes = Record<string, ColumnsShapeBase>;
 type JoinedParsers = Record<string, ColumnsParsers>;
@@ -457,10 +457,10 @@ type CommonQueryData = {
     schema?: string;
     select?: SelectItem[];
     as?: string;
-    from?: string | Query | RawExpression;
+    from?: string | Query | Expression;
     and?: WhereItem[];
     or?: WhereItem[][];
-    coalesceValue?: unknown | RawExpression;
+    coalesceValue?: unknown | Expression;
     parsers?: ColumnsParsers;
     notFoundDefault?: unknown;
     defaults?: Record<string, unknown>;
@@ -486,10 +486,10 @@ type CommonQueryData = {
 };
 type SelectQueryData = CommonQueryData & {
     type: undefined;
-    distinct?: Expression[];
+    distinct?: SelectableOrExpression[];
     fromOnly?: boolean;
     join?: JoinItem[];
-    group?: (string | RawExpression)[];
+    group?: (string | Expression)[];
     having?: HavingItem[];
     havingOr?: HavingItem[][];
     window?: WindowItem[];
@@ -504,7 +504,7 @@ type SelectQueryData = CommonQueryData & {
     offset?: number;
     for?: {
         type: 'UPDATE' | 'NO KEY UPDATE' | 'SHARE' | 'KEY SHARE';
-        tableNames?: string[] | RawExpression;
+        tableNames?: string[] | Expression;
         mode?: 'NO WAIT' | 'SKIP LOCKED';
     };
     [getValueKey]?: ColumnTypeBase;
@@ -512,7 +512,7 @@ type SelectQueryData = CommonQueryData & {
 type InsertQueryData = CommonQueryData & {
     type: 'insert';
     columns: string[];
-    values: unknown[][] | MaybeArray<RawExpression> | {
+    values: unknown[][] | MaybeArray<Expression> | {
         from: Query;
         values?: unknown[][];
     };
@@ -527,12 +527,12 @@ type InsertQueryData = CommonQueryData & {
         update?: OnConflictMergeUpdate;
     };
 };
-type UpdateQueryDataObject = Record<string, RawExpression | {
+type UpdateQueryDataObject = Record<string, Expression | {
     op: string;
     arg: unknown;
 } | unknown>;
 type UpdatedAtDataInjector = (data: UpdateQueryDataItem[]) => UpdateQueryDataItem | void;
-type UpdateQueryDataItem = UpdateQueryDataObject | RawExpression | UpdatedAtDataInjector;
+type UpdateQueryDataItem = UpdateQueryDataObject | Expression | UpdatedAtDataInjector;
 type UpdateQueryData = CommonQueryData & {
     type: 'update';
     updateData: UpdateQueryDataItem[];
@@ -580,14 +580,14 @@ type QueryData = SelectQueryData | InsertQueryData | UpdateQueryData | DeleteQue
 declare const cloneQueryArrays: (q: QueryData) => void;
 
 type AliasOrTable<T extends Pick<Query, 'table' | 'meta'>> = T['meta']['as'] extends string ? T['meta']['as'] : T['table'] extends string ? T['table'] : never;
-type Expression<T extends Query = Query, C extends ColumnTypeBase = ColumnTypeBase> = StringKey<keyof T['selectable']> | RawExpression<C>;
+type SelectableOrExpression<T extends Query = Query, C extends ColumnTypeBase = ColumnTypeBase> = '*' | StringKey<keyof T['selectable']> | Expression<C>;
 type ExpressionOfType<T extends Query, C extends ColumnTypeBase, Type> = {
     [K in keyof T['selectable']]: ColumnOutput<T['selectable'][K]['column']> extends Type | null ? K : never;
-}[Selectable<T>] | RawExpression<C>;
+}[Selectable<T>] | Expression<C>;
 type NumberExpression<T extends Query, C extends ColumnTypeBase = ColumnTypeBase> = ExpressionOfType<T, C, number>;
 type StringExpression<T extends Query, C extends ColumnTypeBase = ColumnTypeBase> = ExpressionOfType<T, C, string>;
 type BooleanExpression<T extends Query, C extends ColumnTypeBase = ColumnTypeBase> = ExpressionOfType<T, C, boolean>;
-type ExpressionOutput<T extends Query, Expr extends Expression<T>> = Expr extends keyof T['selectable'] ? T['selectable'][Expr]['column'] : Expr extends RawExpression<infer ColumnTypeBase> ? ColumnTypeBase : never;
+type ExpressionOutput<T extends Query, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['selectable'] ? T['selectable'][Expr]['column'] : Expr extends Expression<infer ColumnTypeBase> ? ColumnTypeBase : never;
 declare const getClonedQueryData: (query: QueryData) => QueryData;
 declare const getQueryAs: (q: {
     table?: string;
@@ -620,16 +620,16 @@ type Resolve = (result: any) => any;
 type Reject = (error: any) => any;
 declare class Then {
     get then(): typeof maybeWrappedThen;
-    catch(this: Query, fn: (reason: any) => unknown): Promise<any>;
+    catch(this: Query, fn: (reason: any) => unknown): Promise<unknown>;
 }
 declare const handleResult: CommonQueryData['handleResult'];
-declare function maybeWrappedThen(this: Query, resolve?: Resolve, reject?: Reject): Promise<any>;
+declare function maybeWrappedThen(this: Query, resolve?: Resolve, reject?: Reject): Promise<unknown>;
 declare const parseResult: (q: Query, parsers: ColumnsParsers | undefined, returnType: QueryReturnType | undefined, result: QueryResult, isSubQuery?: boolean) => unknown;
 declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
 
 type SelectArg<T extends QueryBase> = '*' | StringKey<keyof T['selectable']> | SelectAsArg<T>;
 type SelectAsArg<T extends QueryBase> = Record<string, SelectAsValue<T>>;
-type SelectAsValue<T extends QueryBase> = StringKey<keyof T['selectable']> | RawExpression | ((q: T) => QueryBase) | ((q: T) => RawExpression) | ((q: T) => QueryBase | RawExpression);
+type SelectAsValue<T extends QueryBase> = StringKey<keyof T['selectable']> | Expression | ((q: T) => QueryBase) | ((q: T) => Expression) | ((q: T) => QueryBase | Expression);
 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, [
     EmptyObject,
@@ -662,12 +662,12 @@ type SelectAsResult<T extends Query, Arg, Result extends SelectObjectResultTuple
     },
     Result[1] & AddSelectable
 ] : Result;
-type SelectAsValueResult<T extends Query, Arg extends SelectAsValue<T>> = Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RawExpression ? Arg['__column'] : Arg extends (q: T) => infer R ? R extends QueryBase ? SelectSubQueryResult<R> : R extends RawExpression ? R['__column'] : R extends QueryBase | RawExpression ? SelectSubQueryResult<Exclude<R, RawExpression>> | Exclude<R, QueryBase>['__column'] : never : never;
+type SelectAsValueResult<T extends Query, Arg extends SelectAsValue<T>> = Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends Expression ? Arg['_type'] : Arg extends (q: T) => infer R ? R extends QueryBase ? SelectSubQueryResult<R> : R extends Expression ? R['_type'] : R extends QueryBase | Expression ? SelectSubQueryResult<Exclude<R, Expression>> | Exclude<R, QueryBase>['_type'] : never : never;
 type SelectSubQueryResult<Arg extends QueryBase & {
     [isRequiredRelationKey]?: boolean;
 }> = 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: RawExpression) => void;
-declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, arg: RawExpression | Query | StringKey<keyof T["selectable"]>) => string | RawExpression | Query;
+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 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 {
@@ -750,7 +750,7 @@ declare class Select {
 }
 
 type FromArgs<T extends Query> = [
-    first: Query | RawExpression | Exclude<keyof T['withData'], symbol | number>,
+    first: Query | Expression | Exclude<keyof T['withData'], symbol | number>,
     second?: {
         only?: boolean;
     }
@@ -805,37 +805,37 @@ declare class From {
 }
 
 type WhereArg<T extends QueryBase> = (Omit<{
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | RawExpression;
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | Expression;
 }, 'NOT' | 'OR' | 'IN' | 'EXISTS'> & {
     NOT?: MaybeArray<WhereArg<T>>;
     OR?: MaybeArray<WhereArg<T>>[];
     IN?: MaybeArray<{
         columns: (keyof T['selectable'])[];
-        values: unknown[][] | Query | RawExpression;
+        values: unknown[][] | Query | Expression;
     }>;
-}) | QueryBase | RawExpression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
+}) | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
 type WhereArgs<T extends QueryBase> = 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 | RawExpression : ({
+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;
 } & {
     length: Column extends {
         length: number;
     } ? Column['length'] : never;
-})[] | Query | RawExpression;
+})[] | Query | Expression;
 type WhereResult<T extends QueryBase> = T & {
     meta: {
         hasWhere: true;
     };
 };
 type WhereInArg<T extends Pick<Query, 'selectable'>> = {
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | RawExpression;
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | Expression;
 };
 declare const addWhere: <T extends Where>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 declare const addWhereNot: <T extends QueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 declare const addOr: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
 declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | RawExpression | undefined, not?: boolean) => WhereResult<T>;
+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 {
     where<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     _where<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
@@ -898,24 +898,24 @@ type JoinFirstArg<T extends QueryBase> = Query | keyof T['relations'] | keyof T[
 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;
 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> | RawExpression> | RawExpression | true
+    conditions: Record<JoinSelectable<Q>, Selectable<T> | Expression> | Expression | true
 ] | [
-    leftColumn: JoinSelectable<Q> | RawExpression,
-    rightColumn: Selectable<T> | RawExpression
+    leftColumn: JoinSelectable<Q> | Expression,
+    rightColumn: Selectable<T> | Expression
 ] | [
-    leftColumn: JoinSelectable<Q> | RawExpression,
+    leftColumn: JoinSelectable<Q> | Expression,
     op: string,
-    rightColumn: Selectable<T> | RawExpression
+    rightColumn: Selectable<T> | Expression
 ];
 type JoinWithArgs<T extends QueryBase, W extends keyof T['withData']> = [
-    conditions: Record<WithSelectable<T, W>, Selectable<T> | RawExpression> | RawExpression
+    conditions: Record<WithSelectable<T, W>, Selectable<T> | Expression> | Expression
 ] | [
-    leftColumn: WithSelectable<T, W> | RawExpression,
-    rightColumn: Selectable<T> | RawExpression
+    leftColumn: WithSelectable<T, W> | Expression,
+    rightColumn: Selectable<T> | Expression
 ] | [
-    leftColumn: WithSelectable<T, W> | RawExpression,
+    leftColumn: WithSelectable<T, W> | Expression,
     op: string,
-    rightColumn: Selectable<T> | RawExpression
+    rightColumn: Selectable<T> | Expression
 ];
 type JoinResult<T extends Query, Arg extends JoinFirstArg<T>, RequireJoined extends boolean, RequireMain extends boolean, Cb extends (q: never) => {
     meta: QueryMetaBase;
@@ -1039,7 +1039,7 @@ declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBas
 type WithArgsOptions = {
     [K in keyof WithOptions]: K extends 'columns' ? boolean | string[] : WithOptions[K];
 };
-type WithArgs = [string, ColumnsShapeBase, RawExpression] | [string, WithArgsOptions, ColumnsShapeBase, RawExpression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
+type WithArgs = [string, ColumnsShapeBase, Expression] | [string, WithArgsOptions, ColumnsShapeBase, Expression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
 type WithShape<Args extends WithArgs> = Args[1] extends Query ? Args[1]['result'] : Args[1] extends (qb: Db) => Query ? ReturnType<Args[1]>['result'] : Args[2] extends Query ? Args[2]['result'] : Args[2] extends (qb: Db) => Query ? ReturnType<Args[2]>['result'] : Args[1] extends ColumnsShapeBase ? Args[1] : Args[2] extends ColumnsShapeBase ? Args[2] : Args[2] extends (t: ColumnTypes) => ColumnsShapeBase ? ReturnType<Args[2]> extends ColumnsShapeBase ? ReturnType<Args[2]> : never : never;
 type WithResult<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase> = AddQueryWith<T, {
     table: Args[0];
@@ -1121,7 +1121,7 @@ type UnionArg<T extends Query> = (Omit<Query, 'result'> & {
     result: {
         [K in keyof T['result']]: Pick<T['result'][K], 'dataType'>;
     };
-}) | RawExpression;
+}) | Expression;
 declare class Union {
     /**
      * Creates a union query, taking an array or a list of callbacks, builders, or raw statements to build the union statement, with optional boolean `wrap`.
@@ -1437,11 +1437,11 @@ type CreateManyResult<T extends Query> = T extends {
 } ? T : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T;
 type CreateRawData<T extends Query> = {
     columns: (keyof T['shape'])[];
-    values: RawExpression;
+    values: Expression;
 };
 type CreateManyRawData<T extends Query> = {
     columns: (keyof T['shape'])[];
-    values: RawExpression[];
+    values: Expression[];
 };
 type RawRequiredColumns<T extends Query> = {
     [K in keyof T['inputType'] as K extends keyof T['meta']['defaults'] ? never : null extends T['inputType'][K] ? never : undefined extends T['inputType'][K] ? never : K]: true;
@@ -1451,7 +1451,7 @@ type CreateRawArgs<T extends Query, Arg extends {
 }> = keyof RawRequiredColumns<T> extends Arg['columns'][number] ? [data: Arg] : [
     `Missing required columns: ${Exclude<StringKey<keyof RawRequiredColumns<T>>, Arg['columns'][number]>}`
 ];
-type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | RawExpression;
+type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | Expression;
 type CreateCtx = {
     columns: Map<string, number>;
     returnTypeAll?: true;
@@ -1813,7 +1813,7 @@ declare class OnConflictQueryBuilder<T extends Query, Arg extends OnConflictArg<
      *
      * @param update - column, or array of columns, or object for new column values, or raw SQL
      */
-    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | RawExpression): T;
+    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | Expression): T;
 }
 
 type UpdateData<T extends Query> = {
@@ -1823,7 +1823,7 @@ type UpdateData<T extends Query> = {
 } : EmptyObject) & {
     __raw?: never;
 };
-type UpdateColumn<T extends Query, Key extends keyof T['inputType']> = T['inputType'][Key] | RawExpression | {
+type UpdateColumn<T extends Query, Key extends keyof T['inputType']> = T['inputType'][Key] | Expression | {
     [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
 } | ((q: {
     [K in keyof JsonModifiers]: K extends 'selectable' ? T['selectable'] : T[K];
@@ -1884,7 +1884,7 @@ type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
     create?: CreateData<Rel['nestedCreateQuery']>[];
 };
 type UpdateArg<T extends Query> = T['meta']['hasWhere'] extends true ? UpdateData<T> : never;
-type UpdateRawArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [sql: RawExpression] | TemplateLiteralArgs : never;
+type UpdateRawArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [sql: Expression] | TemplateLiteralArgs : never;
 type UpdateResult<T extends Query> = T['meta']['hasSelect'] extends true ? T : SetQueryReturnsRowCount<T>;
 type ChangeCountArg<T extends Query> = keyof T['shape'] | Partial<Record<keyof T['shape'], number>>;
 type UpdateCtx = {
@@ -2146,14 +2146,14 @@ type ForQueryBuilder<Q extends Query> = Q & {
     _skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
 };
 declare class For {
-    forUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    forShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    forKeyShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forKeyShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    forUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    forShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    forKeyShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forKeyShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
 }
 
 type ColumnInfo = {
@@ -2194,13 +2194,13 @@ declare class Clear {
 }
 
 type HavingArgObject<T extends Query, Agg extends keyof Aggregate1ArgumentTypes<T>> = {
-    [Column in Exclude<Aggregate1ArgumentTypes<T>[Agg], RawExpression>]?: T['selectable'][Column]['column']['type'] | (ColumnOperators<T['selectable'], Column> & AggregateOptions<T>);
+    [Column in Exclude<Aggregate1ArgumentTypes<T>[Agg], Expression>]?: T['selectable'][Column]['column']['type'] | (ColumnOperators<T['selectable'], Column> & AggregateOptions<T>);
 };
 type HavingArg<T extends Query = Query> = ({
     [Agg in keyof Aggregate1ArgumentTypes<T>]?: HavingArgObject<T, Agg>;
 } & {
     count?: number | HavingArgObject<T, 'count'>;
-}) | Query | RawExpression;
+}) | Query | Expression;
 type HavingArgs<T extends Query> = [...args: HavingArg<T>[]] | TemplateLiteralArgs;
 declare class Having {
     having<T extends Query>(this: T, ...args: HavingArgs<T>): T;
@@ -2338,6 +2338,7 @@ type HookAction = 'Create' | 'Update' | 'Delete';
 declare abstract class QueryHooks extends QueryBase {
     /**
      * Run the function before any kind of query.
+     *
      * @param cb - function to call, first argument is a query object
      */
     beforeQuery<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
@@ -2346,12 +2347,14 @@ declare abstract class QueryHooks extends QueryBase {
      * Run the function after any kind of query.
      * Enforces wrapping the query into a transaction.
      * The function will run after the query is succeeded, but before the transaction commit.
+     *
      * @param cb - function to call, first argument is the query result of type `unknown`, second argument is a query object
      */
     afterQuery<T extends QueryHooks>(this: T, cb: QueryAfterHook): T;
     _afterQuery<T extends QueryBase>(this: T, cb: QueryAfterHook): T;
     /**
      * Run the function before a `create` kind of query.
+     *
      * @param cb - function to call, first argument is a query object
      */
     beforeCreate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
@@ -2361,6 +2364,8 @@ declare abstract class QueryHooks extends QueryBase {
      * Enforces wrapping the query into a transaction.
      * The function will run after the query is succeeded, but before the transaction commit.
      * Queries inside the function will run in the same transaction as the target query.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterCreate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
@@ -2368,12 +2373,15 @@ declare abstract class QueryHooks extends QueryBase {
     /**
      * Run the function after transaction for a `create` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterCreateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     _afterCreateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function before an `update` kind of query.
+     *
      * @param cb - function to call, first argument is a query object
      */
     beforeUpdate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
@@ -2384,6 +2392,8 @@ declare abstract class QueryHooks extends QueryBase {
      * The function will run after the query is succeeded, but before the transaction commit.
      * Queries inside the function will run in the same transaction as the target query.
      * If no records were updated, the hook *won't* run.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterUpdate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
@@ -2392,12 +2402,15 @@ declare abstract class QueryHooks extends QueryBase {
      * Run the function after transaction for an `update` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
      * If no records were updated, the hook *won't* run.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterUpdateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     _afterUpdateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function before a `create` or an `update` kind of query.
+     *
      * @param cb - function to call, first argument is a query object
      */
     beforeSave<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
@@ -2408,6 +2421,8 @@ declare abstract class QueryHooks extends QueryBase {
      * The function will run after the query is succeeded, but before the transaction commit.
      * Queries inside the function will run in the same transaction as the target query.
      * For the `update` query, if no records were updated, the hook *won't* run.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterSave<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
@@ -2416,12 +2431,15 @@ declare abstract class QueryHooks extends QueryBase {
      * Run the function after transaction for a `create` or an `update` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
      * For the `update` query, if no records were updated, the hook *won't* run.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterSaveCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     _afterSaveCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function before a `delete` kind of query.
+     *
      * @param cb - function to call, first argument is a query object
      */
     beforeDelete<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
@@ -2432,6 +2450,8 @@ declare abstract class QueryHooks extends QueryBase {
      * The function will run after the query is succeeded, but before the transaction commit.
      * Queries inside the function will run in the same transaction as the target query.
      * If no records were deleted, the hook *won't* run.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterDelete<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
@@ -2440,6 +2460,8 @@ declare abstract class QueryHooks extends QueryBase {
      * Run the function after transaction for a `delete` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
      * If no records were deleted, the hook *won't* run.
+     *
+     * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
     afterDeleteCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
@@ -2538,10 +2560,10 @@ declare class QueryUpsertOrCreate {
     _orCreate<T extends UpsertThis>(this: T, data: UpsertCreateArg<T>): UpsertResult<T>;
 }
 
-type GetArg<T extends QueryBase> = GetStringArg<T> | RawExpression;
+type GetArg<T extends QueryBase> = GetStringArg<T> | Expression;
 type GetStringArg<T extends QueryBase> = StringKey<keyof T['selectable']>;
-type GetResult<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValue<T, Arg> : Arg extends RawExpression ? SetQueryReturnsColumn<T, Arg['__column']> : never;
-type GetResultOptional<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValueOptional<T, Arg> : Arg extends RawExpression ? SetQueryReturnsColumnOptional<T, Arg['__column']> : never;
+type GetResult<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValue<T, Arg> : Arg extends Expression ? SetQueryReturnsColumn<T, Arg['_type']> : never;
+type GetResultOptional<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValueOptional<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOptional<T, Arg['_type']> : never;
 declare class QueryGet {
     /**
      * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
@@ -2584,42 +2606,201 @@ declare class MergeQueryMethods {
     _merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
 }
 
-type SqlArgs<T extends Query> = SqlColumnArgs<T> | SqlNoColumnArgs;
-type SqlColumnArgs<T extends Query> = [column: ColumnFn<T>, params?: {
-    raw?: string;
-    values?: Values;
-}];
-type SqlColumnArgsWithSQL<T extends Query> = [column: ColumnFn<T>, params: {
-    raw: string;
-}];
-type SqlNoColumnArgs = [params: {
-    raw: string;
-    values?: Values;
-}] | [params: {
-    values: Values;
-}] | TemplateLiteralArgs;
-type Values = Record<string, unknown>;
-type ColumnFn<T extends Query> = (types: T['columnTypes']) => ColumnType;
-type SqlFn<C extends ColumnType> = (...args: TemplateLiteralArgs) => RawExpression<C>;
-type SqlResult<T extends Query, Args extends SqlArgs<T>> = Args extends SqlColumnArgs<T> ? Args extends SqlColumnArgsWithSQL<T> ? RawExpression<ReturnType<Args[0]>> : SqlFn<ReturnType<Args[0]>> : Args extends [{
-    raw: string;
-}] | TemplateLiteralArgs ? RawExpression : SqlFn<ColumnType>;
-type RawArgs<CT extends ColumnTypesBase, C extends ColumnType> = [column: (types: CT) => C, sql: string, values?: Record<string, unknown>] | [sql: string, values?: Record<string, unknown>];
-declare class RawSqlMethods {
+declare class RawSQL<T extends ColumnTypeBase, CT extends ColumnTypesBase = DefaultColumnTypes> extends RawSQLBase<T> {
+    columnTypes: CT;
+    constructor(sql: string | TemplateLiteralArgs, values?: Record<string, unknown> | false, type?: T);
+    toSQL(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: {
+        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, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+    };
+    timestampsSnakeCase<T_2 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, 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>, {}>>;
+    };
+    timestampsNoTZ<T_3 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, 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, orchid_core.ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>, {}>>;
+    };
+    timestampsNoTZSnakeCase<T_4 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, 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>, {}>>;
+    };
+    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>, {}>;
+    };
+    smallint(): SmallIntColumn;
+    integer(): IntegerColumn;
+    bigint(): BigIntColumn;
+    numeric<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(precision?: Precision | undefined, scale?: Scale | undefined): DecimalColumn<Precision, Scale>;
+    decimal<Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined): DecimalColumn<Precision_1, Scale_1>;
+    real(): RealColumn;
+    doublePrecision(): DoublePrecisionColumn;
+    identity(options?: TableData.Identity | undefined): IdentityColumn<IntegerColumn>;
+    smallSerial(): SmallSerialColumn;
+    serial(): SerialColumn;
+    bigSerial(): BigSerialColumn;
+    money(): MoneyColumn;
+    varchar<Limit extends number | undefined = undefined>(limit?: Limit | undefined): VarCharColumn<Limit>;
+    char<Limit_1 extends number | undefined = undefined>(limit?: Limit_1 | undefined): CharColumn<Limit_1>;
+    text: (min: number, max: number) => TextColumn;
+    string: (min: number, max: number) => TextColumn;
+    citext(min: number, max: number): CitextColumn;
+    bytea(): ByteaColumn;
+    date(): DateColumn;
+    timestampNoTZ<Precision_2 extends number>(precision?: Precision_2 | undefined): TimestampColumn<Precision_2>;
+    timestamp<Precision_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined): TimestampTZColumn<number>;
+    time<Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined): TimeColumn<Precision_4>;
+    interval<Fields extends string | undefined = undefined, Precision_5 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_5 | undefined): IntervalColumn<Fields, Precision_5>;
+    boolean(): BooleanColumn;
+    enum<U extends string, T_5 extends [U, ...U[]]>(dataType: string, type: T_5): EnumColumn<U, T_5>;
+    point(): PointColumn;
+    line(): LineColumn;
+    lseg(): LsegColumn;
+    box(): BoxColumn;
+    path(): PathColumn;
+    polygon(): PolygonColumn;
+    circle(): CircleColumn;
+    cidr(): CidrColumn;
+    inet(): InetColumn;
+    macaddr(): MacAddrColumn;
+    macaddr8(): MacAddr8Column;
+    bit<Length extends number>(length: Length): BitColumn<Length>;
+    bitVarying<Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined): BitVaryingColumn<Length_1>;
+    tsvector(): TsVectorColumn;
+    tsquery(): TsQueryColumn;
+    uuid(): UUIDColumn;
+    xml(): XMLColumn;
+    json<Type extends orchid_core.JSONTypeAny>(schemaOrFn: Type | ((j: {
+        set: <Value extends orchid_core.JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
+        tuple: <T_6 extends [] | orchid_core.JSONTupleItems, Rest extends orchid_core.JSONTypeAny | null = null>(items: T_6, rest?: Rest) => orchid_core.JSONTuple<T_6, Rest>;
+        union: <T_7 extends [orchid_core.JSONTypeAny, orchid_core.JSONTypeAny, ...orchid_core.JSONTypeAny[]]>(types: T_7) => orchid_core.JSONUnion<T_7>;
+        any: () => orchid_core.JSONAny;
+        bigint: () => orchid_core.JSONBigInt;
+        boolean: () => orchid_core.JSONBoolean;
+        date: () => orchid_core.JSONDate;
+        nan: () => orchid_core.JSONNaN;
+        never: () => orchid_core.JSONNever;
+        null: () => orchid_core.JSONNull;
+        number: () => orchid_core.JSONNumber;
+        string: () => orchid_core.JSONString;
+        unknown: () => orchid_core.JSONUnknown;
+        array: <Type_1 extends orchid_core.JSONTypeAny>(element: Type_1) => orchid_core.JSONArray<Type_1, "many">;
+        discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
+        enum: <U_1 extends string, T_8 extends [U_1, ...U_1[]]>(options: T_8) => orchid_core.JSONEnum<U_1, T_8>;
+        instanceOf: <T_9 extends new (...args: any[]) => any>(cls: T_9) => orchid_core.JSONInstanceOf<T_9>;
+        intersection: <Left extends orchid_core.JSONTypeAny, Right extends orchid_core.JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_10 extends orchid_core.JSONTypeAny>(fn: () => T_10) => orchid_core.JSONLazy<T_10>;
+        literal: <T_11 extends orchid_core.Primitive>(value: T_11) => orchid_core.JSONLiteral<T_11>;
+        map: <Key extends orchid_core.JSONTypeAny, Value_1 extends orchid_core.JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
+        nativeEnum: <T_12 extends orchid_core.EnumLike>(givenEnum: T_12) => orchid_core.JSONNativeEnum<T_12>;
+        nullable: <T_13 extends orchid_core.JSONTypeAny>(type: T_13) => orchid_core.JSONNullable<T_13>;
+        nullish: <T_14 extends orchid_core.JSONTypeAny>(type: T_14) => orchid_core.JSONNullish<T_14>;
+        object: <T_15 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_15) => orchid_core.JSONObject<T_15, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_15]: T_15[k_1]["type"]; }> extends infer T_16 extends object ? { [k in keyof T_16]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_15]: T_15[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_15]: T_15[k_1]["type"]; }> extends infer T_19 extends object ? { [k in keyof T_19]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_15]: T_15[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        } extends infer T_17 extends object ? { [k_2 in keyof T_17]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_15]: T_15[k_1]["type"]; }> extends infer T_18 extends object ? { [k in keyof T_18]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_15]: T_15[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        })[k_2]; } : never>;
+        optional: <T_20 extends orchid_core.JSONTypeAny>(type: T_20) => orchid_core.JSONOptional<T_20>;
+        record: typeof orchid_core.record;
+    }) => Type)): JSONColumn<Type>;
+    jsonText(): JSONTextColumn;
+    array<Item extends ColumnType<unknown, orchid_core.BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
+    type(dataType: string): CustomTypeColumn;
+    domain(dataType: string): DomainColumn;
+    primaryKey(columns: string[], options?: {
+        name?: string | undefined;
+    } | undefined): {};
+    index(columns: orchid_core.MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    unique(columns: orchid_core.MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    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;
+        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>, {}>): {};
+}>;
+
+declare class RawSqlMethods<CT extends ColumnTypesBase> {
     /**
-     * When there is a need to use a piece of raw SQL, use the `sql` method.
+     * When there is a need to use a piece of raw SQL, use the `sql` method from tables, or a `raw` function imported from `orchid-orm`.
      *
-     * To select with a raw SQL, need to specify a column type as a first argument, so the TS could use it to guess the result type of the query:
+     * When selecting a raw SQL, specify a resulting type with `<generic>` syntax:
      *
      * ```ts
      * const result: { num: number }[] = await db.table.select({
-     *   num: db.table.sql((t) => t.integer())`
+     *   num: db.table.sql<number>`
      *     random() * 100
      *   `,
      * });
      * ```
      *
-     * Other than for select, the column type can be omitted:
+     * In a situation when you want the result to be parsed, such as when returning a timestamp that you want to be parsed into a `Date` object, provide a column type in such a way:
+     *
+     * This example assumes that the `timestamp` column was overridden with `asDate` as shown in [Override column types](/guide/columns-overview#override-column-types).
+     *
+     * ```ts
+     * const result: { timestamp: Date }[] = await db.table.select({
+     *   timestamp: db.table.sql`now()`.type((t) => t.timestamp()),
+     * });
+     * ```
+     *
+     * In some cases such as when using [from](/guide/orm-and-query-builder.html#from), setting column type via callback allows for special `where` operations:
+     *
+     * ```ts
+     * const subQuery = db.someTable.select({
+     *   sum: (q) => q.sql`$a + $b`.type((t) => t.decimal()).values({ a: 1, b: 2 }),
+     * });
+     *
+     * // `gt`, `gte`, `min`, `lt`, `lte`, `max` in `where`
+     * // are allowed only for numeric columns:
+     * const result = await db.$from(subQuery).where({ sum: { gte: 5 } });
+     * ```
+     *
+     * ```ts
+     * db.$from(Otherdb.table.select('foo', 'bar'));
+     * ```
+     *
+     * `where` and other methods don't need the return type, so it can be omitted:
      *
      * ```ts
      * await db.table.where(db.table.sql`
@@ -2627,6 +2808,23 @@ declare class RawSqlMethods {
      * `);
      * ```
      *
+     * Instead of `sql` method, you can use `raw` function from `orchid-orm` (or `pqb`) to do the same.
+     * The only difference, `raw` function don't have access to the overridden column types.
+     *
+     * ```ts
+     * import { raw } from 'orchid-orm';
+     *
+     * await db.table.where(raw`
+     *   "someValue" = random() * 100
+     * `);
+     *
+     * await db.table.select({
+     *   // it is a default `timestamp` column,
+     *   // if you have overriden it with `asDate` or `asNumber` it won't be parsed properly:
+     *   now: raw`now()`.type((t) => t.timestamp()),
+     * });
+     * ```
+     *
      * Interpolating values in template literals is completely safe:
      *
      * ```ts
@@ -2652,7 +2850,7 @@ declare class RawSqlMethods {
      * await db.table.where(db.table.sql({ raw: `column = random() * ${value}` }));
      * ```
      *
-     * To inject values into `raw` SQL strings, define it with `$` in the string and provide `values` object.
+     * To inject values into `raw` SQL strings, denote it with `$` in the string and provide `values` object.
      *
      * Use `$$` to provide column or/and table name. Column names will be quoted so don't quote them manually.
      *
@@ -2662,13 +2860,10 @@ declare class RawSqlMethods {
      *
      * // this is SAFE, SQL injection are prevented:
      * await db.table.where(
-     *   db.table.sql({
-     *     values: {
-     *       column: 'someTable.someColumn', // or simply 'column'
-     *       one: value,
-     *       two: 123,
-     *     },
-     *     raw: '$$column = random() * $value',
+     *   db.table.sql({ raw: '$$column = random() * $value' }).values({
+     *     column: 'someTable.someColumn', // or simply 'column'
+     *     one: value,
+     *     two: 123,
      *   }),
      * );
      * ```
@@ -2677,40 +2872,39 @@ declare class RawSqlMethods {
      *
      * ```ts
      * // simplest form:
-     * db.table`key = ${value}`;
+     * db.table.sql`key = ${value}`;
+     *
+     * // with resulting type:
+     * db.table.sql<boolean>`key = ${value}`;
      *
      * // with column type for select:
-     * db.table((t) => t.boolean())`key = ${value}`;
+     * db.table.sql`key = ${value}`.type((t) => t.boolean());
      *
      * // raw SQL string, not allowed to interpolate:
-     * db.table({ raw: 'random()' });
+     * db.table.sql({ raw: 'random()' });
+     *
+     * // with resulting type:
+     * db.table.sql<number>({ raw: 'random()' });
      *
      * // with values:
-     * db.table({
-     *   values: {
-     *     column: 'columnName',
-     *     one: 1,
-     *     two: 2,
-     *   },
-     *   raw: '$$columnName = $one + $two',
+     * db.table.sql({ raw: '$$columnName = $one + $two' }).values({
+     *   columnName: 'column',
+     *   one: 1,
+     *   two: 2,
      * });
      *
-     * // with column type for select:
-     * db.table((t) => t.decimal(), { raw: 'random()' });
-     *
-     * // combine values and template literal:
-     * db.table({ values: { one: 1, two: 2 } })`
-     *   ($one + $two) / $one
-     * `;
+     * // combine template literal, column type, and values:
+     * db.table.sql`($one + $two) / $one`
+     *   .type((t) => t.numeric())
+     *   .values({ one: 1, two: 2 });
      * ```
      *
-     * @param args - template string or a specific options
-     */
-    sql<T extends Query, Args extends SqlArgs<T>>(this: T, ...args: Args): SqlResult<T, Args>;
-    /**
-     * @deprecated use `sql` method instead, `raw` will be removed
+     * @param args - template literal or an object { raw: string }
+     * @return object that has `type` and `values` methods
      */
-    raw<T extends Query, C extends ColumnType>(this: T, ...args: RawArgs<T['columnTypes'], C>): RawExpression<C>;
+    sql<T = unknown>(this: {
+        columnTypes: CT;
+    }, ...args: RawSQLArgs): RawSQL<ColumnTypeBase<T>, CT>;
 }
 
 type CopyArg<T extends Query> = CopyOptions<keyof T['shape']>;
@@ -2846,9 +3040,9 @@ declare class TransformMethods {
     _transform<T extends Query, Fn extends QueryTransformFn<T>>(this: T, fn: Fn): QueryTransform<T, Fn>;
 }
 
-type WindowArg<T extends Query> = Record<string, WindowArgDeclaration<T> | RawExpression>;
+type WindowArg<T extends Query> = Record<string, WindowArgDeclaration<T> | Expression>;
 type WindowArgDeclaration<T extends Query = Query> = {
-    partitionBy?: Expression<T> | Expression<T>[];
+    partitionBy?: SelectableOrExpression<T> | SelectableOrExpression<T>[];
     order?: OrderArg<T>;
 };
 type WindowResult<T extends Query, W extends WindowArg<T>> = T & {
@@ -2858,15 +3052,15 @@ type OrderArg<T extends Query, Key extends PropertyKey = keyof T['selectable'] |
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' ? never : K;
 }[keyof T['result']]> = Key | {
     [K in Key]?: SortDir;
-} | RawExpression;
+} | Expression;
 type OrderArgs<T extends Query> = OrderArg<T>[] | TemplateLiteralArgs;
-type FindArgs<T extends Query> = [T['shape'][T['singlePrimaryKey']]['type'] | RawExpression] | TemplateLiteralArgs;
+type FindArgs<T extends Query> = [T['shape'][T['singlePrimaryKey']]['type'] | 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;
-interface QueryMethods extends Omit<AsMethods, 'result'>, Aggregate, Select, From, Join, With, Union, Omit<JsonModifiers, 'result'>, JsonMethods, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Omit<Where, 'result'>, Clear, Having, Window, Then, QueryLog, Omit<QueryHooks, 'result'>, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods, CopyMethods, TransformMethods {
+interface QueryMethods<CT extends ColumnTypesBase> extends Omit<AsMethods, 'result'>, Aggregate, Select, From, Join, With, Union, Omit<JsonModifiers, 'result'>, JsonMethods, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Omit<Where, 'result'>, Clear, Having, Window, Then, QueryLog, Omit<QueryHooks, 'result'>, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<CT>, CopyMethods, TransformMethods {
 }
-declare class QueryMethods {
+declare class QueryMethods<CT extends ColumnTypesBase> {
     /**
      * `.all` is a default behavior, that returns an array of objects:
      *
@@ -2927,8 +3121,8 @@ declare class QueryMethods {
      * ```
      * @param select - column name or a raw SQL
      */
-    pluck<T extends Query, S extends Expression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
-    _pluck<T extends Query, S extends Expression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
+    pluck<T extends Query, S extends SelectableOrExpression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
+    _pluck<T extends Query, S extends SelectableOrExpression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
     /**
      * `.exec` won't parse the response at all, and returns undefined:
      *
@@ -2980,8 +3174,8 @@ declare class QueryMethods {
      *
      * @param columns - column names or a raw SQL
      */
-    distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T;
-    _distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    distinct<T extends Query>(this: T, ...columns: SelectableOrExpression<T>[]): T;
+    _distinct<T extends Query>(this: T, ...columns: SelectableOrExpression<T>[]): T;
     /**
      * Find a single record by the primary key (id), adds `LIMIT 1`.
      * Throws when not found.
@@ -3068,8 +3262,8 @@ declare class QueryMethods {
      *
      * @param columns - column names or a raw SQL
      */
-    group<T extends Query>(this: T, ...columns: Expression<T>[]): T;
-    _group<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    group<T extends Query>(this: T, ...columns: SelectableOrExpression<T>[]): T;
+    _group<T extends Query>(this: T, ...columns: SelectableOrExpression<T>[]): T;
     window<T extends Query, W extends WindowArg<T>>(this: T, arg: W): WindowResult<T, W>;
     _window<T extends Query, W extends WindowArg<T>>(this: T, arg: W): WindowResult<T, W>;
     wrap<T extends Query, Q extends Query, As extends string = 't'>(this: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
@@ -3204,7 +3398,7 @@ declare class QueryMethods {
     makeHelper<T extends Query, Args extends unknown[], Result>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
 }
 
-type AggregateArg<T extends Query> = Expression<T> | Record<string, Expression<T>> | [Expression<T>, string];
+type AggregateArg<T extends Query> = SelectableOrExpression<T> | Record<string, SelectableOrExpression<T>> | [SelectableOrExpression<T>, string];
 type AggregateOptions<T extends Query = Query, As extends string | undefined = any> = {
     as?: As;
     distinct?: boolean;
@@ -3215,19 +3409,19 @@ type AggregateOptions<T extends Query = Query, As extends string | undefined = a
     over?: keyof T['windows'] | WindowArgDeclaration<T>;
 };
 type Aggregate1ArgumentTypes<T extends Query = Query, C extends ColumnTypeBase = ColumnTypeBase> = {
-    count: Expression<T, C>;
+    count: SelectableOrExpression<T, C>;
     avg: NumberExpression<T, C>;
-    min: Expression<T, C>;
-    max: Expression<T, C>;
+    min: SelectableOrExpression<T, C>;
+    max: SelectableOrExpression<T, C>;
     sum: NumberExpression<T, C>;
     bitAnd: NumberExpression<T, C>;
     bitOr: NumberExpression<T, C>;
     boolAnd: BooleanExpression<T, C>;
     boolOr: BooleanExpression<T, C>;
     every: BooleanExpression<T, C>;
-    jsonAgg: Expression<T, C>;
-    jsonbAgg: Expression<T, C>;
-    xmlAgg: Expression<T, C>;
+    jsonAgg: SelectableOrExpression<T, C>;
+    jsonbAgg: SelectableOrExpression<T, C>;
+    xmlAgg: SelectableOrExpression<T, C>;
 };
 declare const aggregate1FunctionNames: {
     readonly count: "count";
@@ -3262,40 +3456,40 @@ declare class Aggregate {
     _selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
     avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     _avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
-    selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
-    _selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
+    selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
+    _selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
     min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     _min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
-    selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
-    _selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
+    selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
+    _selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
     max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     _max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
-    selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
-    _selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
+    selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
+    _selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
     sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     _sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
-    selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
-    _selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
+    selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
+    _selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
     bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     _bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
-    selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
-    _selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
+    selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
+    _selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
     bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     _bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
-    selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
-    _selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
+    selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
+    _selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
     boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
     _boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
-    selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
-    _selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
+    selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
+    _selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
     boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
     _boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
-    selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
-    _selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
+    selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
+    _selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
     every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
     _every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
-    selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
-    _selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
+    selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
+    _selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: SelectableOrExpression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
     jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
     _jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
     selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
@@ -3308,28 +3502,28 @@ declare class Aggregate {
     _xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<StringColumn>>;
     selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
     _selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
-    jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
+    jsonObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    _jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
+    _jsonObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
+    selectJsonObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    _selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
+    _selectJsonObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
+    jsonbObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    _jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
+    _jsonbObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
+    selectJsonbObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    _selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
+    _selectJsonbObjectAgg<T extends Query, Obj extends Record<string, SelectableOrExpression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
     stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<StringColumn>>;
@@ -3358,7 +3552,7 @@ type WithDataItem = {
     shape: ColumnsShapeBase;
 };
 type WithDataBase = Record<never, WithDataItem>;
-type Query = QueryCommon & QueryMethods & {
+type Query = QueryCommon & QueryMethods<ColumnTypesBase> & {
     queryBuilder: Db;
     columnTypes: ColumnTypesBase;
     whereQueryBuilder: typeof WhereQueryBuilder;
@@ -3415,7 +3609,7 @@ type SetQueryReturnsAll<T extends Query> = SetQueryReturns<WhereResult<T>, 'all'
 type SetQueryReturnsOneOptional<T extends Query> = SetQueryReturns<T, 'one'>;
 type SetQueryReturnsOne<T extends Query> = SetQueryReturns<T, 'oneOrThrow'>;
 type SetQueryReturnsRows<T extends Query> = SetQueryReturns<T, 'rows'>;
-type SetQueryReturnsPluck<T extends Query, S extends keyof T['selectable'] | RawExpression, C extends ColumnTypeBase = S extends keyof T['selectable'] ? T['selectable'][S]['column'] : S extends RawExpression ? S['__column'] : never> = Omit<T, 'result' | 'returnType' | 'then' | 'catch'> & {
+type SetQueryReturnsPluck<T extends Query, S extends keyof T['selectable'] | Expression, C extends ColumnTypeBase = S extends keyof T['selectable'] ? T['selectable'][S]['column'] : S extends Expression ? S['_type'] : never> = Omit<T, 'result' | 'returnType' | 'then' | 'catch'> & {
     meta: {
         hasSelect: true;
     };
@@ -3473,144 +3667,144 @@ declare const Operators: {
         not: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
         };
-        in: ((key: string, value: any[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | RawExpression | Query;
+        in: ((key: string, value: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: any[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | RawExpression | Query;
+        notIn: ((key: string, value: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     boolean: {
-        equals: ((key: string, value: boolean | RawExpression | Query, values: unknown[]) => string) & {
-            type: boolean | RawExpression | Query;
+        equals: ((key: string, value: boolean | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: boolean | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: boolean | RawExpression | Query, values: unknown[]) => string) & {
-            type: boolean | RawExpression | Query;
+        not: ((key: string, value: boolean | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: boolean | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: RawExpression | Query | boolean[], values: unknown[]) => string) & {
-            type: RawExpression | Query | boolean[];
+        in: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[];
         };
-        notIn: ((key: string, value: RawExpression | Query | boolean[], values: unknown[]) => string) & {
-            type: RawExpression | Query | boolean[];
+        notIn: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[];
         };
     };
     number: {
-        lt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        lt: ((key: string, value: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        lte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        lte: ((key: string, value: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        gt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        gt: ((key: string, value: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        gte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        gte: ((key: string, value: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        between: ((key: string, value: [number | RawExpression | Query, number | RawExpression | Query], values: unknown[]) => string) & {
-            type: [number | RawExpression | Query, number | RawExpression | Query];
+        between: ((key: string, value: [number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query], values: unknown[]) => string) & {
+            type: [number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query];
         };
-        equals: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        equals: ((key: string, value: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        not: ((key: string, value: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        in: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
         };
-        notIn: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        notIn: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
         };
     };
     date: {
-        lt: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        lt: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        lte: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        lte: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        gt: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        gt: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        gte: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        gte: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        between: ((key: string, value: [RawExpression | Date | Query, RawExpression | Date | Query], values: unknown[]) => string) & {
-            type: [RawExpression | Date | Query, RawExpression | Date | Query];
+        between: ((key: string, value: [Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query], values: unknown[]) => string) & {
+            type: [Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query];
         };
-        equals: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        equals: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        not: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        not: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        in: ((key: string, value: RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: RawExpression | Query | Date[];
+        in: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
         };
-        notIn: ((key: string, value: RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: RawExpression | Query | Date[];
+        notIn: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
         };
     };
     time: {
-        lt: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        lt: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        lte: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        lte: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        gt: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        gt: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        gte: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        gte: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        between: ((key: string, value: [RawExpression | Date | Query, RawExpression | Date | Query], values: unknown[]) => string) & {
-            type: [RawExpression | Date | Query, RawExpression | Date | Query];
+        between: ((key: string, value: [Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query], values: unknown[]) => string) & {
+            type: [Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query];
         };
-        equals: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        equals: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        not: ((key: string, value: RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: RawExpression | Date | Query;
+        not: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
         };
-        in: ((key: string, value: RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: RawExpression | Query | Date[];
+        in: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
         };
-        notIn: ((key: string, value: RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: RawExpression | Query | Date[];
+        notIn: ((key: string, value: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
         };
     };
     text: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     json: {
@@ -3629,11 +3823,11 @@ declare const Operators: {
         not: ((key: string, value: unknown, values: unknown[]) => string) & {
             type: unknown;
         };
-        in: ((key: string, value: unknown[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: unknown[] | RawExpression | Query;
+        in: ((key: string, value: unknown[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: unknown[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: unknown[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: unknown[] | RawExpression | Query;
+        notIn: ((key: string, value: unknown[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: unknown[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     array: {
@@ -3643,21 +3837,17 @@ declare const Operators: {
         not: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
         };
-        in: ((key: string, value: any[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | RawExpression | Query;
+        in: ((key: string, value: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: any[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | RawExpression | Query;
+        notIn: ((key: string, value: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
 };
 
-type ColumnsShape = Record<string, ColumnType>;
-declare abstract class ColumnsObject<Shape extends ColumnsShapeBase> extends ColumnType<{
-    [K in keyof Shape]: Shape[K]['type'];
-}, typeof Operators.any> {
-    shape: Shape;
-    dataType: "object";
+declare class CustomTypeColumn extends ColumnType<unknown, typeof Operators.any> {
+    dataType: string;
     operators: {
         equals: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
@@ -3665,19 +3855,27 @@ declare abstract class ColumnsObject<Shape extends ColumnsShapeBase> extends Col
         not: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
         };
-        in: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        in: ((key: string, value: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        notIn: ((key: string, value: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
-    constructor(shape: Shape);
+    constructor(dataType: string);
+    toCode(t: string): Code;
 }
-declare abstract class ArrayOfColumnsObjects<Shape extends ColumnsShapeBase> extends ColumnType<{
-    [K in keyof Shape]: Shape[K]['type'];
-}[], typeof Operators.any> {
-    shape: Shape;
+declare class DomainColumn extends CustomTypeColumn {
+    toCode(t: string): Code;
+}
+
+type ArrayData<Item extends ColumnTypeBase> = ColumnData & ArrayMethodsData & {
+    item: Item;
+};
+type ArrayMethods = typeof arrayMethods;
+interface ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array>, ArrayMethods {
+}
+declare class ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array> {
     dataType: "array";
     operators: {
         equals: ((key: string, value: any, values: unknown[]) => string) & {
@@ -3686,185 +3884,165 @@ declare abstract class ArrayOfColumnsObjects<Shape extends ColumnsShapeBase> ext
         not: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
         };
-        in: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        in: ((key: string, value: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        notIn: ((key: string, value: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
-    constructor(shape: Shape);
-}
-declare abstract class PluckResultColumnType<C extends ColumnTypeBase> extends ColumnTypeBase<C['type'][], typeof Operators.any> {
+    data: ArrayData<Item>;
+    constructor(item: Item);
+    toSQL(): string;
+    toCode(this: ArrayColumn<Item>, t: string): Code;
+    parseFn: ((input: unknown) => unknown[]) & {
+        hideFromCode: boolean;
+    };
 }
 
-type NumberColumn = ColumnType<number, typeof Operators.number>;
-type NumberColumnData = BaseNumberData & {
-    identity: TableData.Identity;
-};
-type SerialColumnData = NumberColumnData & {
-    default: RawExpression;
+type JSONTypes = typeof jsonTypes;
+declare const jsonTypes: {
+    set: <Value extends JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
+    tuple: <T extends [] | orchid_core.JSONTupleItems, Rest extends JSONTypeAny | null = null>(items: T, rest?: Rest) => orchid_core.JSONTuple<T, Rest>;
+    union: <T_1 extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T_1) => orchid_core.JSONUnion<T_1>;
+    any: () => orchid_core.JSONAny;
+    bigint: () => orchid_core.JSONBigInt;
+    boolean: () => orchid_core.JSONBoolean;
+    date: () => orchid_core.JSONDate;
+    nan: () => orchid_core.JSONNaN;
+    never: () => orchid_core.JSONNever;
+    null: () => orchid_core.JSONNull;
+    number: () => orchid_core.JSONNumber;
+    string: () => orchid_core.JSONString;
+    unknown: () => orchid_core.JSONUnknown;
+    array: <Type extends JSONTypeAny>(element: Type) => orchid_core.JSONArray<Type, "many">;
+    discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
+    enum: <U extends string, T_2 extends [U, ...U[]]>(options: T_2) => orchid_core.JSONEnum<U, T_2>;
+    instanceOf: <T_3 extends new (...args: any[]) => any>(cls: T_3) => orchid_core.JSONInstanceOf<T_3>;
+    intersection: <Left extends JSONTypeAny, Right extends JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+    lazy: <T_4 extends JSONTypeAny>(fn: () => T_4) => orchid_core.JSONLazy<T_4>;
+    literal: <T_5 extends orchid_core.Primitive>(value: T_5) => orchid_core.JSONLiteral<T_5>;
+    map: <Key extends JSONTypeAny, Value_1 extends JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
+    nativeEnum: <T_6 extends orchid_core.EnumLike>(givenEnum: T_6) => orchid_core.JSONNativeEnum<T_6>;
+    nullable: <T_7 extends JSONTypeAny>(type: T_7) => orchid_core.JSONNullable<T_7>;
+    nullish: <T_8 extends JSONTypeAny>(type: T_8) => orchid_core.JSONNullish<T_8>;
+    object: <T_9 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T_9) => orchid_core.JSONObject<T_9, UnknownKeys, Catchall, JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_10 extends object ? { [k in keyof T_10]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never) & {
+        [k: string]: Catchall["type"];
+    } extends infer T_11 extends object ? { [k_2 in keyof T_11]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_12 extends object ? { [k in keyof T_12]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never) & {
+        [k: string]: Catchall["type"];
+    })[k_2]; } : never>;
+    optional: <T_14 extends JSONTypeAny>(type: T_14) => orchid_core.JSONOptional<T_14>;
+    record: typeof record;
 };
-type NumberMethods = typeof numberTypeMethods;
-interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
-}
-declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
-    data: NumberColumnData;
+declare class JSONColumn<Type extends JSONTypeAny = JSONTypeAny> extends ColumnType<Type['type'], typeof Operators.json> {
+    dataType: "jsonb";
     operators: {
-        lt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
-        };
-        lte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
-        };
-        gt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        jsonPath: ((key: string, value: [path: string, op: string, value: unknown], values: unknown[]) => string) & {
+            type: [path: string, op: string, value: unknown];
         };
-        gte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        jsonSupersetOf: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
         };
-        between: ((key: string, value: [number | RawExpression | Query, number | RawExpression | Query], values: unknown[]) => string) & {
-            type: [number | RawExpression | Query, number | RawExpression | Query];
+        jsonSubsetOf: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
         };
-        equals: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        equals: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
         };
-        not: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        not: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
         };
-        in: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        in: ((key: string, value: unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        notIn: ((key: string, value: unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: unknown[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
+    data: ColumnData & {
+        schema: Type;
+    };
+    constructor(schemaOrFn?: Type | ((j: JSONTypes) => Type));
+    toCode(t: string): Code;
 }
-declare abstract class IntegerBaseColumn extends NumberBaseColumn {
-    data: NumberColumnData;
-    constructor();
-}
-declare abstract class NumberAsStringBaseColumn extends ColumnType<string, typeof Operators.number> {
+declare class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "json";
     operators: {
-        lt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        contains: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        lte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        gt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        startsWith: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        gte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        between: ((key: string, value: [number | RawExpression | Query, number | RawExpression | Query], values: unknown[]) => string) & {
-            type: [number | RawExpression | Query, number | RawExpression | Query];
+        endsWith: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        equals: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        not: ((key: string, value: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        in: ((key: string, value: string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        notIn: ((key: string, value: string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
-    data: ColumnData;
+    toCode(t: string): Code;
 }
-declare class DecimalBaseColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends ColumnType<string, typeof Operators.number> {
-    data: ColumnData & {
-        numericPrecision: Precision;
-        numericScale: Scale;
-    };
+
+declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]> extends ColumnType<T[number], typeof Operators.any> {
+    enumName: string;
+    options: T;
     operators: {
-        lt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
         };
-        lte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
         };
-        gt: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        in: ((key: string, value: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        gte: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        notIn: ((key: string, value: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        between: ((key: string, value: [number | RawExpression | Query, number | RawExpression | Query], values: unknown[]) => string) & {
-            type: [number | RawExpression | Query, number | RawExpression | Query];
+    };
+    dataType: string;
+    constructor(enumName: string, options: T);
+    toCode(t: string, migration?: boolean): Code;
+    toSQL(): string;
+}
+
+declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean> {
+    dataType: "boolean";
+    operators: {
+        equals: ((key: string, value: boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        not: ((key: string, value: boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: boolean | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: number | RawExpression | Query, values: unknown[]) => string) & {
-            type: number | RawExpression | Query;
+        in: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[], values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[];
         };
-        in: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
-        };
-        notIn: ((key: string, value: RawExpression | number[] | Query, values: unknown[]) => string) & {
-            type: RawExpression | number[] | Query;
+        notIn: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[], values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | boolean[];
         };
     };
-    dataType: "decimal";
-    constructor(numericPrecision?: Precision, numericScale?: Scale);
-    toCode(t: string): Code;
-    toSQL(): string;
-}
-type IdentityColumn<T extends ColumnTypeBase> = ColumnWithDefault<T, RawExpression>;
-declare class SmallIntColumn extends IntegerBaseColumn {
-    dataType: "smallint";
-    parseItem: typeof parseInt;
-    toCode(t: string): Code;
-    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
-}
-declare class IntegerColumn extends IntegerBaseColumn {
-    dataType: "integer";
-    parseItem: typeof parseInt;
-    toCode(t: string): Code;
-    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
-}
-declare class BigIntColumn extends NumberAsStringBaseColumn {
-    dataType: "bigint";
-    toCode(t: string): Code;
-    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
-}
-declare class DecimalColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends DecimalBaseColumn<Precision, Scale> {
-}
-declare class RealColumn extends NumberBaseColumn {
-    dataType: "real";
-    parseItem: typeof parseFloat;
-    toCode(t: string): Code;
-}
-declare class DoublePrecisionColumn extends NumberAsStringBaseColumn {
-    dataType: "double precision";
-    toCode(t: string): Code;
-}
-declare class SmallSerialColumn extends IntegerBaseColumn {
-    dataType: "smallint";
-    parseItem: typeof parseInt;
-    data: SerialColumnData;
-    constructor();
-    toSQL(): string;
-    toCode(t: string): Code;
-}
-declare class SerialColumn extends IntegerBaseColumn {
-    dataType: "integer";
-    parseItem: typeof parseInt;
-    data: SerialColumnData;
-    constructor();
-    toSQL(): string;
-    toCode(t: string): Code;
-}
-declare class BigSerialColumn extends NumberAsStringBaseColumn {
-    dataType: "bigint";
-    data: SerialColumnData;
-    toSql(): string;
     toCode(t: string): Code;
+    parseItem: (input: string) => boolean;
 }
 
 type StringColumn = ColumnType<string, typeof Operators.text>;
@@ -4072,35 +4250,35 @@ interface TextBaseColumn extends ColumnType<string, typeof Operators.text>, Text
 declare abstract class TextBaseColumn extends ColumnType<string, typeof Operators.text> {
     data: TextColumnData;
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
 }
@@ -4131,35 +4309,35 @@ declare class TextColumn extends TextBaseColumn {
 declare class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
     dataType: "bytea";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4167,35 +4345,35 @@ declare class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
 declare class PointColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "point";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4203,35 +4381,35 @@ declare class PointColumn extends ColumnType<string, typeof Operators.text> {
 declare class LineColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "line";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4239,35 +4417,35 @@ declare class LineColumn extends ColumnType<string, typeof Operators.text> {
 declare class LsegColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "lseg";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4275,35 +4453,35 @@ declare class LsegColumn extends ColumnType<string, typeof Operators.text> {
 declare class BoxColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "box";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4311,35 +4489,35 @@ declare class BoxColumn extends ColumnType<string, typeof Operators.text> {
 declare class PathColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "path";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4347,35 +4525,35 @@ declare class PathColumn extends ColumnType<string, typeof Operators.text> {
 declare class PolygonColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "polygon";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4383,35 +4561,35 @@ declare class PolygonColumn extends ColumnType<string, typeof Operators.text> {
 declare class CircleColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "circle";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4426,35 +4604,35 @@ declare class MoneyColumn extends NumberBaseColumn {
 declare class CidrColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "cidr";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4462,35 +4640,35 @@ declare class CidrColumn extends ColumnType<string, typeof Operators.text> {
 declare class InetColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "inet";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4498,35 +4676,35 @@ declare class InetColumn extends ColumnType<string, typeof Operators.text> {
 declare class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "macaddr";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4534,35 +4712,35 @@ declare class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
 declare class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
     dataType: "macaddr8";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4570,35 +4748,35 @@ declare class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
 declare class BitColumn<Length extends number> extends ColumnType<string, typeof Operators.text> {
     dataType: "bit";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     data: ColumnData & {
@@ -4611,35 +4789,35 @@ 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: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     data: ColumnData & {
@@ -4652,35 +4830,35 @@ declare class BitVaryingColumn<Length extends number | undefined = undefined> ex
 declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "tsvector";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4688,35 +4866,35 @@ declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
 declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "tsquery";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4724,35 +4902,35 @@ declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
 declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "uuid";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     primaryKey<T extends ColumnType>(this: T): PrimaryKeyColumn<T>;
@@ -4761,35 +4939,35 @@ declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
 declare class XMLColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "xml";
     operators: {
-        contains: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        contains: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        containsSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        containsSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        startsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        startsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWith: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWith: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        endsWithSensitive: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        endsWithSensitive: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        equals: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        equals: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        not: ((key: string, value: string | RawExpression | Query, values: unknown[]) => string) & {
-            type: string | RawExpression | Query;
+        not: ((key: string, value: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        in: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        in: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: string[] | RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | RawExpression | Query;
+        notIn: ((key: string, value: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: string[] | Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(t: string): Code;
@@ -4804,142 +4982,33 @@ declare class CitextColumn extends TextBaseColumn {
     toCode(t: string): Code;
 }
 
-interface DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date>, DateTypeMethods {
-}
-declare abstract class DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date> {
-    data: DateColumnData;
-    operators: {
-        lt: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        lte: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        gt: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        gte: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        between: ((key: string, value: [orchid_core.RawExpression | Date | Query, orchid_core.RawExpression | Date | Query], values: unknown[]) => string) & {
-            type: [orchid_core.RawExpression | Date | Query, orchid_core.RawExpression | Date | Query];
-        };
-        equals: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        not: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        in: ((key: string, value: orchid_core.RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Query | Date[];
-        };
-        notIn: ((key: string, value: orchid_core.RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Query | Date[];
-        };
-    };
-    encodeFn: (input: string | number | Date) => Date;
-    asNumber(): EncodeColumn<IntegerColumn, string | number | Date>;
-    asDate<T extends ColumnType>(this: T): ParseColumn<T, Date>;
-}
-declare class DateColumn extends DateBaseColumn {
-    dataType: "date";
-    toCode(t: string): Code;
-}
-declare abstract class DateTimeBaseClass<Precision extends number | undefined = undefined> extends DateBaseColumn {
-    data: DateColumnData & {
-        dateTimePrecision: Precision;
-    };
-    constructor(dateTimePrecision?: Precision);
-    toSQL(): string;
-}
-declare abstract class DateTimeTzBaseClass<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
-    abstract baseDataType: string;
-    toSQL(): string;
-}
-declare class TimestampColumn<Precision extends number> extends DateTimeBaseClass<Precision> {
-    dataType: "timestamp";
-    toCode(t: string): Code;
-}
-declare class TimestampTZColumn<Precision extends number> extends DateTimeTzBaseClass<Precision> {
-    dataType: "timestamptz";
-    baseDataType: "timestamp";
-    toCode(t: string): Code;
-}
-declare class TimeColumn<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
-    dataType: "time";
-    toCode(t: string): Code;
-}
-type TimeInterval = {
-    years?: number;
-    months?: number;
-    days?: number;
-    hours?: number;
-    minutes?: number;
-    seconds?: number;
-};
-declare class IntervalColumn<Fields extends string | undefined = undefined, Precision extends number | undefined = undefined> extends ColumnType<TimeInterval, typeof Operators.date> {
-    dataType: "interval";
-    data: ColumnData & {
-        fields: Fields;
-        precision: Precision;
-    };
-    operators: {
-        lt: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        lte: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        gt: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        gte: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        between: ((key: string, value: [orchid_core.RawExpression | Date | Query, orchid_core.RawExpression | Date | Query], values: unknown[]) => string) & {
-            type: [orchid_core.RawExpression | Date | Query, orchid_core.RawExpression | Date | Query];
-        };
-        equals: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        not: ((key: string, value: orchid_core.RawExpression | Date | Query, values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Date | Query;
-        };
-        in: ((key: string, value: orchid_core.RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Query | Date[];
-        };
-        notIn: ((key: string, value: orchid_core.RawExpression | Query | Date[], values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Query | Date[];
-        };
-    };
-    constructor(fields?: Fields, precision?: Precision);
-    toCode(t: string): Code;
-    toSQL(): string;
-}
-
-declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean> {
-    dataType: "boolean";
+type ColumnsShape = Record<string, ColumnType>;
+declare abstract class ColumnsObject<Shape extends ColumnsShapeBase> extends ColumnType<{
+    [K in keyof Shape]: Shape[K]['type'];
+}, typeof Operators.any> {
+    shape: Shape;
+    dataType: "object";
     operators: {
-        equals: ((key: string, value: boolean | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: boolean | orchid_core.RawExpression | Query;
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
         };
-        not: ((key: string, value: boolean | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: boolean | orchid_core.RawExpression | Query;
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
         };
-        in: ((key: string, value: orchid_core.RawExpression | Query | boolean[], values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Query | boolean[];
+        in: ((key: string, value: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: orchid_core.RawExpression | Query | boolean[], values: unknown[]) => string) & {
-            type: orchid_core.RawExpression | Query | boolean[];
+        notIn: ((key: string, value: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
-    toCode(t: string): Code;
-    parseItem: (input: string) => boolean;
+    constructor(shape: Shape);
 }
-
-declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]> extends ColumnType<T[number], typeof Operators.any> {
-    enumName: string;
-    options: T;
+declare abstract class ArrayOfColumnsObjects<Shape extends ColumnsShapeBase> extends ColumnType<{
+    [K in keyof Shape]: Shape[K]['type'];
+}[], typeof Operators.any> {
+    shape: Shape;
+    dataType: "array";
     operators: {
         equals: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
@@ -4947,200 +5016,43 @@ declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]>
         not: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
         };
-        in: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        in: ((key: string, value: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        notIn: ((key: string, value: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
-    dataType: string;
-    constructor(enumName: string, options: T);
-    toCode(t: string, migration?: boolean): Code;
-    toSQL(): string;
+    constructor(shape: Shape);
+}
+declare abstract class PluckResultColumnType<C extends ColumnTypeBase> extends ColumnTypeBase<C['type'][], typeof Operators.any> {
 }
 
-type JSONTypes = typeof jsonTypes;
-declare const jsonTypes: {
-    set: <Value extends JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
-    tuple: <T extends [] | orchid_core.JSONTupleItems, Rest extends JSONTypeAny | null = null>(items: T, rest?: Rest) => orchid_core.JSONTuple<T, Rest>;
-    union: <T_1 extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T_1) => orchid_core.JSONUnion<T_1>;
-    any: () => orchid_core.JSONAny;
-    bigint: () => orchid_core.JSONBigInt;
-    boolean: () => orchid_core.JSONBoolean;
-    date: () => orchid_core.JSONDate;
-    nan: () => orchid_core.JSONNaN;
-    never: () => orchid_core.JSONNever;
-    null: () => orchid_core.JSONNull;
-    number: () => orchid_core.JSONNumber;
-    string: () => orchid_core.JSONString;
-    unknown: () => orchid_core.JSONUnknown;
-    array: <Type extends JSONTypeAny>(element: Type) => orchid_core.JSONArray<Type, "many">;
-    discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
-    enum: <U extends string, T_2 extends [U, ...U[]]>(options: T_2) => orchid_core.JSONEnum<U, T_2>;
-    instanceOf: <T_3 extends new (...args: any[]) => any>(cls: T_3) => orchid_core.JSONInstanceOf<T_3>;
-    intersection: <Left extends JSONTypeAny, Right extends JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
-    lazy: <T_4 extends JSONTypeAny>(fn: () => T_4) => orchid_core.JSONLazy<T_4>;
-    literal: <T_5 extends orchid_core.Primitive>(value: T_5) => orchid_core.JSONLiteral<T_5>;
-    map: <Key extends JSONTypeAny, Value_1 extends JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
-    nativeEnum: <T_6 extends orchid_core.EnumLike>(givenEnum: T_6) => orchid_core.JSONNativeEnum<T_6>;
-    nullable: <T_7 extends JSONTypeAny>(type: T_7) => orchid_core.JSONNullable<T_7>;
-    nullish: <T_8 extends JSONTypeAny>(type: T_8) => orchid_core.JSONNullish<T_8>;
-    object: <T_9 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T_9) => orchid_core.JSONObject<T_9, UnknownKeys, Catchall, JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_10 extends object ? { [k in keyof T_10]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never) & {
-        [k: string]: Catchall["type"];
-    } extends infer T_11 extends object ? { [k_2 in keyof T_11]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_12 extends object ? { [k in keyof T_12]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never) & {
-        [k: string]: Catchall["type"];
-    })[k_2]; } : never>;
-    optional: <T_14 extends JSONTypeAny>(type: T_14) => orchid_core.JSONOptional<T_14>;
-    record: typeof record;
+type ColumnTypes = typeof columnTypes;
+type TableData = {
+    primaryKey?: TableData.PrimaryKey;
+    indexes?: TableData.Index[];
+    constraints?: TableData.Constraint[];
 };
-declare class JSONColumn<Type extends JSONTypeAny = JSONTypeAny> extends ColumnType<Type['type'], typeof Operators.json> {
-    dataType: "jsonb";
-    operators: {
-        jsonPath: ((key: string, value: [path: string, op: string, value: unknown], values: unknown[]) => string) & {
-            type: [path: string, op: string, value: unknown];
-        };
-        jsonSupersetOf: ((key: string, value: unknown, values: unknown[]) => string) & {
-            type: unknown;
-        };
-        jsonSubsetOf: ((key: string, value: unknown, values: unknown[]) => string) & {
-            type: unknown;
-        };
-        equals: ((key: string, value: unknown, values: unknown[]) => string) & {
-            type: unknown;
-        };
-        not: ((key: string, value: unknown, values: unknown[]) => string) & {
-            type: unknown;
-        };
-        in: ((key: string, value: unknown[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: unknown[] | orchid_core.RawExpression | Query;
-        };
-        notIn: ((key: string, value: unknown[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: unknown[] | orchid_core.RawExpression | Query;
+declare namespace TableData {
+    type PrimaryKey = {
+        columns: string[];
+        options?: {
+            name?: string;
         };
     };
-    data: ColumnData & {
-        schema: Type;
+    type Index = {
+        columns: IndexColumnOptions[];
+        options: IndexOptions;
     };
-    constructor(schemaOrFn?: Type | ((j: JSONTypes) => Type));
-    toCode(t: string): Code;
-}
-declare class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "json";
-    operators: {
-        contains: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        containsSensitive: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        startsWith: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        startsWithSensitive: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        endsWith: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        endsWithSensitive: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        equals: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        not: ((key: string, value: string | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string | orchid_core.RawExpression | Query;
-        };
-        in: ((key: string, value: string[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | orchid_core.RawExpression | Query;
-        };
-        notIn: ((key: string, value: string[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: string[] | orchid_core.RawExpression | Query;
-        };
+    type Constraint = {
+        name?: string;
+        check?: Check;
+        identity?: Identity;
+        references?: References;
+        dropMode?: DropMode;
     };
-    toCode(t: string): Code;
-}
-
-type ArrayData<Item extends ColumnTypeBase> = ColumnData & ArrayMethodsData & {
-    item: Item;
-};
-type ArrayMethods = typeof arrayMethods;
-interface ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array>, ArrayMethods {
-}
-declare class ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['type'][], typeof Operators.array> {
-    dataType: "array";
-    operators: {
-        equals: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
-        };
-        not: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
-        };
-        in: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
-        };
-        notIn: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
-        };
-    };
-    data: ArrayData<Item>;
-    constructor(item: Item);
-    toSQL(): string;
-    toCode(this: ArrayColumn<Item>, t: string): Code;
-    parseFn: ((input: unknown) => unknown[]) & {
-        hideFromCode: boolean;
-    };
-}
-
-declare class CustomTypeColumn extends ColumnType<unknown, typeof Operators.any> {
-    dataType: string;
-    operators: {
-        equals: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
-        };
-        not: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
-        };
-        in: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
-        };
-        notIn: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
-        };
-    };
-    constructor(dataType: string);
-    toCode(t: string): Code;
-}
-declare class DomainColumn extends CustomTypeColumn {
-    toCode(t: string): Code;
-}
-
-type ColumnTypes = typeof columnTypes;
-type TableData = {
-    primaryKey?: TableData.PrimaryKey;
-    indexes?: TableData.Index[];
-    constraints?: TableData.Constraint[];
-};
-declare namespace TableData {
-    type PrimaryKey = {
-        columns: string[];
-        options?: {
-            name?: string;
-        };
-    };
-    type Index = {
-        columns: IndexColumnOptions[];
-        options: IndexOptions;
-    };
-    type Constraint = {
-        name?: string;
-        check?: Check;
-        identity?: Identity;
-        references?: References;
-        dropMode?: DropMode;
-    };
-    type Check = RawExpression;
+    type Check = RawSQLBase;
     type References = {
         columns: string[];
         fnOrTable: (() => ForeignKeyTable) | string;
@@ -5167,10 +5079,10 @@ declare const getTableData: () => TableData;
 declare const resetTableData: (data?: TableData) => void;
 declare const getColumnTypes: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>, Shape extends ColumnsShape>(types: CT, fn: (t: CT) => Shape, nowSQL: string | undefined, data?: TableData) => Shape;
 declare function text(min: number, max: number): TextColumn;
-declare function sql(sql: TemplateStringsArray, ...values: unknown[]): RawExpression;
-declare function sql(sql: string): RawExpression;
-declare function sql(values: Record<string, unknown>, sql: string): RawExpression;
-declare function sql(values: Record<string, unknown>): (...sql: TemplateLiteralArgs) => RawExpression;
+declare function sql(sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase;
+declare function sql(sql: string): RawSQLBase;
+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: {
@@ -5179,12 +5091,12 @@ declare const columnTypes: {
         };
         timestamp(): T;
         timestampsSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T, RawExpression>;
-            updatedAt: orchid_core.ColumnWithDefault<T, RawExpression>;
+            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, RawExpression>;
-        updatedAt: orchid_core.ColumnWithDefault<T, RawExpression>;
+        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>, {}>>;
     };
     timestampsSnakeCase<T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
@@ -5192,8 +5104,8 @@ declare const columnTypes: {
         };
         timestamp(): T_1;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_1, RawExpression>;
-        updatedAt: orchid_core.ColumnWithDefault<T_1, RawExpression>;
+        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>, {}>>;
     };
     timestampsNoTZ<T_2 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
@@ -5201,12 +5113,12 @@ declare const columnTypes: {
         };
         timestampNoTZ(): T_2;
         timestampsNoTZSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T_2, RawExpression>;
-            updatedAt: orchid_core.ColumnWithDefault<T_2, RawExpression>;
+            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, RawExpression>;
-        updatedAt: orchid_core.ColumnWithDefault<T_2, RawExpression>;
+        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>, {}>>;
     };
     timestampsNoTZSnakeCase<T_3 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
         name(name: string): {
@@ -5214,8 +5126,8 @@ declare const columnTypes: {
         };
         timestampNoTZ(): T_3;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_3, RawExpression>;
-        updatedAt: orchid_core.ColumnWithDefault<T_3, RawExpression>;
+        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>, {}>>;
     };
     name: typeof name;
     sql: typeof sql;
@@ -5274,15 +5186,297 @@ 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?: RawExpression | undefined;
+        check?: RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, 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 & {
         name?: string;
         dropMode?: DropMode;
     }): EmptyObject;
-    check(check: RawExpression): EmptyObject;
+    check(check: RawSQLBase): EmptyObject;
+};
+
+type NumberColumn = ColumnType<number, typeof Operators.number>;
+type NumberColumnData = BaseNumberData & {
+    identity: TableData.Identity;
+};
+type SerialColumnData = NumberColumnData & {
+    default: Expression;
+};
+type NumberMethods = typeof numberTypeMethods;
+interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
+}
+declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
+    data: NumberColumnData;
+    operators: {
+        lt: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        lte: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        gt: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        gte: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        between: ((key: string, value: [number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query], values: unknown[]) => string) & {
+            type: [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: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        not: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        in: ((key: string, value: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
+        };
+        notIn: ((key: string, value: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
+        };
+    };
+}
+declare abstract class IntegerBaseColumn extends NumberBaseColumn {
+    data: NumberColumnData;
+    constructor();
+}
+declare abstract class NumberAsStringBaseColumn extends ColumnType<string, typeof Operators.number> {
+    operators: {
+        lt: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        lte: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        gt: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        gte: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        between: ((key: string, value: [number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query], values: unknown[]) => string) & {
+            type: [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: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        not: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        in: ((key: string, value: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
+        };
+        notIn: ((key: string, value: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
+        };
+    };
+    data: ColumnData;
+}
+declare class DecimalBaseColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends ColumnType<string, typeof Operators.number> {
+    data: ColumnData & {
+        numericPrecision: Precision;
+        numericScale: Scale;
+    };
+    operators: {
+        lt: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        lte: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        gt: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        gte: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        between: ((key: string, value: [number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query], values: unknown[]) => string) & {
+            type: [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: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        not: ((key: string, value: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: number | Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
+        };
+        in: ((key: string, value: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
+        };
+        notIn: ((key: string, value: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[], values: unknown[]) => string) & {
+            type: Expression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | number[];
+        };
+    };
+    dataType: "decimal";
+    constructor(numericPrecision?: Precision, numericScale?: Scale);
+    toCode(t: string): Code;
+    toSQL(): string;
+}
+type IdentityColumn<T extends ColumnTypeBase> = ColumnWithDefault<T, Expression>;
+declare class SmallIntColumn extends IntegerBaseColumn {
+    dataType: "smallint";
+    parseItem: typeof parseInt;
+    toCode(t: string): Code;
+    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+}
+declare class IntegerColumn extends IntegerBaseColumn {
+    dataType: "integer";
+    parseItem: typeof parseInt;
+    toCode(t: string): Code;
+    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+}
+declare class BigIntColumn extends NumberAsStringBaseColumn {
+    dataType: "bigint";
+    toCode(t: string): Code;
+    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+}
+declare class DecimalColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends DecimalBaseColumn<Precision, Scale> {
+}
+declare class RealColumn extends NumberBaseColumn {
+    dataType: "real";
+    parseItem: typeof parseFloat;
+    toCode(t: string): Code;
+}
+declare class DoublePrecisionColumn extends NumberAsStringBaseColumn {
+    dataType: "double precision";
+    toCode(t: string): Code;
+}
+declare class SmallSerialColumn extends IntegerBaseColumn {
+    dataType: "smallint";
+    parseItem: typeof parseInt;
+    data: SerialColumnData;
+    constructor();
+    toSQL(): string;
+    toCode(t: string): Code;
+}
+declare class SerialColumn extends IntegerBaseColumn {
+    dataType: "integer";
+    parseItem: typeof parseInt;
+    data: SerialColumnData;
+    constructor();
+    toSQL(): string;
+    toCode(t: string): Code;
+}
+declare class BigSerialColumn extends NumberAsStringBaseColumn {
+    dataType: "bigint";
+    data: SerialColumnData;
+    toSql(): string;
+    toCode(t: string): Code;
+}
+
+interface DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date>, DateTypeMethods {
+}
+declare abstract class DateBaseColumn extends ColumnType<string, typeof Operators.date, string | number | Date> {
+    data: DateColumnData;
+    operators: {
+        lt: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        lte: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        gt: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        gte: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        between: ((key: string, value: [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], values: unknown[]) => string) & {
+            type: [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: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        not: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        in: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
+        };
+        notIn: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
+        };
+    };
+    encodeFn: (input: string | number | Date) => Date;
+    asNumber(): EncodeColumn<IntegerColumn, string | number | Date>;
+    asDate<T extends ColumnType>(this: T): ParseColumn<T, Date>;
+}
+declare class DateColumn extends DateBaseColumn {
+    dataType: "date";
+    toCode(t: string): Code;
+}
+declare abstract class DateTimeBaseClass<Precision extends number | undefined = undefined> extends DateBaseColumn {
+    data: DateColumnData & {
+        dateTimePrecision: Precision;
+    };
+    constructor(dateTimePrecision?: Precision);
+    toSQL(): string;
+}
+declare abstract class DateTimeTzBaseClass<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
+    abstract baseDataType: string;
+    toSQL(): string;
+}
+declare class TimestampColumn<Precision extends number> extends DateTimeBaseClass<Precision> {
+    dataType: "timestamp";
+    toCode(t: string): Code;
+}
+declare class TimestampTZColumn<Precision extends number> extends DateTimeTzBaseClass<Precision> {
+    dataType: "timestamptz";
+    baseDataType: "timestamp";
+    toCode(t: string): Code;
+}
+declare class TimeColumn<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
+    dataType: "time";
+    toCode(t: string): Code;
+}
+type TimeInterval = {
+    years?: number;
+    months?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
 };
+declare class IntervalColumn<Fields extends string | undefined = undefined, Precision extends number | undefined = undefined> extends ColumnType<TimeInterval, typeof Operators.date> {
+    dataType: "interval";
+    data: ColumnData & {
+        fields: Fields;
+        precision: Precision;
+    };
+    operators: {
+        lt: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        lte: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        gt: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        gte: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        between: ((key: string, value: [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], values: unknown[]) => string) & {
+            type: [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: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        not: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query, values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Date | Query;
+        };
+        in: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
+        };
+        notIn: ((key: string, value: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[], values: unknown[]) => string) & {
+            type: orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query | Date[];
+        };
+    };
+    constructor(fields?: Fields, precision?: Precision);
+    toCode(t: string): Code;
+    toSQL(): string;
+}
 
 type ColumnData = ColumnDataBase & {
     maxChars?: number;
@@ -5350,7 +5544,154 @@ type ColumnFromDbParams = {
     numericScale?: number;
     dateTimePrecision?: number;
 };
-declare const simplifyColumnDefault: (value?: string) => orchid_core.RawExpression<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>> | undefined;
+declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {
+    timestamps<T extends ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T;
+        };
+        timestamp(): T;
+        timestampsSnakeCase(): {
+            createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+        };
+    }): {
+        createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+    };
+    timestampsSnakeCase<T_1 extends ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T_1;
+        };
+        timestamp(): T_1;
+    }): {
+        createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+    };
+    timestampsNoTZ<T_2 extends ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>>(this: {
+        name(name: string): {
+            timestampNoTZ(): T_2;
+        };
+        timestampNoTZ(): T_2;
+        timestampsNoTZSnakeCase(): {
+            createdAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+        };
+    }): {
+        createdAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+    };
+    timestampsNoTZSnakeCase<T_3 extends ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>>(this: {
+        name(name: string): {
+            timestampNoTZ(): T_3;
+        };
+        timestampNoTZ(): T_3;
+    }): {
+        createdAt: orchid_core.ColumnWithDefault<T_3, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_3, orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>>;
+    };
+    name: typeof orchid_core.name;
+    sql: {
+        (sql: TemplateStringsArray, ...values: unknown[]): orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>;
+        (sql: string): orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>;
+        (values: Record<string, unknown>, sql: string): orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>;
+        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, unknown, ColumnDataBase>, {}>;
+    };
+    smallint(): SmallIntColumn;
+    integer(): IntegerColumn;
+    bigint(): BigIntColumn;
+    numeric<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(precision?: Precision | undefined, scale?: Scale | undefined): DecimalColumn<Precision, Scale>;
+    decimal<Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined): DecimalColumn<Precision_1, Scale_1>;
+    real(): RealColumn;
+    doublePrecision(): DoublePrecisionColumn;
+    identity(options?: TableData.Identity | undefined): IdentityColumn<IntegerColumn>;
+    smallSerial(): SmallSerialColumn;
+    serial(): SerialColumn;
+    bigSerial(): BigSerialColumn;
+    money(): MoneyColumn;
+    varchar<Limit extends number | undefined = undefined>(limit?: Limit | undefined): VarCharColumn<Limit>;
+    char<Limit_1 extends number | undefined = undefined>(limit?: Limit_1 | undefined): CharColumn<Limit_1>;
+    text: (min: number, max: number) => TextColumn;
+    string: (min: number, max: number) => TextColumn;
+    citext(min: number, max: number): CitextColumn;
+    bytea(): ByteaColumn;
+    date(): DateColumn;
+    timestampNoTZ<Precision_2 extends number>(precision?: Precision_2 | undefined): TimestampColumn<Precision_2>;
+    timestamp<Precision_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined): TimestampTZColumn<number>;
+    time<Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined): TimeColumn<Precision_4>;
+    interval<Fields extends string | undefined = undefined, Precision_5 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_5 | undefined): IntervalColumn<Fields, Precision_5>;
+    boolean(): BooleanColumn;
+    enum<U extends string, T_4 extends [U, ...U[]]>(dataType: string, type: T_4): EnumColumn<U, T_4>;
+    point(): PointColumn;
+    line(): LineColumn;
+    lseg(): LsegColumn;
+    box(): BoxColumn;
+    path(): PathColumn;
+    polygon(): PolygonColumn;
+    circle(): CircleColumn;
+    cidr(): CidrColumn;
+    inet(): InetColumn;
+    macaddr(): MacAddrColumn;
+    macaddr8(): MacAddr8Column;
+    bit<Length extends number>(length: Length): BitColumn<Length>;
+    bitVarying<Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined): BitVaryingColumn<Length_1>;
+    tsvector(): TsVectorColumn;
+    tsquery(): TsQueryColumn;
+    uuid(): UUIDColumn;
+    xml(): XMLColumn;
+    json<Type extends orchid_core.JSONTypeAny>(schemaOrFn: Type | ((j: {
+        set: <Value extends orchid_core.JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
+        tuple: <T_5 extends [] | orchid_core.JSONTupleItems, Rest extends orchid_core.JSONTypeAny | null = null>(items: T_5, rest?: Rest) => orchid_core.JSONTuple<T_5, Rest>;
+        union: <T_6 extends [orchid_core.JSONTypeAny, orchid_core.JSONTypeAny, ...orchid_core.JSONTypeAny[]]>(types: T_6) => orchid_core.JSONUnion<T_6>;
+        any: () => orchid_core.JSONAny;
+        bigint: () => orchid_core.JSONBigInt;
+        boolean: () => orchid_core.JSONBoolean;
+        date: () => orchid_core.JSONDate;
+        nan: () => orchid_core.JSONNaN;
+        never: () => orchid_core.JSONNever;
+        null: () => orchid_core.JSONNull;
+        number: () => orchid_core.JSONNumber;
+        string: () => orchid_core.JSONString;
+        unknown: () => orchid_core.JSONUnknown;
+        array: <Type_1 extends orchid_core.JSONTypeAny>(element: Type_1) => orchid_core.JSONArray<Type_1, "many">;
+        discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
+        enum: <U_1 extends string, T_7 extends [U_1, ...U_1[]]>(options: T_7) => orchid_core.JSONEnum<U_1, T_7>;
+        instanceOf: <T_8 extends new (...args: any[]) => any>(cls: T_8) => orchid_core.JSONInstanceOf<T_8>;
+        intersection: <Left extends orchid_core.JSONTypeAny, Right extends orchid_core.JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_9 extends orchid_core.JSONTypeAny>(fn: () => T_9) => orchid_core.JSONLazy<T_9>;
+        literal: <T_10 extends orchid_core.Primitive>(value: T_10) => orchid_core.JSONLiteral<T_10>;
+        map: <Key extends orchid_core.JSONTypeAny, Value_1 extends orchid_core.JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
+        nativeEnum: <T_11 extends orchid_core.EnumLike>(givenEnum: T_11) => orchid_core.JSONNativeEnum<T_11>;
+        nullable: <T_12 extends orchid_core.JSONTypeAny>(type: T_12) => orchid_core.JSONNullable<T_12>;
+        nullish: <T_13 extends orchid_core.JSONTypeAny>(type: T_13) => orchid_core.JSONNullish<T_13>;
+        object: <T_14 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_14) => orchid_core.JSONObject<T_14, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_15 extends object ? { [k in keyof T_15]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_18 extends object ? { [k in keyof T_18]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        } extends infer T_16 extends object ? { [k_2 in keyof T_16]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_17 extends object ? { [k in keyof T_17]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        })[k_2]; } : never>;
+        optional: <T_19 extends orchid_core.JSONTypeAny>(type: T_19) => orchid_core.JSONOptional<T_19>;
+        record: typeof orchid_core.record;
+    }) => Type)): JSONColumn<Type>;
+    jsonText(): JSONTextColumn;
+    array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
+    type(dataType: string): CustomTypeColumn;
+    domain(dataType: string): DomainColumn;
+    primaryKey(columns: string[], options?: {
+        name?: string | undefined;
+    } | undefined): {};
+    index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    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?: orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, 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: orchid_core.RawSQLBase<ColumnTypeBase<unknown, BaseOperators, 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> {
     primaryKey<T extends ColumnType>(this: T): PrimaryKeyColumn<T>;
@@ -5403,11 +5744,11 @@ declare abstract class VirtualColumn extends ColumnType<unknown, typeof Operator
         not: ((key: string, value: any, values: unknown[]) => string) & {
             type: any;
         };
-        in: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        in: ((key: string, value: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
-        notIn: ((key: string, value: any[] | orchid_core.RawExpression | Query, values: unknown[]) => string) & {
-            type: any[] | orchid_core.RawExpression | Query;
+        notIn: ((key: string, value: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
+            type: any[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
     toCode(): never;
@@ -5416,6 +5757,7 @@ declare abstract class VirtualColumn extends ColumnType<unknown, typeof Operator
 }
 
 declare class UnknownColumn extends VirtualColumn {
+    static instance: UnknownColumn;
 }
 
 declare const columnsShapeToCode: (shape: ColumnsShapeBase, tableData: TableData, t: string) => Code[];
@@ -5427,14 +5769,12 @@ declare const referencesArgsToCode: ({ columns, fnOrTable, foreignColumns, optio
 declare const columnForeignKeysToCode: (foreignKeys: ForeignKey<string, string[]>[]) => Code[];
 declare const foreignKeyArgumentToCode: (foreignKey: ForeignKey<string, string[]>) => Code[];
 declare const columnIndexesToCode: (indexes: Exclude<ColumnData['indexes'], undefined>) => Code[];
-declare const columnCheckToCode: (t: string, check: RawExpression) => string;
+declare const columnCheckToCode: (t: string, check: RawSQLBase) => string;
 declare const identityToCode: (identity: TableData.Identity, dataType?: string) => Code[];
 declare const columnCode: (type: ColumnType, t: string, code: Code, data?: ColumnData, skip?: Record<'encodeFn', unknown>) => Code;
 
 declare const columnsByType: Record<string, new (...args: never[]) => ColumnType>;
 
-declare const getRaw: (raw: RawExpression, valuesArray: unknown[]) => string;
-
 type Value = any;
 declare const quote: (value: Value) => string;
 declare const quoteString: (value: string) => string;
@@ -5488,4 +5828,4 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingArgs, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, JSONTypes, 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, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SerialColumn, SerialColumnData, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, StringExpression, 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, Window, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getRaw, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, joinSubQuery, jsonTypes, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, setQueryObjectValue, simplifyColumnDefault, testTransaction, throwIfNoWhere, toSql, toSqlCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOfType, ExpressionOutput, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingArgs, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, JSONTypes, 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, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOrExpression, SerialColumn, SerialColumnData, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, StringExpression, 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, Window, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, joinSubQuery, jsonTypes, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, setQueryObjectValue, simplifyColumnDefault, testTransaction, throwIfNoWhere, toSql, toSqlCacheKey };