pqb 0.15.2 → 0.16.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, 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 { 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';
@@ -1507,379 +1507,664 @@ declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBas
     _onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
 }
 
-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 & {
+type WhereArg<T extends QueryBase> = {
+    [K in keyof T['selectable'] | 'NOT' | 'OR' | 'IN' | 'EXISTS']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
+        columns: (keyof T['selectable'])[];
+        values: unknown[][] | Query | Expression;
+    }> : K extends keyof T['selectable'] ? T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | Expression | Query : never;
+} | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
+type WhereArgs<T extends QueryBase> = WhereArg<T>[] | TemplateLiteralArgs;
+type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
+type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | Expression : ({
+    [I in keyof Column]: Column[I] extends keyof T['selectable'] ? T['selectable'][Column[I]]['column']['type'] : never;
+} & {
+    length: Column extends {
+        length: number;
+    } ? Column['length'] : never;
+})[] | Query | Expression;
+type WhereInArg<T extends Pick<Query, 'selectable'>> = {
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | Expression;
+};
+type WhereResult<T extends QueryBase> = T & {
     meta: {
-        tsQuery: string extends As ? never : As;
+        hasWhere: true;
     };
 };
-declare const saveSearchAlias: (q: QueryBase, as: string) => string;
-declare class SearchMethods {
+/**
+ * Adds `where` arguments to query data: SQL template string is added as `RawSQL` object, other arguments are added as is.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addWhere: <T extends QueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+/**
+ * Adds `where` arguments to query data with a `NOT` keyword: SQL template string is added as `RawSQL` object, other arguments are added as is.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addWhereNot: <T extends QueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+/**
+ * Adds `where` arguments to query data. Arguments will be separated from each other with `OR`.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addOr: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+/**
+ * Adds `where` arguments to query data with a `NOT` keyword. Arguments will be separated from each other with `OR`.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+/**
+ * Process arguments of `whereIn` to add them to query data properly.
+ *
+ * @param q - query object to add the data to.
+ * @param and - `true` to join arguments with `AND`, `false` to join them with `OR.
+ * @param arg - `whereIn` argument: can be a single column name, tuple of column names, or object with column names and values.
+ * @param values - if the `arg` is a column name or a tuple, `values` are the values for the column/columns. If `arg` is an object, `values` are `undefined`.
+ * @param not - adds the `NOT` keyword.
+ */
+declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
+declare abstract class Where extends QueryBase {
     /**
-     * ## language
+     * Constructing `WHERE` conditions:
      *
-     * By default, the search language is English.
+     * ```ts
+     * db.table.where({
+     *   // column of the current table
+     *   name: 'John',
      *
-     * You can set a different default language in the `createBaseTable` config:
+     *   // table name may be specified, it can be the name of a joined table
+     *   'table.lastName': 'Johnsonuk',
      *
-     * ```ts
-     * import { createBaseTable } from 'orchid-orm';
+     *   // object with operators, see the "column operators" section to see a full list of them:
+     *   age: {
+     *     gt: 30,
+     *     lt: 70,
+     *   },
      *
-     * export const BaseTable = createBaseTable({
-     *   language: 'swedish',
+     *   // where column equals to raw SQL
+     *   column: db.table.sql`raw expression`,
      * });
      * ```
      *
-     * See the list of supported language configs with the SQL:
+     * `undefined` values are ignored, so you can supply a partial object with conditions:
      *
-     * ```sql
-     * SELECT cfgname FROM pg_ts_config;
+     * ```ts
+     * type Params = {
+     *   // allow providing exact age, or lower or greate than
+     *   age?: number | { lt?: number; gt?: number };
+     * };
+     *
+     * const loadRecords = async (params: Params) => {
+     *   // this will load all records if params is an empty object
+     *   const records = await db.table.where(params);
+     * };
      * ```
      *
-     * When performing a search, you can override the default language:
+     * It supports a sub-query that is selecting a single value to compare it with a column:
      *
      * ```ts
-     * db.table.search({
-     *   language: 'finnish',
-     *   in: 'body',
-     *   query: 'query',
+     * db.table.where({
+     *   // compare `someColumn` in one table with the `column` value returned from another query.
+     *   someColumn: db.otherTable.where(...conditions).get('column'),
      * });
      * ```
      *
-     * `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:
+     * `where` can accept other queries and merge their conditions:
      *
      * ```ts
-     * db.table.search({
-     *   // the table has `lang` column, use it for the search
-     *   languageColumn: 'lang',
-     *   in: 'body',
-     *   query: 'query',
-     * });
-     * ```
+     * const otherQuery = db.table.where({ name: 'John' });
      *
-     * ## text vector to search in
+     * db.table.where({ id: 1 }, otherQuery);
+     * // this will produce WHERE "table"."id" = 1 AND "table"."name' = 'John'
+     * ```
      *
-     * The text to search in can be a simple string, or a raw SQL, or a text column, or multiple columns:
+     * `where` supports raw SQL:
      *
      * ```ts
-     * db.table.search({
-     *   // search in the given string
-     *   text: 'simply a string to search in',
-     *   query: 'query',
-     * });
+     * db.table.where`a = b`;
+     *
+     * // or
+     * db.table.where(db.table.sql`a = b`);
      *
+     * // or
      * 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.where(raw`a = b`);
+     * ```
      *
-     * db.table.search({
-     *   // search in a single text column
-     *   in: 'body',
-     *   query: 'query',
-     * });
+     * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `or`, `whereNot`, `whereIn`, `whereExists`:
      *
-     * db.table.search({
-     *   // search in multiple columns, they are concatenated with `concat_ws` as shown above
-     *   in: ['title', 'body'],
-     *   query: 'query',
-     * });
+     * ```ts
+     * db.table.where((q) =>
+     *   q
+     *     .where({ name: 'Name' })
+     *     .or({ id: 1 }, { id: 2 })
+     *     .whereIn('letter', ['a', 'b', 'c'])
+     *     .whereExists(Message, 'authorId', 'id'),
+     * );
+     * ```
      *
-     * 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',
-     * });
+     * `where` can accept multiple arguments, conditions are joined with `AND`:
+     *
+     * ```ts
+     * db.table.where(
+     *   { id: 1 },
+     *   db.table.where({ name: 'John' }),
+     *   db.table.sql`a = b`,
+     * );
      * ```
      *
-     * 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:
+     * ### where special keys
+     *
+     * The object passed to `where` can contain special keys, each of the keys corresponds to its own method and takes the same value as the type of argument of the method.
+     *
+     * For example:
      *
      * ```ts
-     * db.table.search({
-     *   vector: 'titleAndBodyVector',
-     *   query: 'query',
+     * db.table.where({
+     *   NOT: { key: 'value' },
+     *   OR: [{ name: 'a' }, { name: 'b' }],
+     *   IN: {
+     *     columns: ['id', 'name'],
+     *     values: [
+     *       [1, 'a'],
+     *       [2, 'b'],
+     *     ],
+     *   },
      * });
      * ```
      *
-     * ## search query
+     * Using methods instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
      *
-     * Read about different search queries in [this Postgres doc](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES).
+     * ```ts
+     * db.table.where({
+     *   // see .whereNot
+     *   NOT: { id: 1 },
+     *   // can be an array:
+     *   NOT: [{ id: 1 }, { id: 2 }],
      *
-     * `search` method can accept one of the following queries:
+     *   // see .or
+     *   OR: [{ name: 'a' }, { name: 'b' }],
+     *   // can be an array:
+     *   // this will give id = 1 AND id = 2 OR id = 3 AND id = 4
+     *   OR: [
+     *     [{ id: 1 }, { id: 2 }],
+     *     [{ id: 3 }, { id: 4 }],
+     *   ],
      *
-     * - `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`
+     *   // see .in, the key syntax requires an object with columns and values
+     *   IN: {
+     *     columns: ['id', 'name'],
+     *     values: [
+     *       [1, 'a'],
+     *       [2, 'b'],
+     *     ],
+     *   },
+     *   // can be an array:
+     *   IN: [
+     *     {
+     *       columns: ['id', 'name'],
+     *       values: [
+     *         [1, 'a'],
+     *         [2, 'b'],
+     *       ],
+     *     },
+     *     { columns: ['someColumn'], values: [['foo', 'bar']] },
+     *   ],
+     * });
+     * ```
      *
-     * 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.
+     * ## column operators
      *
-     * Each query kind accepts a string or a raw SQL.
+     * `where` argument can take an object where the key is the name of the operator and the value is its argument.
+     *
+     * Different types of columns support different sets of operators.
+     *
+     * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
      *
      * ```ts
-     * import { raw } from 'orchid-orm';
+     * db.table.where({
+     *   numericColumn: {
+     *     // lower than 5
+     *     lt: 5,
      *
-     * db.table.search({
-     *   vector: 'titleAndBodyVector',
-     *   // can accept raw SQL:
-     *   phraseQuery: raw`'The Fat Rats'`,
+     *     // lower than the value returned by sub-query
+     *     lt: OtherTable.select('someNumber').take(),
+     *
+     *     // raw SQL expression produces WHERE "numericColumn" < "otherColumn" + 10
+     *     lt: db.table.sql`"otherColumn" + 10`,
+     *   },
      * });
      * ```
      *
-     * ## order by search rank
+     * ### Any type of column operators
      *
-     * Read about search ranking in [this Postgres doc](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-RANKING).
+     * `equals` is a simple `=` operator, it may be useful for comparing column value with JSON object:
      *
-     * Set `order: true` to order results by the search rank:
+     * ```ts
+     * db.table.where({
+     *   // this will fail because an object with operators is expected
+     *   jsonColumn: someObject,
+     *
+     *   // use this instead:
+     *   jsonColumn: { equals: someObject },
+     * });
+     * ```
+     *
+     * `not` is `!=` (or `<>`) not equal operator:
      *
      * ```ts
-     * db.table.search({
-     *   in: 'body',
-     *   query: 'query',
-     *   // will add ORDER BY ts_rank(to_tsvector('english', body)) DESC
-     *   order: true,
+     * db.table.where({
+     *   anyColumn: { not: value },
      * });
      * ```
      *
-     * To order with `ts_rank_cd` instead of `ts_rank`, set `coverDensity: true`:
+     * `in` is for the `IN` operator to check if the column value is included in a list of values.
+     *
+     * Takes an array of the same type as a column, a sub-query that returns a list of values, or a raw SQL expression that returns a list.
      *
      * ```ts
-     * db.table.search({
-     *   in: 'body',
-     *   query: 'query',
-     *   // will add ORDER BY ts_rank_cd(to_tsvector('english', body)) DESC
-     *   order: {
-     *     coverDensity: true,
+     * db.table.where({
+     *   column: {
+     *     in: ['a', 'b', 'c'],
+     *
+     *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
+     *     in: OtherTable.select('column'),
+     *
+     *     in: db.table.sql`('a', 'b')`,
      *   },
      * });
      * ```
      *
-     * Other options are:
+     * `notIn` is for the `NOT IN` operator, and takes the same arguments as `in`
+     *
+     * ### Numeric, Date, and Time column operators
+     *
+     * To compare numbers, dates, and times.
+     *
+     * `lt` is for `<` (lower than)
+     *
+     * `lte` is for `<=` (lower than or equal)
+     *
+     * `gt` is for `>` (greater than)
+     *
+     * `gte` is for `>=` (greater than or equal)
      *
      * ```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
+     * db.table.where({
+     *   numericColumn: {
+     *     gt: 5,
+     *     lt: 10,
+     *   },
+     *
+     *   date: {
+     *     lte: new Date(),
+     *   },
+     *
+     *   time: {
+     *     gte: new Date(),
      *   },
      * });
      * ```
      *
-     * Giving the `as` alias for the search allows to set the ordering in the `order` method:
+     * `between` also works with numeric, dates, and time columns, it takes an array of two elements.
+     *
+     * Both elements can be of the same type as a column, a sub-query, or a raw SQL expression.
      *
      * ```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',
-     *     },
-     *   });
+     * db.table.where({
+     *   column: {
+     *     // simple values
+     *     between: [1, 10],
+     *
+     *     // sub-query and raw SQL expression
+     *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
+     *   },
+     * });
      * ```
      *
-     * @param arg - search config
+     * ### Text column operators
+     *
+     * For `text`, `char`, `varchar`, and `json` columns.
+     *
+     * `json` is stored as text, so it has text operators. Use the `jsonb` type for JSON operators.
+     *
+     * Takes a string, or sub-query returning string, or raw SQL expression as well as other operators.
+     *
+     * ```ts
+     * db.table.where({
+     *   textColumn: {
+     *     // WHERE "textColumn" LIKE '%string%'
+     *     contains: 'string',
+     *     // WHERE "textColumn" ILIKE '%string%'
+     *     containsInsensitive: 'string',
+     *     // WHERE "textColumn" LIKE 'string%'
+     *     startsWith: 'string',
+     *     // WHERE "textColumn" ILIKE 'string%'
+     *     startsWithInsensitive: 'string',
+     *     // WHERE "textColumn" LIKE '%string'
+     *     endsWith: 'string',
+     *     // WHERE "textColumn" ILIKE '%string'
+     *     endsWithInsensitive: 'string',
+     *   },
+     * });
+     * ```
+     *
+     * ### JSONB column operators
+     *
+     * For the `jsonb` column, note that the `json` type has text operators instead.
+     *
+     * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
+     *
+     * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
+     *
+     * ```ts
+     * db.table.where({
+     *   jsonbColumn: {
+     *     jsonPath: [
+     *       '$.name', // first element is JSON path
+     *       '=', // second argument is comparison operator
+     *       'value', // third argument is a value to compare with
+     *     ],
+     *   },
+     * });
+     * ```
+     *
+     * `jsonSupersetOf`: check if the column value is a superset of provided value.
+     *
+     * For instance, it is true if the column has JSON `{ "a": 1, "b": 2 }` and provided value is `{ "a": 1 }`.
+     *
+     * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
+     *
+     * ```ts
+     * db.table.where({
+     *   jsonbColumn: {
+     *     jsonSupersetOf: { a: 1 },
+     *   },
+     * });
+     * ```
+     *
+     * `jsonSubsetOf`: check if the column value is a subset of provided value.
+     *
+     * For instance, it is true if the column has JSON `{ "a": 1 }` and provided value is `{ "a": 1, "b": 2 }`.
+     *
+     * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
+     *
+     * ```ts
+     * db.table.where({
+     *   jsonbColumn: {
+     *     jsonSupersetOf: { a: 1 },
+     *   },
+     * });
+     * ```
+     *
+     * @param args - {@link WhereArgs}
      */
-    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;
-    }> : 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 : ({
-    [I in keyof Column]: Column[I] extends keyof T['selectable'] ? T['selectable'][Column[I]]['column']['type'] : never;
-} & {
-    length: Column extends {
-        length: number;
-    } ? Column['length'] : never;
-})[] | Query | Expression;
-type WhereResult<T extends QueryBase> = T & {
-    meta: {
-        hasWhere: true;
-    };
-};
-type WhereInArg<T extends Pick<Query, 'selectable'>> = {
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | Expression;
-};
-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>;
-declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
-declare abstract class Where extends QueryBase {
     where<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     _where<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    /**
+     * `whereNot` takes the same arguments as `where` and prepends them with `NOT` in SQL
+     *
+     * ```ts
+     * // find records of different colors than red
+     * db.table.whereNot({ color: 'red' });
+     * ```
+     *
+     * @param args - {@link WhereArgs}
+     */
     whereNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     _whereNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    /**
+     * `and` is an alias for {@link where} to make it look closer to SQL:
+     *
+     * ```ts
+     * db.table.where({ id: 1 }).and({ name: 'John' });
+     * ```
+     *
+     * @param args - {@link WhereArgs}
+     */
     and<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     _and<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    /**
+     * `andNot` is an alias for `whereNot`.
+     *
+     * @param args - {@link WhereArgs}
+     */
     andNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     _andNot<T extends Where>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    /**
+     * `or` is accepting the same arguments as {@link where}, joining arguments with `OR`.
+     *
+     * Columns in single arguments are still joined with `AND`.
+     *
+     * The database is processing `AND` before `OR`, so this should be intuitively clear.
+     *
+     * ```ts
+     * db.table.or({ id: 1, color: 'red' }, { id: 2, color: 'blue' });
+     * ```
+     *
+     * This query will produce such SQL (simplified):
+     *
+     * ```sql
+     * SELECT * FROM "table"
+     * WHERE id = 1 AND color = 'red'
+     *    OR id = 2 AND color = 'blue'
+     * ```
+     *
+     * @param args - {@link WhereArgs} will be joined with `OR`
+     */
     or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
     _or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    /**
+     * `orNot` takes the same arguments as {@link or}, and prepends each condition with `NOT` just as {@link whereNot} does.
+     *
+     * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
+     */
     orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
     _orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    /**
+     * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
+     *
+     * When used with a single column it works equivalent to the `in` column operator:
+     *
+     * ```ts
+     * db.table.whereIn('column', [1, 2, 3]);
+     * // the same as:
+     * db.table.where({ column: [1, 2, 3] });
+     * ```
+     *
+     * `whereIn` can support a tuple of columns, that's what the `in` operator cannot support:
+     *
+     * ```ts
+     * db.table.whereIn(
+     *   ['id', 'name'],
+     *   [
+     *     [1, 'Alice'],
+     *     [2, 'Bob'],
+     *   ],
+     * );
+     * ```
+     *
+     * It supports sub query which should return records with columns of the same type:
+     *
+     * ```ts
+     * db.table.whereIn(['id', 'name'], OtherTable.select('id', 'name'));
+     * ```
+     *
+     * It supports raw SQL expression:
+     *
+     * ```ts
+     * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+     * ```
+     *
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     */
     whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    /**
+     * See {@link whereIn}.
+     *
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     */
     whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     _whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     _whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    /**
+     * Takes the same arguments as {@link whereIn}.
+     * Add a `WHERE IN` condition prefixed with `OR` to the query:
+     *
+     * ```ts
+     * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
+     * ```
+     *
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     */
     orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    /**
+     * See {@link orWhereIn}.
+     *
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     */
     orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     _orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     _orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    /**
+     * Acts as `whereIn`, but negates the condition with `NOT`:
+     *
+     * ```ts
+     * db.table.whereNotIn('color', ['red', 'green', 'blue']);
+     * ```
+     *
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     */
     whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    /**
+     * See {@link whereNotIn}.
+     *
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     */
     whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     _whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     _whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    /**
+     * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
+     *
+     * ```ts
+     * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
+     * ```
+     *
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     */
     orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    /**
+     * See {@link orWhereNotIn}.
+     *
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     */
     orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     _orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     _orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    /**
+     * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
+     *
+     * This method is accepting the same arguments as `join`, see the {@link Join.join} section for more details.
+     *
+     * ```ts
+     * // find users who have accounts
+     * // find by a relation name if it's defined
+     * db.user.whereExists('account');
+     *
+     * // find using a table and a join conditions
+     * db.user.whereExists(db.account, 'account.id', 'user.id');
+     *
+     * // find using a query builder in a callback:
+     * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
+     * ```
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+     */
     whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    /**
+     * See {@link whereExists}.
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
+     */
     whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     _whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
     _whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    /**
+     * Acts as `whereExists`, but prepends the condition with `OR`:
+     *
+     * ```ts
+     * // find users who have an account or a profile,
+     * // imagine that the user has both `account` and `profile` relations defined.
+     * db.user.whereExist('account').orWhereExists('profile');
+     * ```
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+     */
     orWhereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    /**
+     * See {@link orWhereExists}.
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
+     */
     orWhereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     _orWhereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     _orWhereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    /**
+     * Acts as `whereExists`, but negates the condition with `NOT`:
+     *
+     * ```ts
+     * // find users who don't have an account,
+     * // image that the user `belongsTo` or `hasOne` account.
+     * db.user.whereNotExist('account');
+     * ```
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+     */
     whereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    /**
+     * See {@link whereNotExists}.
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
+     */
     whereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     _whereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     _whereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    /**
+     * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
+     *
+     * ```ts
+     * // find users who don't have an account OR who don't have a profile
+     * // imagine that the user has both `account` and `profile` relations defined.
+     * db.user.whereNotExists('account').orWhereNotExists('profile');
+     * ```
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+     */
     orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    /**
+     * See {@link orWhereNotExists}.
+     *
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
+     */
     orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     _orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     _orWhereNotExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
@@ -3367,127 +3652,430 @@ declare class Update {
      * });
      * ```
      *
-     * `null` value will set a column to `NULL`, but the `undefined` value will be ignored:
+     * `null` value will set a column to `NULL`, but the `undefined` value will be ignored:
+     *
+     * ```ts
+     * db.table.findBy({ id: 1 }).update({
+     *   name: null, // updates to null
+     *   age: undefined, // skipped, no effect
+     * });
+     * ```
+     *
+     * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
+     */
+    update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
+    _update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
+    /**
+     * `updateRaw` is for updating records with raw expression.
+     *
+     * The behavior is the same as a regular `update` method has:
+     * `find` or `where` must precede calling this method,
+     * it returns an updated count by default,
+     * you can customize returning data by using `select`.
+     *
+     * ```ts
+     * const value = 'new name';
+     *
+     * // update with SQL template string
+     * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
+     *
+     * // or update with `sql` function:
+     * await db.table.find(1).updateRaw(db.table.sql`name = ${value}`);
+     * ```
+     * @param args - raw SQL via a template string or by using a `sql` method
+     */
+    updateRaw<T extends Query>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
+    _updateRaw<T extends Query>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
+    /**
+     * To make sure that at least one row was updated use `updateOrThrow`:
+     *
+     * ```ts
+     * import { NotFoundError } from 'pqb';
+     *
+     * try {
+     *   // updatedCount is guaranteed to be greater than 0
+     *   const updatedCount = await db.table
+     *     .where(conditions)
+     *     .updateOrThrow({ name: 'name' });
+     *
+     *   // updatedRecords is guaranteed to be a non-empty array
+     *   const updatedRecords = await db.table
+     *     .where(conditions)
+     *     .select('id')
+     *     .updateOrThrow({ name: 'name' });
+     * } catch (err) {
+     *   if (err instanceof NotFoundError) {
+     *     // handle error
+     *   }
+     * }
+     * ```
+     *
+     * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
+     */
+    updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
+    _updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
+    /**
+     * Increments a column value by the specified amount. Optionally takes `returning` argument.
+     *
+     * ```ts
+     * // increment numericColumn column by 1, return updated records
+     * const result = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .increment('numericColumn');
+     *
+     * // increment someColumn by 5 and otherColumn by 10, return updated records
+     * const result2 = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .increment({
+     *     someColumn: 5,
+     *     otherColumn: 10,
+     *   });
+     * ```
+     *
+     * @param data - name of the column to increment, or an object with columns and values to add
+     */
+    increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    _increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    /**
+     * Decrements a column value by the specified amount. Optionally takes `returning` argument.
+     *
+     * ```ts
+     * // decrement numericColumn column by 1, return updated records
+     * const result = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .decrement('numericColumn');
+     *
+     * // decrement someColumn by 5 and otherColumn by 10, return updated records
+     * const result2 = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .decrement({
+     *     someColumn: 5,
+     *     otherColumn: 10,
+     *   });
+     * ```
+     *
+     * @param data - name of the column to decrement, or an object with columns and values to subtract
+     */
+    decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+}
+
+type IsolationLevel = 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED' | 'READ UNCOMMITTED';
+type TransactionOptions = {
+    level: IsolationLevel;
+    readOnly?: boolean;
+    deferrable?: boolean;
+};
+declare class Transaction {
+    transaction<T extends Query, Result>(this: T, cb: () => Promise<Result>): Promise<Result>;
+    transaction<T extends Query, Result>(this: T, options: IsolationLevel | TransactionOptions, cb: () => Promise<Result>): Promise<Result>;
+}
+
+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.findBy({ id: 1 }).update({
-     *   name: null, // updates to null
-     *   age: undefined, // skipped, no effect
+     * db.table.search({
+     *   vector: 'titleAndBodyVector',
+     *   query: 'query',
      * });
      * ```
      *
-     * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
-     */
-    update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
-    _update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
-    /**
-     * `updateRaw` is for updating records with raw expression.
+     * ## search query
      *
-     * The behavior is the same as a regular `update` method has:
-     * `find` or `where` must precede calling this method,
-     * it returns an updated count by default,
-     * you can customize returning data by using `select`.
+     * Read about different search queries in [this Postgres doc](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES).
      *
-     * ```ts
-     * const value = 'new name';
+     * `search` method can accept one of the following queries:
      *
-     * // update with SQL template string
-     * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
+     * - `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`
      *
-     * // or update with `sql` function:
-     * await db.table.find(1).updateRaw(db.table.sql`name = ${value}`);
-     * ```
-     * @param args - raw SQL via a template string or by using a `sql` method
-     */
-    updateRaw<T extends Query>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
-    _updateRaw<T extends Query>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
-    /**
-     * To make sure that at least one row was updated use `updateOrThrow`:
+     * 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.
      *
-     * ```ts
-     * import { NotFoundError } from 'pqb';
+     * Each query kind accepts a string or a raw SQL.
      *
-     * try {
-     *   // updatedCount is guaranteed to be greater than 0
-     *   const updatedCount = await db.table
-     *     .where(conditions)
-     *     .updateOrThrow({ name: 'name' });
+     * ```ts
+     * import { raw } from 'orchid-orm';
      *
-     *   // updatedRecords is guaranteed to be a non-empty array
-     *   const updatedRecords = await db.table
-     *     .where(conditions)
-     *     .select('id')
-     *     .updateOrThrow({ name: 'name' });
-     * } catch (err) {
-     *   if (err instanceof NotFoundError) {
-     *     // handle error
-     *   }
-     * }
+     * db.table.search({
+     *   vector: 'titleAndBodyVector',
+     *   // can accept raw SQL:
+     *   phraseQuery: raw`'The Fat Rats'`,
+     * });
      * ```
      *
-     * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
-     */
-    updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
-    _updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
-    /**
-     * Increments a column value by the specified amount. Optionally takes `returning` argument.
+     * ## 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
-     * // increment numericColumn column by 1, return updated records
-     * const result = await db.table
-     *   .selectAll()
-     *   .where(...conditions)
-     *   .increment('numericColumn');
+     * db.table.search({
+     *   in: 'body',
+     *   query: 'query',
+     *   // will add ORDER BY ts_rank(to_tsvector('english', body)) DESC
+     *   order: true,
+     * });
+     * ```
      *
-     * // increment someColumn by 5 and otherColumn by 10, return updated records
-     * const result2 = await db.table
-     *   .selectAll()
-     *   .where(...conditions)
-     *   .increment({
-     *     someColumn: 5,
-     *     otherColumn: 10,
-     *   });
+     * 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,
+     *   },
+     * });
      * ```
      *
-     * @param data - name of the column to increment, or an object with columns and values to add
-     */
-    increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-    _increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-    /**
-     * Decrements a column value by the specified amount. Optionally takes `returning` argument.
+     * Other options are:
      *
      * ```ts
-     * // decrement numericColumn column by 1, return updated records
-     * const result = await db.table
-     *   .selectAll()
-     *   .where(...conditions)
-     *   .decrement('numericColumn');
+     * 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
+     *   },
+     * });
+     * ```
      *
-     * // decrement someColumn by 5 and otherColumn by 10, return updated records
-     * const result2 = await db.table
-     *   .selectAll()
-     *   .where(...conditions)
-     *   .decrement({
-     *     someColumn: 5,
-     *     otherColumn: 10,
+     * 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 data - name of the column to decrement, or an object with columns and values to subtract
+     * @param arg - search config
      */
-    decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-    _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-}
-
-type IsolationLevel = 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED' | 'READ UNCOMMITTED';
-type TransactionOptions = {
-    level: IsolationLevel;
-    readOnly?: boolean;
-    deferrable?: boolean;
-};
-declare class Transaction {
-    transaction<T extends Query, Result>(this: T, cb: () => Promise<Result>): Promise<Result>;
-    transaction<T extends Query, Result>(this: T, options: IsolationLevel | TransactionOptions, cb: () => Promise<Result>): Promise<Result>;
+    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 UpsertCreateArg<T extends Query> = CreateData<T> | (() => CreateData<T>);
@@ -3684,39 +4272,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;
@@ -4101,37 +4674,46 @@ declare class QueryMethods<CT extends ColumnTypesBase> {
     distinct<T extends Query>(this: T, ...columns: SelectableOrExpression<T>[]): T;
     _distinct<T extends Query>(this: T, ...columns: SelectableOrExpression<T>[]): T;
     /**
-     * Find a single record by the primary key (id), adds `LIMIT 1`.
-     * Throws when not found.
+     * The `find` method is available only for tables which has exactly one primary key.
+     * And also it can accept raw SQL template literal, then the primary key is not required.
+     *
+     * Find record by id, throw [NotFoundError](/guide/error-handling.html) if not found:
      *
      * ```ts
-     * const result: TableType = await db.table.find(123);
+     * await db.table.find(1);
      * ```
      *
-     * @param args - primary key value to find by
+     * ```ts
+     * await db.user.find`
+     *   age = ${age} AND
+     *   name = ${name}
+     * `;
+     * ```
+     *
+     * @param args - primary key value to find by, or a raw SQL
      */
     find<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOne<WhereResult<T>>;
     _find<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOne<WhereResult<T>>;
     /**
-     * Find a single record by the primary key (id), adds `LIMIT 1`.
+     * Find a single record by the primary key (id), adds `LIMIT 1`, can accept a raw SQL.
      * Returns `undefined` when not found.
      *
      * ```ts
      * const result: TableType | undefined = await db.table.find(123);
      * ```
      *
-     * @param args - primary key value to find by
+     * @param args - primary key value to find by, or a raw SQL
      */
     findOptional<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOneOptional<WhereResult<T>>;
     _findOptional<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOneOptional<WhereResult<T>>;
     /**
      * The same as `where(conditions).take()`, it will filter records and add a `LIMIT 1`.
-     * Throws when not found.
+     * Throws `NotFoundError` if not found.
      *
      * ```ts
-     * const result: TableType = await db.table.findBy({
-     *   key: 'value',
-     * });
+     * const result: TableType = await db.table.findBy({ key: 'value' });
+     * // is equivalent to:
+     * db.table.where({ key: 'value' }).take()
      * ```
      *
      * @param args - `where` conditions
@@ -4282,6 +4864,15 @@ declare class QueryMethods<CT extends ColumnTypesBase> {
      */
     offset<T extends Query>(this: T, arg: number | undefined): T;
     _offset<T extends Query>(this: T, arg: number | undefined): T;
+    /**
+     * Use `exists()` to check if there is at least one record-matching condition.
+     *
+     * It will discard previous `select` statements if any. Returns a boolean.
+     *
+     * ```ts
+     * const exists: boolean = await db.table.where(...conditions).exists();
+     * ```
+     */
     exists<T extends Query>(this: T): SetQueryReturnsColumn<T, BooleanColumn>;
     _exists<T extends Query>(this: T): SetQueryReturnsColumn<T, BooleanColumn>;
     /**
@@ -4578,7 +5169,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> {
@@ -4598,41 +5189,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]>;
@@ -4698,205 +5255,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> {
@@ -5458,7 +5818,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;
@@ -5492,8 +5852,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;
@@ -5842,39 +6201,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;
@@ -5966,7 +6310,7 @@ 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 & {
@@ -5990,20 +6334,6 @@ declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = Ba
     generated<T extends ColumnType>(this: T, ...args: RawSQLArgs): T;
 }
 
-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,
-  };
-}
-
 declare abstract class VirtualColumn extends ColumnType<unknown, typeof Operators.any> {
     dataType: string;
     operators: {
@@ -6089,4 +6419,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, 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 };
+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 };