pqb 0.15.1 → 0.16.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, SQLQueryArgs, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, Expression, ColumnTypeBase, MaybeArray, TemplateLiteralArgs, ColumnsParsers, getValueKey, StringKey, NullableColumn, EmptyTuple, SetOptional, MergeObjects, RawSQLBase, RawSQLValues, RawSQLArgs, Spread, ColumnOperatorBase, ColumnOperatorFnBase, Code, ArrayMethodsData, arrayMethods, JSONTypeAny, record, BaseStringData, PrimaryKeyColumn, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, ColumnWithDefault, numberTypeMethods, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ColumnDataBase, ValidationContext, MessageParam } from 'orchid-core';
+import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, SQLQueryArgs, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, Expression, ColumnTypeBase, MaybeArray, TemplateLiteralArgs, ColumnsParsers, getValueKey, StringKey, NullableColumn, EmptyTuple, SetOptional, MergeObjects, RawSQLBase, RawSQLValues, RawSQLArgs, Spread, ColumnOperatorBase, ColumnOperatorFnBase, Code, ArrayMethodsData, arrayTypeMethods, JSONType, JSONUnknown, JSONTypes, StringTypeData, PrimaryKeyColumn, stringTypeMethods, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, NumberTypeMethods, ColumnWithDefault, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ValidationContext, ErrorMessage, ColumnDataBase } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -123,6 +123,7 @@ type DbTableOptions = {
     autoPreparedStatements?: boolean;
     noPrimaryKey?: NoPrimaryKeyOption;
     snakeCase?: boolean;
+    language?: string;
 } & QueryLogOptions;
 declare const anyShape: Record<string, ColumnType<unknown, 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<CT> {
@@ -403,6 +404,38 @@ type JsonItem<As extends string = string, Type extends ColumnTypeBase = ColumnTy
 type SelectItem = string | RelationQuery | {
     selectAs: Record<string, string | Query | Expression>;
 } | JsonItem | Expression;
+type OrderTsQueryConfig = true | {
+    coverDensity?: boolean;
+    weights?: number[];
+    normalization?: number;
+    dir?: SortDir;
+};
+type QuerySourceItem = {
+    queryAs: string;
+    as?: string;
+    textSQL?: MaybeArray<string>;
+    langSQL?: string;
+    vectorSQL?: string;
+    order?: OrderTsQueryConfig;
+} & ({
+    language?: string;
+} | {
+    languageColumn: string;
+}) & ({
+    text: string | Expression;
+} | {
+    in: MaybeArray<string> | Record<string, SearchWeight>;
+} | {
+    vector: string;
+}) & ({
+    query: string | Expression;
+} | {
+    plainQuery: string | Expression;
+} | {
+    phraseQuery: string | Expression;
+} | {
+    tsQuery: string | Expression;
+});
 type JoinItem = SimpleJoinItem | JoinLateralItem;
 type SimpleJoinItem = {
     type: string;
@@ -429,6 +462,7 @@ type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query |
     IN?: MaybeArray<WhereInItem>;
     EXISTS?: MaybeArray<SimpleJoinItem['args']>;
     ON?: WhereOnItem | WhereJsonPathEqualsItem;
+    SEARCH?: MaybeArray<WhereSearchItem>;
 }) | ((q: unknown) => QueryBase) | Query | Expression;
 type WhereInItem = {
     columns: string[];
@@ -451,6 +485,11 @@ type WhereOnJoinItem = {
         as?: string;
     };
 } | string;
+type SearchWeight = 'A' | 'B' | 'C' | 'D';
+type WhereSearchItem = {
+    as: string;
+    vectorSQL: string;
+};
 type SortDir = 'ASC' | 'DESC' | 'ASC NULLS FIRST' | 'DESC NULLS LAST';
 type OrderItem = string | Record<string, SortDir> | Expression;
 type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
@@ -494,6 +533,7 @@ type CommonQueryData = {
     select?: SelectItem[];
     as?: string;
     from?: string | Query | Expression;
+    sources?: Record<string, QuerySourceItem>;
     and?: WhereItem[];
     or?: WhereItem[][];
     coalesceValue?: unknown | Expression;
@@ -519,6 +559,7 @@ type CommonQueryData = {
     autoPreparedStatements?: boolean;
     [toSqlCacheKey]?: Sql;
     transform?: ((input: unknown) => unknown)[];
+    language?: string;
 };
 type SelectQueryData = CommonQueryData & {
     type: undefined;
@@ -665,16 +706,19 @@ declare class FnExpression<Q extends Query, T extends ColumnTypeBase> extends Ex
     })[];
     options: AggregateOptions<Q>;
     _type: T;
+    _mods: unknown[];
     constructor(q: Q, fn: string, args: (SelectableOrExpression<Q> | {
         pairs: Record<string, SelectableOrExpression<Q>>;
     } | {
         value: unknown;
     })[], options: AggregateOptions<Q>, _type: T);
+    modifySQL(sql: string, ctx: ToSqlCtx, quotedAs?: string): string;
     toSQL(ctx: ToSqlCtx, quotedAs?: string): string;
 }
 type ColumnExpression<C extends ColumnTypeBase, Ops extends BaseOperators = C['operators']> = Expression<C> & {
     [K in keyof Ops]: (arg: Parameters<Ops[K]>[1]) => ColumnExpression<BooleanNullable>;
 };
+declare const makeColumnFnClass: <T extends ColumnType<unknown, BaseOperators, unknown>>(column: T) => typeof FnExpression;
 type FnExpressionArg<Q extends Query> = SelectableOrExpression<Q> | {
     pairs: Record<string, SelectableOrExpression<Q>>;
 } | {
@@ -691,7 +735,6 @@ type NullableJSONObject<T extends Query, Obj extends Record<string, SelectableOr
 }>>;
 type NullableText = NullableColumn<TextColumn>;
 declare class SelectAggMethods<T extends Query = Query> {
-    _qbFor: Query;
     /**
      * `fn` allows to call an arbitrary SQL function.
      *
@@ -1464,16 +1507,315 @@ declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBas
     _onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
 }
 
-type WhereArg<T extends QueryBase> = (Omit<{
-    [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<{
+declare module './aggregate' {
+    interface SelectAggMethods<T extends Query> {
+        /**
+         * Give the `as` alias for the search, and it becomes possible to select a text with highlights of the matching words or phrases:
+         *
+         * ```ts
+         * db.table
+         *   .search({
+         *     as: 'search',
+         *     in: 'body',
+         *     query: 'query',
+         *   })
+         *   .select({
+         *     highlightedText: (q) => q.headline('search'),
+         *   });
+         * ```
+         *
+         * When searching in the generated `tsvector` column, need to provide a text source to the `headline`:
+         *
+         * ```ts
+         * db.table
+         *   .search({
+         *     as: 'search',
+         *     vector: 'textVector',
+         *     query: 'query',
+         *   })
+         *   .select({
+         *     // `body` is a column name
+         *     highlightedText: (q) => q.headline('search', { text: 'body' }),
+         *   });
+         * ```
+         *
+         * `text` can be a raw SQL, here we are joining multiple columns:
+         *
+         * ```ts
+         * import { raw } from 'orchid-orm';
+         *
+         * db.table
+         *   .search({
+         *     as: 'search',
+         *     vector: 'titleAndBodyVector',
+         *     query: 'query',
+         *   })
+         *   .select({
+         *     highlightedText: (q) =>
+         *       q.headline('search', { text: raw`concat_ws(' ', title, body)` }),
+         *   });
+         * ```
+         *
+         * `headline` supports a string for `options`, see details [in Postgres doc](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-HEADLINE).
+         *
+         * Provide a simple string or a raw SQL:
+         *
+         * ```ts
+         * db.table
+         *   .search({
+         *     as: 'search',
+         *     in: 'body',
+         *     query: 'query',
+         *   })
+         *   .select({
+         *     highlightedText: (q) =>
+         *       q.headline('search', {
+         *         options:
+         *           'MaxFragments=10, MaxWords=7, MinWords=3, StartSel=<<, StopSel=>>',
+         *       }),
+         *   });
+         * ```
+         *
+         * @param search - name of the search to use the query from
+         * @param options - `text` for a text source, `options` for `ts_headline` options
+         */
+        headline(search: string | undefined extends T['meta']['tsQuery'] ? never : Exclude<T['meta']['tsQuery'], undefined>, options?: {
+            text?: SelectableOrExpressionOfType<T, TextColumn>;
+            options?: string | Expression;
+        }): ColumnExpression<TextColumn>;
+    }
+}
+type SearchArg<T extends QueryBase, As extends string> = {
+    as?: As;
+    order?: OrderTsQueryConfig;
+} & ({
+    language?: string | Expression;
+} | {
+    languageColumn?: keyof T['selectable'];
+}) & ({
+    text: string | Expression;
+} | {
+    in: MaybeArray<keyof T['selectable']> | {
+        [K in keyof T['selectable']]?: SearchWeight;
+    };
+} | {
+    vector: {
+        [K in keyof T['selectable']]: T['selectable'][K]['column']['dataType'] extends 'tsvector' ? K : never;
+    }[keyof T['selectable']];
+}) & ({
+    query: string | Expression;
+} | {
+    plainQuery: string | Expression;
+} | {
+    phraseQuery: string | Expression;
+} | {
+    tsQuery: string | Expression;
+});
+type WhereSearchResult<T extends QueryBase, As extends string> = T & {
+    meta: {
+        tsQuery: string extends As ? never : As;
+    };
+};
+declare const saveSearchAlias: (q: QueryBase, as: string) => string;
+declare class SearchMethods {
+    /**
+     * ## language
+     *
+     * By default, the search language is English.
+     *
+     * You can set a different default language in the `createBaseTable` config:
+     *
+     * ```ts
+     * import { createBaseTable } from 'orchid-orm';
+     *
+     * export const BaseTable = createBaseTable({
+     *   language: 'swedish',
+     * });
+     * ```
+     *
+     * See the list of supported language configs with the SQL:
+     *
+     * ```sql
+     * SELECT cfgname FROM pg_ts_config;
+     * ```
+     *
+     * When performing a search, you can override the default language:
+     *
+     * ```ts
+     * db.table.search({
+     *   language: 'finnish',
+     *   in: 'body',
+     *   query: 'query',
+     * });
+     * ```
+     *
+     * `language` also accepts a raw SQL.
+     *
+     * The language can be stored in the column of this table, then you can use `languageColumn` to use this column for the search:
+     *
+     * ```ts
+     * db.table.search({
+     *   // the table has `lang` column, use it for the search
+     *   languageColumn: 'lang',
+     *   in: 'body',
+     *   query: 'query',
+     * });
+     * ```
+     *
+     * ## text vector to search in
+     *
+     * The text to search in can be a simple string, or a raw SQL, or a text column, or multiple columns:
+     *
+     * ```ts
+     * db.table.search({
+     *   // search in the given string
+     *   text: 'simply a string to search in',
+     *   query: 'query',
+     * });
+     *
+     * import { raw } from 'orchid-orm';
+     *
+     * db.table.search({
+     *   // raw SQL: join text columns with space
+     *   text: raw`concat_ws(' ', title, body)`,
+     *   query: 'query',
+     * });
+     *
+     * db.table.search({
+     *   // search in a single text column
+     *   in: 'body',
+     *   query: 'query',
+     * });
+     *
+     * db.table.search({
+     *   // search in multiple columns, they are concatenated with `concat_ws` as shown above
+     *   in: ['title', 'body'],
+     *   query: 'query',
+     * });
+     *
+     * db.table.search({
+     *   // search in multiple columns with different weights. Weight can be A, B, C, or D
+     *   in: {
+     *     title: 'A',
+     *     body: 'B',
+     *   },
+     *   query: 'query',
+     * });
+     * ```
+     *
+     * For better performance, define a [generated](/guide/migration-column-methods.html#generated) column of `tsvector` type, and use it in the search with `vector` keyword:
+     *
+     * ```ts
+     * db.table.search({
+     *   vector: 'titleAndBodyVector',
+     *   query: 'query',
+     * });
+     * ```
+     *
+     * ## search query
+     *
+     * Read about different search queries in [this Postgres doc](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES).
+     *
+     * `search` method can accept one of the following queries:
+     *
+     * - `query`: corresponds to `websearch_to_tsquery` in Postgres, good to use by default
+     * - `plainQuery`: corresponds to `plainto_tsquery`
+     * - `phraseQuery`: corresponds to `phraseto_tsquery`
+     * - `tsQuery`: corresponds to `to_tsquery`
+     *
+     * The `query` (`websearch_to_tsquery`) can work with any user input, while other query kinds require a specific format and will fail for invalid input.
+     *
+     * Each query kind accepts a string or a raw SQL.
+     *
+     * ```ts
+     * import { raw } from 'orchid-orm';
+     *
+     * db.table.search({
+     *   vector: 'titleAndBodyVector',
+     *   // can accept raw SQL:
+     *   phraseQuery: raw`'The Fat Rats'`,
+     * });
+     * ```
+     *
+     * ## order by search rank
+     *
+     * Read about search ranking in [this Postgres doc](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-RANKING).
+     *
+     * Set `order: true` to order results by the search rank:
+     *
+     * ```ts
+     * db.table.search({
+     *   in: 'body',
+     *   query: 'query',
+     *   // will add ORDER BY ts_rank(to_tsvector('english', body)) DESC
+     *   order: true,
+     * });
+     * ```
+     *
+     * To order with `ts_rank_cd` instead of `ts_rank`, set `coverDensity: true`:
+     *
+     * ```ts
+     * db.table.search({
+     *   in: 'body',
+     *   query: 'query',
+     *   // will add ORDER BY ts_rank_cd(to_tsvector('english', body)) DESC
+     *   order: {
+     *     coverDensity: true,
+     *   },
+     * });
+     * ```
+     *
+     * Other options are:
+     *
+     * ```ts
+     * db.table.search({
+     *   in: 'body',
+     *   query: 'query',
+     *   order: {
+     *     // weights for D, C, B, A:
+     *     weights: [0.1, 0.2, 0.4, 1],
+     *     // by default, rank ignores the document length
+     *     // change rank behavior by providing here a special number
+     *     normalization: 32,
+     *     // it's possible to change the order direction:
+     *     dir: 'ASC', // DESC by default
+     *   },
+     * });
+     * ```
+     *
+     * Giving the `as` alias for the search allows to set the ordering in the `order` method:
+     *
+     * ```ts
+     * db.table
+     *   .search({
+     *     as: 'search',
+     *     in: 'body',
+     *     query: 'query',
+     *   })
+     *   .order({
+     *     // can be `search: true` for defaults
+     *     search: {
+     *       // same options as above
+     *       coverDensity: true,
+     *       weights: [0.1, 0.2, 0.4, 1.0],
+     *       normalization: 32,
+     *       dir: 'ASC',
+     *     },
+     *   });
+     * ```
+     *
+     * @param arg - search config
+     */
+    search<T extends Query, As extends string>(this: T, arg: SearchArg<T, As>): WhereSearchResult<T, As>;
+    _search<T extends Query, As extends string>(this: T, arg: SearchArg<T, As>): WhereSearchResult<T, As>;
+}
+
+type WhereArg<T extends QueryBase> = {
+    [K in keyof T['selectable'] | 'NOT' | 'OR' | 'IN' | 'EXISTS' | 'SEARCH']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
         columns: (keyof T['selectable'])[];
         values: unknown[][] | Query | Expression;
-    }>;
-}) | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
+    }> : K extends 'SEARCH' ? MaybeArray<SearchArg<T, never>> : K extends keyof T['selectable'] ? T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | Expression : never;
+} | 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 | Expression : ({
@@ -1491,7 +1833,7 @@ type WhereResult<T extends QueryBase> = T & {
 type WhereInArg<T extends Pick<Query, 'selectable'>> = {
     [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 addWhere: <T extends QueryBase>(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>;
@@ -3342,39 +3684,24 @@ declare const raw: <T = unknown>(...args: RawSQLArgs) => RawSQL<ColumnTypeBase<T
     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;
+    json<Type extends orchid_core.JSONType<unknown, {}> = orchid_core.JSONUnknown>(schemaOrFn?: Type | ((j: {
+        unknown: () => orchid_core.JSONUnknown;
         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>;
+        array: <T_6 extends orchid_core.JSONType<unknown, {}>>(item: T_6) => orchid_core.JSONArray<T_6, "many">;
+        object: <Shape extends orchid_core.JSONObjectShape>(shape: Shape) => orchid_core.JSONObject<Shape, "strip", orchid_core.JSONType<unknown, {}>>;
+        literal: <T_7 extends orchid_core.JSONPrimitive>(value: T_7) => orchid_core.JSONLiteral<T_7>;
+        discriminatedUnion: <Discriminator extends string, Types extends orchid_core.JSONDiscriminatedUnionArg<Discriminator>>(discriminator: Discriminator, types: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, Types>;
+        enum: <U_1 extends string, T_8 extends [U_1, ...U_1[]]>(options: T_8) => orchid_core.JSONEnum<string, T_8>;
+        intersection: <Left extends orchid_core.JSONType<unknown, {}>, Right extends orchid_core.JSONType<unknown, {}>>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_9 extends orchid_core.JSONType<unknown, {}>>(fn: () => T_9) => orchid_core.JSONLazy<T_9>;
+        nativeEnum: <T_10 extends orchid_core.EnumLike>(type: T_10) => orchid_core.JSONNativeEnum<T_10>;
+        record: <Key extends orchid_core.JSONNumber | orchid_core.JSONString, Value extends orchid_core.JSONType<unknown, {}>>(...args: [value: Value] | [key: Key, value: Value]) => orchid_core.JSONRecord<Key, Value>;
+        tuple: <T_11 extends orchid_core.JSONTupleItems, Rest extends orchid_core.JSONType<unknown, {}> | undefined = undefined>(items: T_11, rest?: Rest | undefined) => orchid_core.JSONTuple<T_11, Rest>;
+        union: <T_12 extends orchid_core.JSONUnionArgs>(...types: T_12) => orchid_core.JSONUnion<T_12>;
+    }) => Type) | undefined): JSONColumn<Type>;
     jsonText(): JSONTextColumn;
     array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
     type(dataType: string): CustomTypeColumn;
@@ -3383,7 +3710,8 @@ declare const raw: <T = unknown>(...args: RawSQLArgs) => RawSQL<ColumnTypeBase<T
         name?: string | undefined;
     } | undefined): {};
     index(columns: orchid_core.MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
-    unique(columns: orchid_core.MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    unique(columns: orchid_core.MaybeArray<string | IndexColumnOptions>, options?: IndexOptions | undefined): {};
+    searchIndex(columns: orchid_core.MaybeArray<string | IndexColumnOptions>, options?: IndexOptions | undefined): {};
     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;
@@ -3629,17 +3957,17 @@ type WindowArgDeclaration<T extends Query = Query> = {
 type WindowResult<T extends Query, W extends WindowArg<T>> = T & {
     windows: Record<keyof W, true>;
 };
-type OrderArg<T extends Query, Key extends PropertyKey = keyof T['selectable'] | {
+type OrderArg<T extends Query, TsQuery extends PropertyKey = string | undefined extends T['meta']['tsQuery'] ? never : Exclude<T['meta']['tsQuery'], undefined>, 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;
+}[keyof T['result']] | TsQuery> = Key | {
+    [K in Key]?: K extends TsQuery ? OrderTsQueryConfig : SortDir;
 } | Expression;
 type OrderArgs<T extends Query> = OrderArg<T>[] | TemplateLiteralArgs;
 type FindArgs<T extends Query> = [T['shape'][T['singlePrimaryKey']]['type'] | Expression] | TemplateLiteralArgs;
 type 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<CT extends ColumnTypesBase> extends Omit<AsMethods, 'result'>, AggregateMethods, Select, From, Join, With, Union, Omit<JsonModifiers, 'result'>, JsonMethods, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Omit<Where, 'result'>, Clear, Having, Then, QueryLog, Omit<QueryHooks, 'result'>, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<CT>, CopyMethods, TransformMethods {
+interface QueryMethods<CT extends ColumnTypesBase> extends Omit<AsMethods, 'result'>, AggregateMethods, Select, From, Join, With, Union, Omit<JsonModifiers, 'result'>, JsonMethods, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Omit<Where, 'result'>, SearchMethods, Clear, Having, Then, QueryLog, Omit<QueryHooks, 'result'>, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<CT>, CopyMethods, TransformMethods {
 }
 declare class QueryMethods<CT extends ColumnTypesBase> {
     /**
@@ -4235,7 +4563,7 @@ declare class DomainColumn extends CustomTypeColumn {
 type ArrayData<Item extends ColumnTypeBase> = ColumnData & ArrayMethodsData & {
     item: Item;
 };
-type ArrayMethods = typeof arrayMethods;
+type ArrayMethods = typeof arrayTypeMethods;
 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> {
@@ -4255,41 +4583,7 @@ declare class ArrayColumn<Item extends ColumnTypeBase> extends ColumnType<Item['
     };
 }
 
-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;
-};
-declare class JSONColumn<Type extends JSONTypeAny = JSONTypeAny> extends ColumnType<Type['type'], typeof Operators.json> {
+declare class JSONColumn<Type extends JSONType = JSONUnknown> extends ColumnType<Type['type'], typeof Operators.json> {
     dataType: "jsonb";
     operators: {
         jsonPath: Operator<[path: string, op: string, value: unknown]>;
@@ -4355,205 +4649,8 @@ declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean
 type BooleanNullable = NullableColumn<BooleanColumn>;
 
 type StringColumn = ColumnType<string, typeof Operators.text>;
-type TextColumnData = BaseStringData;
-type TextMethods = typeof textMethods;
-declare const textMethods: {
-    email<T extends {
-        data: {
-            email?: boolean | undefined;
-        };
-    }>(this: T, params?: orchid_core.MessageParam | undefined): Omit<T, "data"> & {
-        data: Omit<T["data"], "email"> & {
-            email: boolean;
-        };
-    };
-    url<T_1 extends {
-        data: {
-            url?: boolean | undefined;
-        };
-    }>(this: T_1, params?: orchid_core.MessageParam | undefined): Omit<T_1, "data"> & {
-        data: Omit<T_1["data"], "url"> & {
-            url: boolean;
-        };
-    };
-    emoji<T_2 extends {
-        data: {
-            emoji?: boolean | undefined;
-        };
-    }>(this: T_2, params?: orchid_core.MessageParam | undefined): Omit<T_2, "data"> & {
-        data: Omit<T_2["data"], "emoji"> & {
-            emoji: boolean;
-        };
-    };
-    uuid<T_3 extends {
-        data: {
-            uuid?: boolean | undefined;
-        };
-    }>(this: T_3, params?: orchid_core.MessageParam | undefined): Omit<T_3, "data"> & {
-        data: Omit<T_3["data"], "uuid"> & {
-            uuid: boolean;
-        };
-    };
-    cuid<T_4 extends {
-        data: {
-            cuid?: boolean | undefined;
-        };
-    }>(this: T_4, params?: orchid_core.MessageParam | undefined): Omit<T_4, "data"> & {
-        data: Omit<T_4["data"], "cuid"> & {
-            cuid: boolean;
-        };
-    };
-    cuid2<T_5 extends {
-        data: {
-            cuid2?: boolean | undefined;
-        };
-    }>(this: T_5, params?: orchid_core.MessageParam | undefined): Omit<T_5, "data"> & {
-        data: Omit<T_5["data"], "cuid2"> & {
-            cuid2: boolean;
-        };
-    };
-    ulid<T_6 extends {
-        data: {
-            ulid?: boolean | undefined;
-        };
-    }>(this: T_6, params?: orchid_core.MessageParam | undefined): Omit<T_6, "data"> & {
-        data: Omit<T_6["data"], "ulid"> & {
-            ulid: boolean;
-        };
-    };
-    regex<T_7 extends {
-        data: {
-            regex?: RegExp | undefined;
-        };
-    }, Value extends RegExp>(this: T_7, value: Value, params?: orchid_core.MessageParam | undefined): Omit<T_7, "data"> & {
-        data: Omit<T_7["data"], "regex"> & {
-            regex: Value;
-        };
-    };
-    includes<T_8 extends {
-        data: {
-            includes?: string | undefined;
-        };
-    }, Value_1 extends string>(this: T_8, value: Value_1, params?: orchid_core.MessageParam | undefined): Omit<T_8, "data"> & {
-        data: Omit<T_8["data"], "includes"> & {
-            includes: Value_1;
-        };
-    };
-    startsWith<T_9 extends {
-        data: {
-            startsWith?: string | undefined;
-        };
-    }, Value_2 extends string>(this: T_9, value: Value_2, params?: orchid_core.MessageParam | undefined): Omit<T_9, "data"> & {
-        data: Omit<T_9["data"], "startsWith"> & {
-            startsWith: Value_2;
-        };
-    };
-    endsWith<T_10 extends {
-        data: {
-            endsWith?: string | undefined;
-        };
-    }, Value_3 extends string>(this: T_10, value: Value_3, params?: orchid_core.MessageParam | undefined): Omit<T_10, "data"> & {
-        data: Omit<T_10["data"], "endsWith"> & {
-            endsWith: Value_3;
-        };
-    };
-    datetime<T_11 extends {
-        data: {
-            datetime?: {
-                offset?: boolean | undefined;
-                precision?: number | undefined;
-            } | undefined;
-        };
-    }>(this: T_11, params?: {
-        offset?: boolean | undefined;
-        precision?: number | undefined;
-    } & {
-        message?: string | undefined;
-    }): Omit<T_11, "data"> & {
-        data: Omit<T_11["data"], "datetime"> & {
-            datetime: {
-                offset?: boolean | undefined;
-                precision?: number | undefined;
-            } & {
-                message?: string | undefined;
-            };
-        };
-    };
-    ip<T_12 extends {
-        data: {
-            ip?: {
-                version?: "v4" | "v6" | undefined;
-            } | undefined;
-        };
-    }>(this: T_12, params?: {
-        version?: "v4" | "v6" | undefined;
-    } & {
-        message?: string | undefined;
-    }): Omit<T_12, "data"> & {
-        data: Omit<T_12["data"], "ip"> & {
-            ip: {
-                version?: "v4" | "v6" | undefined;
-            } & {
-                message?: string | undefined;
-            };
-        };
-    };
-    trim<T_13 extends {
-        data: {
-            trim?: boolean | undefined;
-        };
-    }>(this: T_13, params?: orchid_core.MessageParam | undefined): Omit<T_13, "data"> & {
-        data: Omit<T_13["data"], "trim"> & {
-            trim: boolean;
-        };
-    };
-    toLowerCase<T_14 extends {
-        data: {
-            toLowerCase?: boolean | undefined;
-        };
-    }>(this: T_14, params?: orchid_core.MessageParam | undefined): Omit<T_14, "data"> & {
-        data: Omit<T_14["data"], "toLowerCase"> & {
-            toLowerCase: boolean;
-        };
-    };
-    toUpperCase<T_15 extends {
-        data: {
-            toUpperCase?: boolean | undefined;
-        };
-    }>(this: T_15, params?: orchid_core.MessageParam | undefined): Omit<T_15, "data"> & {
-        data: Omit<T_15["data"], "toUpperCase"> & {
-            toUpperCase: boolean;
-        };
-    };
-    min: <T_16 extends {
-        data: {
-            min?: number | undefined;
-        };
-    }, Value_4 extends number>(this: T_16, value: Value_4, params?: orchid_core.MessageParam | undefined) => Omit<T_16, "data"> & {
-        data: Omit<T_16["data"], "min"> & {
-            min: Value_4;
-        };
-    };
-    max: <T_17 extends {
-        data: {
-            max?: number | undefined;
-        };
-    }, Value_5 extends number>(this: T_17, value: Value_5, params?: orchid_core.MessageParam | undefined) => Omit<T_17, "data"> & {
-        data: Omit<T_17["data"], "max"> & {
-            max: Value_5;
-        };
-    };
-    length: <T_18 extends {
-        data: {
-            length?: number | undefined;
-        };
-    }, Value_6 extends number>(this: T_18, value: Value_6, params?: orchid_core.MessageParam | undefined) => Omit<T_18, "data"> & {
-        data: Omit<T_18["data"], "length"> & {
-            length: Value_6;
-        };
-    };
-    nonEmpty: <T_19 extends orchid_core.NonEmptyBase>(this: T_19, params?: orchid_core.MessageParam | undefined) => orchid_core.NonEmptyResult<T_19>;
-};
+type TextColumnData = StringTypeData;
+type TextMethods = typeof stringTypeMethods;
 interface TextBaseColumn extends ColumnType<string, typeof Operators.text>, TextMethods {
 }
 declare abstract class TextBaseColumn extends ColumnType<string, typeof Operators.text> {
@@ -4587,6 +4684,7 @@ declare class CharColumn<Limit extends number | undefined = undefined> extends L
     toCode(t: string): Code;
 }
 declare class TextColumn extends TextBaseColumn {
+    static instance: TextColumn;
     dataType: "text";
     data: TextColumnData & {
         minArg?: number;
@@ -4836,7 +4934,9 @@ declare class BitVaryingColumn<Length extends number | undefined = undefined> ex
     toCode(t: string): Code;
     toSQL(): string;
 }
+type TsVectorGeneratedColumns = string[] | Record<string, SearchWeight>;
 declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
+    defaultLanguage: string;
     dataType: "tsvector";
     operators: {
         contains: Operator<string | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
@@ -4850,7 +4950,33 @@ declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
         in: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
         notIn: Operator<string[] | orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query>;
     };
+    constructor(defaultLanguage?: string);
     toCode(t: string): Code;
+    /**
+     * For `tsvector` column type, it can also accept language (optional) and columns:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('post', (t) => ({
+     *     id: t.id(),
+     *     title: t.text(),
+     *     body: t.text(),
+     *     // join title and body into a single ts_vector
+     *     generatedTsVector: t.tsvector().generated(['title', 'body']).searchIndex(),
+     *     // with language:
+     *     spanishTsVector: t
+     *       .tsvector()
+     *       .generated('spanish', ['title', 'body'])
+     *       .searchIndex(),
+     *   }));
+     * });
+     * ```
+     *
+     * @param args
+     */
+    generated<T extends ColumnType>(this: T, ...args: RawSQLArgs | [language: string, columns: TsVectorGeneratedColumns] | [columns: TsVectorGeneratedColumns]): T;
 }
 declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "tsquery";
@@ -4990,7 +5116,7 @@ declare const getConstraintKind: (it: TableData.Constraint) => 'constraint' | 'f
 declare const newTableData: () => TableData;
 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 const getColumnTypes: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>, Shape extends ColumnsShape>(types: CT, fn: (t: CT) => Shape, nowSQL: string | undefined, language: string | undefined, data?: TableData) => Shape;
 declare function text(min: number, max: number): TextColumn;
 declare function sql(sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase;
 declare function sql(sql: string): RawSQLBase;
@@ -5086,7 +5212,7 @@ declare const columnTypes: {
     tsquery(): TsQueryColumn;
     uuid(): UUIDColumn;
     xml(): XMLColumn;
-    json<Type extends JSONTypeAny>(schemaOrFn: Type | ((j: JSONTypes) => Type)): JSONColumn<Type>;
+    json<Type extends JSONType<unknown, {}> = JSONUnknown>(schemaOrFn?: Type | ((j: JSONTypes) => Type) | undefined): JSONColumn<Type>;
     jsonText(): JSONTextColumn;
     array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
     type(dataType: string): CustomTypeColumn;
@@ -5096,6 +5222,10 @@ declare const columnTypes: {
     }): {};
     index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
     unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    /**
+     * See {@link ColumnType.searchIndex}
+     */
+    searchIndex(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;
@@ -5116,8 +5246,7 @@ type NumberColumnData = BaseNumberData & {
 type SerialColumnData = NumberColumnData & {
     default: Expression;
 };
-type NumberMethods = typeof numberTypeMethods;
-interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
+interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberTypeMethods {
 }
 declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
     data: NumberColumnData;
@@ -5313,6 +5442,7 @@ type ColumnData = ColumnDataBase & {
     compression?: string;
     foreignKeys?: ForeignKey<string, string[]>[];
     identity?: TableData.Identity;
+    generated?: RawSQLBase;
 };
 type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
 type ForeignKeyAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
@@ -5346,6 +5476,7 @@ type IndexColumnOptions = ({
     collate?: string;
     opclass?: string;
     order?: string;
+    weight?: SearchWeight;
 };
 type IndexOptions = {
     name?: string;
@@ -5357,6 +5488,9 @@ type IndexOptions = {
     tablespace?: string;
     where?: string;
     dropMode?: 'CASCADE' | 'RESTRICT';
+    language?: string | RawSQLBase;
+    languageColumn?: string;
+    tsVector?: boolean;
 };
 type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
 type ColumnFromDbParams = {
@@ -5374,12 +5508,12 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
         };
         timestamp(): T;
         timestampsSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
     };
     timestampsSnakeCase<T_1 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
         name(name: string): {
@@ -5387,8 +5521,8 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
         };
         timestamp(): T_1;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
     };
     timestampsNoTZ<T_2 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
         name(name: string): {
@@ -5396,12 +5530,12 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
         };
         timestampNoTZ(): T_2;
         timestampsNoTZSnakeCase(): {
-            createdAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-            updatedAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+            createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+            updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
         };
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_2, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
     };
     timestampsNoTZSnakeCase<T_3 extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>>(this: {
         name(name: string): {
@@ -5409,15 +5543,15 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
         };
         timestampNoTZ(): T_3;
     }): {
-        createdAt: orchid_core.ColumnWithDefault<T_3, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
-        updatedAt: orchid_core.ColumnWithDefault<T_3, orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        createdAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_3, RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>>;
     };
     name: typeof orchid_core.name;
     sql: {
-        (sql: TemplateStringsArray, ...values: unknown[]): orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
-        (sql: string): orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
-        (values: Record<string, unknown>, sql: string): orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
-        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => orchid_core.RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
+        (sql: TemplateStringsArray, ...values: unknown[]): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
+        (sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
+        (values: Record<string, unknown>, sql: string): RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
+        (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => RawSQLBase<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>;
     };
     smallint(): SmallIntColumn;
     integer(): IntegerColumn;
@@ -5461,39 +5595,24 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
     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;
+    json<Type extends orchid_core.JSONType<unknown, {}> = orchid_core.JSONUnknown>(schemaOrFn?: Type | ((j: {
+        unknown: () => orchid_core.JSONUnknown;
         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>;
+        array: <T_5 extends orchid_core.JSONType<unknown, {}>>(item: T_5) => orchid_core.JSONArray<T_5, "many">;
+        object: <Shape extends orchid_core.JSONObjectShape>(shape: Shape) => orchid_core.JSONObject<Shape, "strip", orchid_core.JSONType<unknown, {}>>;
+        literal: <T_6 extends orchid_core.JSONPrimitive>(value: T_6) => orchid_core.JSONLiteral<T_6>;
+        discriminatedUnion: <Discriminator extends string, Types extends orchid_core.JSONDiscriminatedUnionArg<Discriminator>>(discriminator: Discriminator, types: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, Types>;
+        enum: <U_1 extends string, T_7 extends [U_1, ...U_1[]]>(options: T_7) => orchid_core.JSONEnum<string, T_7>;
+        intersection: <Left extends orchid_core.JSONType<unknown, {}>, Right extends orchid_core.JSONType<unknown, {}>>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_8 extends orchid_core.JSONType<unknown, {}>>(fn: () => T_8) => orchid_core.JSONLazy<T_8>;
+        nativeEnum: <T_9 extends orchid_core.EnumLike>(type: T_9) => orchid_core.JSONNativeEnum<T_9>;
+        record: <Key extends orchid_core.JSONNumber | orchid_core.JSONString, Value extends orchid_core.JSONType<unknown, {}>>(...args: [value: Value] | [key: Key, value: Value]) => orchid_core.JSONRecord<Key, Value>;
+        tuple: <T_10 extends orchid_core.JSONTupleItems, Rest extends orchid_core.JSONType<unknown, {}> | undefined = undefined>(items: T_10, rest?: Rest | undefined) => orchid_core.JSONTuple<T_10, Rest>;
+        union: <T_11 extends orchid_core.JSONUnionArgs>(...types: T_11) => orchid_core.JSONUnion<T_11>;
+    }) => Type) | undefined): JSONColumn<Type>;
     jsonText(): JSONTextColumn;
     array<Item extends ColumnType<unknown, BaseOperators, unknown>>(item: Item): ArrayColumn<Item>;
     type(dataType: string): CustomTypeColumn;
@@ -5502,18 +5621,19 @@ declare const simplifyColumnDefault: (value?: string) => RawSQL<ColumnTypeBase<u
         name?: string | undefined;
     } | undefined): {};
     index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
-    unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions | undefined): {};
+    searchIndex(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions | undefined): {};
     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, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}> | undefined;
+        check?: RawSQLBase<ColumnTypeBase<unknown, orchid_core.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, orchid_core.BaseOperators, unknown, ColumnDataBase>, {}>): {};
+    check(check: RawSQLBase<ColumnTypeBase<unknown, orchid_core.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> {
@@ -5526,6 +5646,54 @@ declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = Ba
     };
     toSQL(): string;
     index<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column'>): T;
+    /**
+     * `searchIndex` is designed for full text search.
+     *
+     * It can accept the same options as a regular `index`, but it is `USING GIN` by default, and it is concatenating columns into a `tsvector`.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     id: t.identity().primaryKey(),
+     *     title: t.string(),
+     *     body: t.string(),
+     *     ...t.searchIndex(['title', 'body']),
+     *   }));
+     * });
+     * ```
+     *
+     * Produces the following index ('english' is a default language, see [full text search](/guide/text-search.html#language) for changing it):
+     *
+     * ```sql
+     * CREATE INDEX "table_title_body_idx" ON "table" USING GIN (to_tsvector('english', concat_ws(' ', "title", "body")))
+     * ```
+     *
+     * Also, it works well with a generated `tsvector` column:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     id: t.identity().primaryKey(),
+     *     title: t.string(),
+     *     body: t.string(),
+     *     generatedTsVector: t.tsvector().generated(['title', 'body']).searchIndex(),
+     *   }));
+     * });
+     * ```
+     *
+     * Produces the following index:
+     *
+     * ```sql
+     * CREATE INDEX "table_generatedTsVector_idx" ON "table" USING GIN ("generatedTsVector")
+     * ```
+     *
+     * @param options - index options
+     */
+    searchIndex<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'tsVector'>): T;
     unique<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column' | 'unique'>): T;
     comment<T extends ColumnType>(this: T, comment: string): T;
     validationDefault<T extends ColumnType>(this: T, value: T['type']): T;
@@ -5536,26 +5704,28 @@ declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = Ba
         type: Transformed;
     };
     to<T extends ColumnType, ToType extends ColumnType>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
-    refine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown, params?: MessageParam): T & {
+    refine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown, params?: ErrorMessage): T & {
         type: RefinedOutput;
     };
     superRefine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
         type: RefinedOutput;
     };
-}
-
-declare const cloneInstance: <T>(instance: T) => T;
-declare const assignMethodsToClass: <Methods extends Record<string, unknown>>(klass: {
-    prototype: unknown;
-}, methods: Methods) => void;
-
-declare const utils_assignMethodsToClass: typeof assignMethodsToClass;
-declare const utils_cloneInstance: typeof cloneInstance;
-declare namespace utils {
-  export {
-    utils_assignMethodsToClass as assignMethodsToClass,
-    utils_cloneInstance as cloneInstance,
-  };
+    /**
+     * Define a generated column. `generated` accepts a raw SQL.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     two: t.integer().generated`1 + 1`,
+     *   }));
+     * });
+     * ```
+     *
+     * @param args - raw SQL
+     */
+    generated<T extends ColumnType>(this: T, ...args: RawSQLArgs): T;
 }
 
 declare abstract class VirtualColumn extends ColumnType<unknown, typeof Operators.any> {
@@ -5643,4 +5813,4 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseOperators, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanNullable, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArg, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, 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, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, Over, 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, SelectAggMethods, SelectArg, SelectItem, SelectQueryBuilder, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, createOperator, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getSelectQueryBuilder, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, isSelectingCount, joinSubQuery, jsonTypes, logColors, logParamToLogObject, makeColumnFn, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, setQueryObjectValue, simplifyColumnDefault, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSql, toSqlCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseOperators, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanNullable, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArg, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, SearchArg, SearchMethods, SearchWeight, Select, SelectAggMethods, SelectArg, SelectItem, SelectQueryBuilder, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, createOperator, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getSelectQueryBuilder, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnFn, makeColumnFnClass, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, saveSearchAlias, setQueryObjectValue, simplifyColumnDefault, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSql, toSqlCacheKey };