pqb 0.15.0 → 0.15.2

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, arrayMethods, JSONTypeAny, record, BaseStringData, PrimaryKeyColumn, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, ColumnWithDefault, numberTypeMethods, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ValidationContext, MessageParam, 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>;
@@ -3383,7 +3725,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 +3972,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> {
     /**
@@ -4587,6 +4930,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 +5180,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 +5196,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 +5362,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;
@@ -5096,6 +5468,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;
@@ -5313,6 +5689,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 +5723,7 @@ type IndexColumnOptions = ({
     collate?: string;
     opclass?: string;
     order?: string;
+    weight?: SearchWeight;
 };
 type IndexOptions = {
     name?: string;
@@ -5357,6 +5735,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 +5755,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 +5768,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 +5777,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 +5790,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;
@@ -5502,18 +5883,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 +5908,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;
@@ -5542,6 +5972,22 @@ declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = Ba
     superRefine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
         type: RefinedOutput;
     };
+    /**
+     * 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 const cloneInstance: <T>(instance: T) => T;
@@ -5643,4 +6089,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, 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, 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, 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, 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 };