@supabase/postgrest-js 2.108.2 → 2.108.3-canary.0

package/dist/index.d.cts

@@ -1125,6 +1125,25 @@ declare class PostgrestTransformBuilder<ClientOptions extends ClientServerOption
    * ```
    */
   select<Query extends string = '*', NewResultOne = GetResult<Schema, Row, RelationName, Relationships, Query, ClientOptions>>(columns?: Query): PostgrestFilterBuilder<ClientOptions, Schema, Row, Method extends 'RPC' ? Result$1 extends unknown[] ? NewResultOne[] : NewResultOne : NewResultOne[], RelationName, Relationships, Method, ThrowOnError>;
+  /**
+   * Order the query result by `column`.
+   *
+   * You can call this method multiple times to order by multiple columns.
+   *
+   * You can order referenced tables, but it only affects the ordering of the
+   * parent table if you use `!inner` in the query.
+   *
+   * @param column - The column to order by
+   * @param options - Named parameters
+   * @param options.ascending - If `true`, the result will be in ascending order
+   * @param options.nullsFirst - If `true`, `null`s appear first. If `false`,
+   * `null`s appear last.
+   * @param options.referencedTable - Set this to order a referenced table by
+   * its columns
+   *
+   * @category Database
+   * @subcategory Using modifiers
+   */
   order<ColumnName extends string & keyof Row>(column: ColumnName, options?: {
     ascending?: boolean;
     nullsFirst?: boolean;
@@ -1744,23 +1763,1195 @@ declare class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions,
    * @exampleSql With `select()`
    * ```sql
    * create table
-   *   characters (id int8 primary key, name text);
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 2,
+   *       "name": "Leia"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  eq<ColumnName extends string>(column: ColumnName extends keyof Row ? ColumnName : ColumnName extends `${string}.${string}` | `${string}->${string}` ? ColumnName : string extends ColumnName ? string : keyof Row, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? NonNullable<unknown> : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? NonNullable<ResolvedFilterValue> : never): this;
+  /**
+   * Match only rows where `column` is not equal to `value`.
+   *
+   * This filter does not include rows where `column` is `NULL`. To match null
+   * values, use `.is(column, null)` instead.
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .neq('name', 'Leia')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "name": "Luke"
+   *     },
+   *     {
+   *       "id": 3,
+   *       "name": "Han"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  neq<ColumnName extends string>(column: ColumnName extends keyof Row ? ColumnName : ColumnName extends `${string}.${string}` | `${string}->${string}` ? ColumnName : string extends ColumnName ? string : keyof Row, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer Resolved ? Resolved : never): this;
+  /**
+   * Match only rows where `column` is greater than `value`.
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription With `select()`
+   * When using [reserved words](https://www.postgresql.org/docs/current/sql-keywords-appendix.html) for column names you need
+   * to add double quotes e.g. `.gt('"order"', 2)`
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .gt('id', 2)
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 3,
+   *       "name": "Han"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  gt<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+  gt(column: string, value: unknown): this;
+  /**
+   * Match only rows where `column` is greater than or equal to `value`.
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .gte('id', 2)
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 2,
+   *       "name": "Leia"
+   *     },
+   *     {
+   *       "id": 3,
+   *       "name": "Han"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  gte<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+  gte(column: string, value: unknown): this;
+  /**
+   * Match only rows where `column` is less than `value`.
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .lt('id', 2)
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "name": "Luke"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  lt<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+  lt(column: string, value: unknown): this;
+  /**
+   * Match only rows where `column` is less than or equal to `value`.
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .lte('id', 2)
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "name": "Luke"
+   *     },
+   *     {
+   *       "id": 2,
+   *       "name": "Leia"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  lte<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+  lte(column: string, value: unknown): this;
+  /**
+   * Match only rows where `column` matches `pattern` case-sensitively.
+   *
+   * @param column - The column to filter on
+   * @param pattern - The pattern to match with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .like('name', '%Lu%')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "name": "Luke"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  like<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
+  like(column: string, pattern: string): this;
+  /**
+   * Match only rows where `column` matches all of `patterns` case-sensitively.
+   *
+   * @param column - The column to filter on
+   * @param patterns - The patterns to match with
+   *
+   * @category Database
+   * @subcategory Using filters
+   */
+  likeAllOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+  likeAllOf(column: string, patterns: readonly string[]): this;
+  /**
+   * Match only rows where `column` matches any of `patterns` case-sensitively.
+   *
+   * @param column - The column to filter on
+   * @param patterns - The patterns to match with
+   *
+   * @category Database
+   * @subcategory Using filters
+   */
+  likeAnyOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+  likeAnyOf(column: string, patterns: readonly string[]): this;
+  /**
+   * Match only rows where `column` matches `pattern` case-insensitively.
+   *
+   * @param column - The column to filter on
+   * @param pattern - The pattern to match with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .ilike('name', '%lu%')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "name": "Luke"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  ilike<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
+  ilike(column: string, pattern: string): this;
+  /**
+   * Match only rows where `column` matches all of `patterns` case-insensitively.
+   *
+   * @param column - The column to filter on
+   * @param patterns - The patterns to match with
+   *
+   * @category Database
+   * @subcategory Using filters
+   */
+  ilikeAllOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+  ilikeAllOf(column: string, patterns: readonly string[]): this;
+  /**
+   * Match only rows where `column` matches any of `patterns` case-insensitively.
+   *
+   * @param column - The column to filter on
+   * @param patterns - The patterns to match with
+   *
+   * @category Database
+   * @subcategory Using filters
+   */
+  ilikeAnyOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+  ilikeAnyOf(column: string, patterns: readonly string[]): this;
+  /**
+   * Match only rows where `column` matches the PostgreSQL regex `pattern`
+   * case-sensitively (using the `~` operator).
+   *
+   * @param column - The column to filter on
+   * @param pattern - The PostgreSQL regular expression pattern to match with
+   */
+  regexMatch<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
+  regexMatch(column: string, pattern: string): this;
+  /**
+   * Match only rows where `column` matches the PostgreSQL regex `pattern`
+   * case-insensitively (using the `~*` operator).
+   *
+   * @param column - The column to filter on
+   * @param pattern - The PostgreSQL regular expression pattern to match with
+   */
+  regexIMatch<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
+  regexIMatch(column: string, pattern: string): this;
+  /**
+   * Match only rows where `column` IS `value`.
+   *
+   * For non-boolean columns, this is only relevant for checking if the value of
+   * `column` is NULL by setting `value` to `null`.
+   *
+   * For boolean columns, you can also set `value` to `true` or `false` and it
+   * will behave the same way as `.eq()`.
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription Checking for nullness, true or false
+   * Using the `eq()` filter doesn't work when filtering for `null`.
+   *
+   * Instead, you need to use `is()`.
+   *
+   * @example Checking for nullness, true or false
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('countries')
+   *   .select()
+   *   .is('name', null)
+   * ```
+   *
+   * @exampleSql Checking for nullness, true or false
+   * ```sql
+   * create table
+   *   countries (id int8 primary key, name text);
+   *
+   * insert into
+   *   countries (id, name)
+   * values
+   *   (1, 'null'),
+   *   (2, null);
+   * ```
+   *
+   * @exampleResponse Checking for nullness, true or false
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 2,
+   *       "name": "null"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  is<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName] & (boolean | null)): this;
+  is(column: string, value: boolean | null): this;
+  /**
+   * Match only rows where `column` IS DISTINCT FROM `value`.
+   *
+   * Unlike `.neq()`, this treats `NULL` as a comparable value. Two `NULL` values
+   * are considered equal (not distinct), and comparing `NULL` with any non-NULL
+   * value returns true (distinct).
+   *
+   * @param column - The column to filter on
+   * @param value - The value to filter with
+   */
+  isDistinct<ColumnName extends string>(column: ColumnName, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never): this;
+  /**
+   * Match only rows where `column` is included in the `values` array.
+   *
+   * @param column - The column to filter on
+   * @param values - The values array to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .in('name', ['Leia', 'Han'])
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 2,
+   *       "name": "Leia"
+   *     },
+   *     {
+   *       "id": 3,
+   *       "name": "Han"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  in<ColumnName extends string>(column: ColumnName, values: ReadonlyArray<ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never>): this;
+  /**
+   * Match only rows where `column` is NOT included in the `values` array.
+   *
+   * @param column - The column to filter on
+   * @param values - The values array to filter with
+   */
+  notIn<ColumnName extends string>(column: ColumnName, values: ReadonlyArray<ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never>): this;
+  /**
+   * Only relevant for jsonb, array, and range columns. Match only rows where
+   * `column` contains every element appearing in `value`.
+   *
+   * @param column - The jsonb, array, or range column to filter on
+   * @param value - The jsonb, array, or range value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example On array columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('issues')
+   *   .select()
+   *   .contains('tags', ['is:open', 'priority:low'])
+   * ```
+   *
+   * @exampleSql On array columns
+   * ```sql
+   * create table
+   *   issues (
+   *     id int8 primary key,
+   *     title text,
+   *     tags text[]
+   *   );
+   *
+   * insert into
+   *   issues (id, title, tags)
+   * values
+   *   (1, 'Cache invalidation is not working', array['is:open', 'severity:high', 'priority:low']),
+   *   (2, 'Use better names', array['is:open', 'severity:low', 'priority:medium']);
+   * ```
+   *
+   * @exampleResponse On array columns
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "title": "Cache invalidation is not working"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   *
+   * @exampleDescription On range columns
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example On range columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .contains('during', '[2000-01-01 13:00, 2000-01-01 13:30)')
+   * ```
+   *
+   * @exampleSql On range columns
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse On range columns
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "room_name": "Emerald",
+   *       "during": "[\"2000-01-01 13:00:00\",\"2000-01-01 15:00:00\")"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   *
+   * @example On `jsonb` columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('users')
+   *   .select('name')
+   *   .contains('address', { postcode: 90210 })
+   * ```
+   *
+   * @exampleSql On `jsonb` columns
+   * ```sql
+   * create table
+   *   users (
+   *     id int8 primary key,
+   *     name text,
+   *     address jsonb
+   *   );
+   *
+   * insert into
+   *   users (id, name, address)
+   * values
+   *   (1, 'Michael', '{ "postcode": 90210, "street": "Melrose Place" }'),
+   *   (2, 'Jane', '{}');
+   * ```
+   *
+   * @exampleResponse On `jsonb` columns
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "name": "Michael"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  contains<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]> | Record<string, unknown>): this;
+  contains(column: string, value: string | readonly unknown[] | Record<string, unknown>): this;
+  /**
+   * Only relevant for jsonb, array, and range columns. Match only rows where
+   * every element appearing in `column` is contained by `value`.
+   *
+   * @param column - The jsonb, array, or range column to filter on
+   * @param value - The jsonb, array, or range value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example On array columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('classes')
+   *   .select('name')
+   *   .containedBy('days', ['monday', 'tuesday', 'wednesday', 'friday'])
+   * ```
+   *
+   * @exampleSql On array columns
+   * ```sql
+   * create table
+   *   classes (
+   *     id int8 primary key,
+   *     name text,
+   *     days text[]
+   *   );
+   *
+   * insert into
+   *   classes (id, name, days)
+   * values
+   *   (1, 'Chemistry', array['monday', 'friday']),
+   *   (2, 'History', array['monday', 'wednesday', 'thursday']);
+   * ```
+   *
+   * @exampleResponse On array columns
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "name": "Chemistry"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   *
+   * @exampleDescription On range columns
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example On range columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .containedBy('during', '[2000-01-01 00:00, 2000-01-01 23:59)')
+   * ```
+   *
+   * @exampleSql On range columns
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse On range columns
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "room_name": "Emerald",
+   *       "during": "[\"2000-01-01 13:00:00\",\"2000-01-01 15:00:00\")"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   *
+   * @example On `jsonb` columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('users')
+   *   .select('name')
+   *   .containedBy('address', {})
+   * ```
+   *
+   * @exampleSql On `jsonb` columns
+   * ```sql
+   * create table
+   *   users (
+   *     id int8 primary key,
+   *     name text,
+   *     address jsonb
+   *   );
+   *
+   * insert into
+   *   users (id, name, address)
+   * values
+   *   (1, 'Michael', '{ "postcode": 90210, "street": "Melrose Place" }'),
+   *   (2, 'Jane', '{}');
+   * ```
+   *
+   * @exampleResponse On `jsonb` columns
+   * ```json
+   *   {
+   *     "data": [
+   *       {
+   *         "name": "Jane"
+   *       }
+   *     ],
+   *     "status": 200,
+   *     "statusText": "OK"
+   *   }
+   *
+   * ```
+   */
+  containedBy<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]> | Record<string, unknown>): this;
+  containedBy(column: string, value: string | readonly unknown[] | Record<string, unknown>): this;
+  /**
+   * Only relevant for range columns. Match only rows where every element in
+   * `column` is greater than any element in `range`.
+   *
+   * @param column - The range column to filter on
+   * @param range - The range to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription With `select()`
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .rangeGt('during', '[2000-01-02 08:00, 2000-01-02 09:00)')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   *   {
+   *     "data": [
+   *       {
+   *         "id": 2,
+   *         "room_name": "Topaz",
+   *         "during": "[\"2000-01-02 09:00:00\",\"2000-01-02 10:00:00\")"
+   *       }
+   *     ],
+   *     "status": 200,
+   *     "statusText": "OK"
+   *   }
+   *
+   * ```
+   */
+  rangeGt<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+  rangeGt(column: string, range: string): this;
+  /**
+   * Only relevant for range columns. Match only rows where every element in
+   * `column` is either contained in `range` or greater than any element in
+   * `range`.
+   *
+   * @param column - The range column to filter on
+   * @param range - The range to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription With `select()`
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .rangeGte('during', '[2000-01-02 08:30, 2000-01-02 09:30)')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   *   {
+   *     "data": [
+   *       {
+   *         "id": 2,
+   *         "room_name": "Topaz",
+   *         "during": "[\"2000-01-02 09:00:00\",\"2000-01-02 10:00:00\")"
+   *       }
+   *     ],
+   *     "status": 200,
+   *     "statusText": "OK"
+   *   }
+   *
+   * ```
+   */
+  rangeGte<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+  rangeGte(column: string, range: string): this;
+  /**
+   * Only relevant for range columns. Match only rows where every element in
+   * `column` is less than any element in `range`.
+   *
+   * @param column - The range column to filter on
+   * @param range - The range to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription With `select()`
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .rangeLt('during', '[2000-01-01 15:00, 2000-01-01 16:00)')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "room_name": "Emerald",
+   *       "during": "[\"2000-01-01 13:00:00\",\"2000-01-01 15:00:00\")"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  rangeLt<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+  rangeLt(column: string, range: string): this;
+  /**
+   * Only relevant for range columns. Match only rows where every element in
+   * `column` is either contained in `range` or less than any element in
+   * `range`.
+   *
+   * @param column - The range column to filter on
+   * @param range - The range to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription With `select()`
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .rangeLte('during', '[2000-01-01 14:00, 2000-01-01 16:00)')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   *   {
+   *     "data": [
+   *       {
+   *         "id": 1,
+   *         "room_name": "Emerald",
+   *         "during": "[\"2000-01-01 13:00:00\",\"2000-01-01 15:00:00\")"
+   *       }
+   *     ],
+   *     "status": 200,
+   *     "statusText": "OK"
+   *   }
+   *
+   * ```
+   */
+  rangeLte<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+  rangeLte(column: string, range: string): this;
+  /**
+   * Only relevant for range columns. Match only rows where `column` is
+   * mutually exclusive to `range` and there can be no element between the two
+   * ranges.
+   *
+   * @param column - The range column to filter on
+   * @param range - The range to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @exampleDescription With `select()`
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .rangeAdjacent('during', '[2000-01-01 12:00, 2000-01-01 13:00)')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
+   *
+   * insert into
+   *   reservations (id, room_name, during)
+   * values
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 1,
+   *       "room_name": "Emerald",
+   *       "during": "[\"2000-01-01 13:00:00\",\"2000-01-01 15:00:00\")"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
+  rangeAdjacent<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+  rangeAdjacent(column: string, range: string): this;
+  /**
+   * Only relevant for array and range columns. Match only rows where
+   * `column` and `value` have an element in common.
+   *
+   * @param column - The array or range column to filter on
+   * @param value - The array or range value to filter with
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @example On array columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('issues')
+   *   .select('title')
+   *   .overlaps('tags', ['is:closed', 'severity:high'])
+   * ```
+   *
+   * @exampleSql On array columns
+   * ```sql
+   * create table
+   *   issues (
+   *     id int8 primary key,
+   *     title text,
+   *     tags text[]
+   *   );
+   *
+   * insert into
+   *   issues (id, title, tags)
+   * values
+   *   (1, 'Cache invalidation is not working', array['is:open', 'severity:high', 'priority:low']),
+   *   (2, 'Use better names', array['is:open', 'severity:low', 'priority:medium']);
+   * ```
+   *
+   * @exampleResponse On array columns
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "title": "Cache invalidation is not working"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   *
+   * @exampleDescription On range columns
+   * Postgres supports a number of [range
+   * types](https://www.postgresql.org/docs/current/rangetypes.html). You
+   * can filter on range columns using the string representation of range
+   * values.
+   *
+   * @example On range columns
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('reservations')
+   *   .select()
+   *   .overlaps('during', '[2000-01-01 12:45, 2000-01-01 13:15)')
+   * ```
+   *
+   * @exampleSql On range columns
+   * ```sql
+   * create table
+   *   reservations (
+   *     id int8 primary key,
+   *     room_name text,
+   *     during tsrange
+   *   );
    *
    * insert into
-   *   characters (id, name)
+   *   reservations (id, room_name, during)
    * values
-   *   (1, 'Luke'),
-   *   (2, 'Leia'),
-   *   (3, 'Han');
+   *   (1, 'Emerald', '[2000-01-01 13:00, 2000-01-01 15:00)'),
+   *   (2, 'Topaz', '[2000-01-02 09:00, 2000-01-02 10:00)');
    * ```
    *
-   * @exampleResponse With `select()`
+   * @exampleResponse On range columns
    * ```json
    * {
    *   "data": [
    *     {
-   *       "id": 2,
-   *       "name": "Leia"
+   *       "id": 1,
+   *       "room_name": "Emerald",
+   *       "during": "[\"2000-01-01 13:00:00\",\"2000-01-01 15:00:00\")"
    *     }
    *   ],
    *   "status": 200,
@@ -1768,101 +2959,126 @@ declare class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions,
    * }
    * ```
    */
-  eq<ColumnName extends string>(column: ColumnName extends keyof Row ? ColumnName : ColumnName extends `${string}.${string}` | `${string}->${string}` ? ColumnName : string extends ColumnName ? string : keyof Row, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? NonNullable<unknown> : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? NonNullable<ResolvedFilterValue> : never): this;
+  overlaps<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]>): this;
+  overlaps(column: string, value: string | readonly unknown[]): this;
   /**
-   * Match only rows where `column` is not equal to `value`.
-   *
-   * This filter does not include rows where `column` is `NULL`. To match null
-   * values, use `.is(column, null)` instead.
+   * Only relevant for text and tsvector columns. Match only rows where
+   * `column` matches the query string in `query`.
    *
-   * @param column - The column to filter on
-   * @param value - The value to filter with
+   * @param column - The text or tsvector column to filter on
+   * @param query - The query text to match with
+   * @param options - Named parameters
+   * @param options.config - The text search configuration to use
+   * @param options.type - Change how the `query` text is interpreted
    *
    * @category Database
    * @subcategory Using filters
    *
-   * @example With `select()`
+   * @remarks
+   * - For more information, see [Postgres full text search](/docs/guides/database/full-text-search).
+   *
+   * @example Text search
    * ```ts
-   * const { data, error } = await supabase
-   *   .from('characters')
-   *   .select()
-   *   .neq('name', 'Leia')
+   * const result = await supabase
+   *   .from("texts")
+   *   .select("content")
+   *   .textSearch("content", `'eggs' & 'ham'`, {
+   *     config: "english",
+   *   });
    * ```
    *
-   * @exampleSql With `select()`
+   * @exampleSql Text search
    * ```sql
-   * create table
-   *   characters (id int8 primary key, name text);
+   * create table texts (
+   *   id      bigint
+   *           primary key
+   *           generated always as identity,
+   *   content text
+   * );
    *
-   * insert into
-   *   characters (id, name)
-   * values
-   *   (1, 'Luke'),
-   *   (2, 'Leia'),
-   *   (3, 'Han');
+   * insert into texts (content) values
+   *     ('Four score and seven years ago'),
+   *     ('The road goes ever on and on'),
+   *     ('Green eggs and ham')
+   * ;
    * ```
    *
-   * @exampleResponse With `select()`
+   * @exampleResponse Text search
    * ```json
    * {
    *   "data": [
    *     {
-   *       "id": 1,
-   *       "name": "Luke"
-   *     },
-   *     {
-   *       "id": 3,
-   *       "name": "Han"
+   *       "content": "Green eggs and ham"
    *     }
    *   ],
    *   "status": 200,
    *   "statusText": "OK"
    * }
    * ```
-   */
-  neq<ColumnName extends string>(column: ColumnName extends keyof Row ? ColumnName : ColumnName extends `${string}.${string}` | `${string}->${string}` ? ColumnName : string extends ColumnName ? string : keyof Row, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer Resolved ? Resolved : never): this;
-  gt<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
-  gt(column: string, value: unknown): this;
-  gte<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
-  gte(column: string, value: unknown): this;
-  lt<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
-  lt(column: string, value: unknown): this;
-  lte<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
-  lte(column: string, value: unknown): this;
-  like<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
-  like(column: string, pattern: string): this;
-  likeAllOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
-  likeAllOf(column: string, patterns: readonly string[]): this;
-  likeAnyOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
-  likeAnyOf(column: string, patterns: readonly string[]): this;
-  ilike<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
-  ilike(column: string, pattern: string): this;
-  ilikeAllOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
-  ilikeAllOf(column: string, patterns: readonly string[]): this;
-  ilikeAnyOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
-  ilikeAnyOf(column: string, patterns: readonly string[]): this;
-  regexMatch<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
-  regexMatch(column: string, pattern: string): this;
-  regexIMatch<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
-  regexIMatch(column: string, pattern: string): this;
-  is<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName] & (boolean | null)): this;
-  is(column: string, value: boolean | null): this;
-  /**
-   * Match only rows where `column` IS DISTINCT FROM `value`.
    *
-   * Unlike `.neq()`, this treats `NULL` as a comparable value. Two `NULL` values
-   * are considered equal (not distinct), and comparing `NULL` with any non-NULL
-   * value returns true (distinct).
+   * @exampleDescription Basic normalization
+   * Uses PostgreSQL's `plainto_tsquery` function.
    *
-   * @param column - The column to filter on
-   * @param value - The value to filter with
+   * @example Basic normalization
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('quotes')
+   *   .select('catchphrase')
+   *   .textSearch('catchphrase', `'fat' & 'cat'`, {
+   *     type: 'plain',
+   *     config: 'english'
+   *   })
+   * ```
+   *
+   * @exampleDescription Full normalization
+   * Uses PostgreSQL's `phraseto_tsquery` function.
+   *
+   * @example Full normalization
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('quotes')
+   *   .select('catchphrase')
+   *   .textSearch('catchphrase', `'fat' & 'cat'`, {
+   *     type: 'phrase',
+   *     config: 'english'
+   *   })
+   * ```
+   *
+   * @exampleDescription Websearch
+   * Uses PostgreSQL's `websearch_to_tsquery` function.
+   * This function will never raise syntax errors, which makes it possible to use raw user-supplied input for search, and can be used
+   * with advanced operators.
+   *
+   * - `unquoted text`: text not inside quote marks will be converted to terms separated by & operators, as if processed by plainto_tsquery.
+   * - `"quoted text"`: text inside quote marks will be converted to terms separated by `<->` operators, as if processed by phraseto_tsquery.
+   * - `OR`: the word “or” will be converted to the | operator.
+   * - `-`: a dash will be converted to the ! operator.
+   *
+   * @example Websearch
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('quotes')
+   *   .select('catchphrase')
+   *   .textSearch('catchphrase', `'fat or cat'`, {
+   *     type: 'websearch',
+   *     config: 'english'
+   *   })
+   * ```
    */
-  isDistinct<ColumnName extends string>(column: ColumnName, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never): this;
+  textSearch<ColumnName extends string & keyof Row>(column: ColumnName, query: string, options?: {
+    config?: string;
+    type?: 'plain' | 'phrase' | 'websearch';
+  }): this;
+  textSearch(column: string, query: string, options?: {
+    config?: string;
+    type?: 'plain' | 'phrase' | 'websearch';
+  }): this;
   /**
-   * Match only rows where `column` is included in the `values` array.
+   * Match only rows where each column in `query` keys is equal to its
+   * associated value. Shorthand for multiple `.eq()`s.
    *
-   * @param column - The column to filter on
-   * @param values - The values array to filter with
+   * @param query - The object to filter with, with column names as keys mapped
+   * to their filter values
    *
    * @category Database
    * @subcategory Using filters
@@ -1871,8 +3087,8 @@ declare class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions,
    * ```ts
    * const { data, error } = await supabase
    *   .from('characters')
-   *   .select()
-   *   .in('name', ['Leia', 'Han'])
+   *   .select('name')
+   *   .match({ id: 2, name: 'Leia' })
    * ```
    *
    * @exampleSql With `select()`
@@ -1893,12 +3109,7 @@ declare class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions,
    * {
    *   "data": [
    *     {
-   *       "id": 2,
    *       "name": "Leia"
-   *     },
-   *     {
-   *       "id": 3,
-   *       "name": "Han"
    *     }
    *   ],
    *   "status": 200,
@@ -1906,40 +3117,24 @@ declare class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions,
    * }
    * ```
    */
-  in<ColumnName extends string>(column: ColumnName, values: ReadonlyArray<ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never>): this;
+  match<ColumnName extends string & keyof Row>(query: Record<ColumnName, Row[ColumnName]>): this;
+  match(query: Record<string, unknown>): this;
   /**
-   * Match only rows where `column` is NOT included in the `values` array.
+   * Match only rows which doesn't satisfy the filter.
+   *
+   * Unlike most filters, `opearator` and `value` are used as-is and need to
+   * follow [PostgREST
+   * syntax](https://postgrest.org/en/stable/api.html#operators). You also need
+   * to make sure they are properly sanitized.
    *
    * @param column - The column to filter on
-   * @param values - The values array to filter with
+   * @param operator - The operator to be negated to filter with, following
+   * PostgREST syntax
+   * @param value - The value to filter with, following PostgREST syntax
+   *
+   * @category Database
+   * @subcategory Using filters
    */
-  notIn<ColumnName extends string>(column: ColumnName, values: ReadonlyArray<ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never>): this;
-  contains<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]> | Record<string, unknown>): this;
-  contains(column: string, value: string | readonly unknown[] | Record<string, unknown>): this;
-  containedBy<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]> | Record<string, unknown>): this;
-  containedBy(column: string, value: string | readonly unknown[] | Record<string, unknown>): this;
-  rangeGt<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
-  rangeGt(column: string, range: string): this;
-  rangeGte<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
-  rangeGte(column: string, range: string): this;
-  rangeLt<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
-  rangeLt(column: string, range: string): this;
-  rangeLte<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
-  rangeLte(column: string, range: string): this;
-  rangeAdjacent<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
-  rangeAdjacent(column: string, range: string): this;
-  overlaps<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]>): this;
-  overlaps(column: string, value: string | readonly unknown[]): this;
-  textSearch<ColumnName extends string & keyof Row>(column: ColumnName, query: string, options?: {
-    config?: string;
-    type?: 'plain' | 'phrase' | 'websearch';
-  }): this;
-  textSearch(column: string, query: string, options?: {
-    config?: string;
-    type?: 'plain' | 'phrase' | 'websearch';
-  }): this;
-  match<ColumnName extends string & keyof Row>(query: Record<ColumnName, Row[ColumnName]>): this;
-  match(query: Record<string, unknown>): this;
   not<ColumnName extends string & keyof Row>(column: ColumnName, operator: 'is', value: null): PostgrestFilterBuilder<ClientOptions, Schema, NonNullableColumn<Row, ColumnName>, NarrowResultColumn<Result$1, ColumnName>, RelationName, Relationships, Method, ThrowOnError> & this;
   not<ColumnName extends string & keyof Row>(column: ColumnName, operator: FilterOperator, value: Row[ColumnName]): this;
   not(column: string, operator: string, value: unknown): this;
@@ -2101,6 +3296,119 @@ declare class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions,
     foreignTable?: string;
     referencedTable?: string;
   }): this;
+  /**
+   * Match only rows which satisfy the filter. This is an escape hatch - you
+   * should use the specific filter methods wherever possible.
+   *
+   * Unlike most filters, `opearator` and `value` are used as-is and need to
+   * follow [PostgREST
+   * syntax](https://postgrest.org/en/stable/api.html#operators). You also need
+   * to make sure they are properly sanitized.
+   *
+   * @param column - The column to filter on
+   * @param operator - The operator to filter with, following PostgREST syntax
+   * @param value - The value to filter with, following PostgREST syntax
+   *
+   * @category Database
+   * @subcategory Using filters
+   *
+   * @remarks
+   * filter() expects you to use the raw PostgREST syntax for the filter values.
+   *
+   * ```ts
+   * .filter('id', 'in', '(5,6,7)')  // Use `()` for `in` filter
+   * .filter('arraycol', 'cs', '{"a","b"}')  // Use `cs` for `contains()`, `{}` for array values
+   * ```
+   *
+   * @example With `select()`
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('characters')
+   *   .select()
+   *   .filter('name', 'in', '("Han","Yoda")')
+   * ```
+   *
+   * @exampleSql With `select()`
+   * ```sql
+   * create table
+   *   characters (id int8 primary key, name text);
+   *
+   * insert into
+   *   characters (id, name)
+   * values
+   *   (1, 'Luke'),
+   *   (2, 'Leia'),
+   *   (3, 'Han');
+   * ```
+   *
+   * @exampleResponse With `select()`
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "id": 3,
+   *       "name": "Han"
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   *
+   * @example On a referenced table
+   * ```ts
+   * const { data, error } = await supabase
+   *   .from('orchestral_sections')
+   *   .select(`
+   *     name,
+   *     instruments!inner (
+   *       name
+   *     )
+   *   `)
+   *   .filter('instruments.name', 'eq', 'flute')
+   * ```
+   *
+   * @exampleSql On a referenced table
+   * ```sql
+   * create table
+   *   orchestral_sections (id int8 primary key, name text);
+   * create table
+   *    instruments (
+   *     id int8 primary key,
+   *     section_id int8 not null references orchestral_sections,
+   *     name text
+   *   );
+   *
+   * insert into
+   *   orchestral_sections (id, name)
+   * values
+   *   (1, 'strings'),
+   *   (2, 'woodwinds');
+   * insert into
+   *   instruments (id, section_id, name)
+   * values
+   *   (1, 2, 'flute'),
+   *   (2, 1, 'violin');
+   * ```
+   *
+   * @exampleResponse On a referenced table
+   * ```json
+   * {
+   *   "data": [
+   *     {
+   *       "name": "woodwinds",
+   *       "instruments": [
+   *         {
+   *           "name": "flute"
+   *         }
+   *       ]
+   *     }
+   *   ],
+   *   "status": 200,
+   *   "statusText": "OK"
+   * }
+   * ```
+   */
   filter<ColumnName extends string & keyof Row>(column: ColumnName, operator: `${'' | 'not.'}${FilterOperator}`, value: unknown): this;
   filter(column: string, operator: string, value: unknown): this;
 }
@@ -3751,6 +5059,13 @@ declare class PostgrestClient<Database = any, ClientOptions extends ClientServer
     urlLengthLimit?: number;
     retry?: boolean;
   });
+  /**
+   * Perform a query on a table or a view.
+   *
+   * @param relation - The table or view name to query
+   *
+   * @category Database
+   */
   from<TableName$1 extends string & keyof Schema['Tables'], Table extends Schema['Tables'][TableName$1]>(relation: TableName$1): PostgrestQueryBuilder<ClientOptions, Schema, Table, TableName$1>;
   from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<ClientOptions, Schema, View, ViewName>;
   /**