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

package/dist/index.mjs

@@ -1501,1310 +1501,77 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 		this.url.searchParams.append(column, `neq.${value}`);
 		return 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(column, value) {
 		this.url.searchParams.append(column, `gt.${value}`);
 		return 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(column, value) {
 		this.url.searchParams.append(column, `gte.${value}`);
 		return 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(column, value) {
 		this.url.searchParams.append(column, `lt.${value}`);
 		return 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(column, value) {
 		this.url.searchParams.append(column, `lte.${value}`);
 		return 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(column, pattern) {
 		this.url.searchParams.append(column, `like.${pattern}`);
 		return 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(column, patterns) {
 		this.url.searchParams.append(column, `like(all).{${patterns.join(",")}}`);
 		return 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(column, patterns) {
 		this.url.searchParams.append(column, `like(any).{${patterns.join(",")}}`);
 		return 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(column, pattern) {
 		this.url.searchParams.append(column, `ilike.${pattern}`);
 		return 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(column, patterns) {
 		this.url.searchParams.append(column, `ilike(all).{${patterns.join(",")}}`);
 		return 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(column, patterns) {
 		this.url.searchParams.append(column, `ilike(any).{${patterns.join(",")}}`);
 		return 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(column, pattern) {
-		this.url.searchParams.append(column, `match.${pattern}`);
-		return 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(column, pattern) {
-		this.url.searchParams.append(column, `imatch.${pattern}`);
-		return 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(column, value) {
-		this.url.searchParams.append(column, `is.${value}`);
-		return 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(column, value) {
-		this.url.searchParams.append(column, `isdistinct.${value}`);
-		return 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(column, values) {
-		const cleanedValues = Array.from(new Set(values)).map((s) => {
-			if (typeof s === "string" && PostgrestReservedCharsRegexp.test(s)) return `"${s}"`;
-			else return `${s}`;
-		}).join(",");
-		this.url.searchParams.append(column, `in.(${cleanedValues})`);
-		return 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(column, values) {
-		const cleanedValues = Array.from(new Set(values)).map((s) => {
-			if (typeof s === "string" && PostgrestReservedCharsRegexp.test(s)) return `"${s}"`;
-			else return `${s}`;
-		}).join(",");
-		this.url.searchParams.append(column, `not.in.(${cleanedValues})`);
-		return 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(column, value) {
-		if (typeof value === "string") this.url.searchParams.append(column, `cs.${value}`);
-		else if (Array.isArray(value)) this.url.searchParams.append(column, `cs.{${value.join(",")}}`);
-		else this.url.searchParams.append(column, `cs.${JSON.stringify(value)}`);
-		return 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(column, value) {
-		if (typeof value === "string") this.url.searchParams.append(column, `cd.${value}`);
-		else if (Array.isArray(value)) this.url.searchParams.append(column, `cd.{${value.join(",")}}`);
-		else this.url.searchParams.append(column, `cd.${JSON.stringify(value)}`);
-		return 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(column, range) {
-		this.url.searchParams.append(column, `sr.${range}`);
-		return 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(column, range) {
-		this.url.searchParams.append(column, `nxl.${range}`);
-		return 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(column, range) {
-		this.url.searchParams.append(column, `sl.${range}`);
-		return 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(column, range) {
-		this.url.searchParams.append(column, `nxr.${range}`);
-		return 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(column, range) {
-		this.url.searchParams.append(column, `adj.${range}`);
-		return 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
-	*   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"
-	* }
-	* ```
-	*/
-	overlaps(column, value) {
-		if (typeof value === "string") this.url.searchParams.append(column, `ov.${value}`);
-		else this.url.searchParams.append(column, `ov.{${value.join(",")}}`);
+	regexMatch(column, pattern) {
+		this.url.searchParams.append(column, `match.${pattern}`);
+		return this;
+	}
+	regexIMatch(column, pattern) {
+		this.url.searchParams.append(column, `imatch.${pattern}`);
+		return this;
+	}
+	is(column, value) {
+		this.url.searchParams.append(column, `is.${value}`);
 		return this;
 	}
 	/**
-	* Only relevant for text and tsvector columns. Match only rows where
-	* `column` matches the query string in `query`.
-	*
-	* @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
-	*
-	* @remarks
-	* - For more information, see [Postgres full text search](/docs/guides/database/full-text-search).
-	*
-	* @example Text search
-	* ```ts
-	* const result = await supabase
-	*   .from("texts")
-	*   .select("content")
-	*   .textSearch("content", `'eggs' & 'ham'`, {
-	*     config: "english",
-	*   });
-	* ```
-	*
-	* @exampleSql Text search
-	* ```sql
-	* create table texts (
-	*   id      bigint
-	*           primary key
-	*           generated always as identity,
-	*   content text
-	* );
-	*
-	* insert into texts (content) values
-	*     ('Four score and seven years ago'),
-	*     ('The road goes ever on and on'),
-	*     ('Green eggs and ham')
-	* ;
-	* ```
-	*
-	* @exampleResponse Text search
-	* ```json
-	* {
-	*   "data": [
-	*     {
-	*       "content": "Green eggs and ham"
-	*     }
-	*   ],
-	*   "status": 200,
-	*   "statusText": "OK"
-	* }
-	* ```
-	*
-	* @exampleDescription Basic normalization
-	* Uses PostgreSQL's `plainto_tsquery` function.
-	*
-	* @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.
+	* Match only rows where `column` IS DISTINCT FROM `value`.
 	*
-	* - `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.
+	* 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).
 	*
-	* @example Websearch
-	* ```ts
-	* const { data, error } = await supabase
-	*   .from('quotes')
-	*   .select('catchphrase')
-	*   .textSearch('catchphrase', `'fat or cat'`, {
-	*     type: 'websearch',
-	*     config: 'english'
-	*   })
-	* ```
+	* @param column - The column to filter on
+	* @param value - The value to filter with
 	*/
-	textSearch(column, query, { config, type } = {}) {
-		let typePart = "";
-		if (type === "plain") typePart = "pl";
-		else if (type === "phrase") typePart = "ph";
-		else if (type === "websearch") typePart = "w";
-		const configPart = config === void 0 ? "" : `(${config})`;
-		this.url.searchParams.append(column, `${typePart}fts${configPart}.${query}`);
+	isDistinct(column, value) {
+		this.url.searchParams.append(column, `isdistinct.${value}`);
 		return this;
 	}
 	/**
-	* Match only rows where each column in `query` keys is equal to its
-	* associated value. Shorthand for multiple `.eq()`s.
+	* Match only rows where `column` is included in the `values` array.
 	*
-	* @param query - The object to filter with, with column names as keys mapped
-	* to their filter values
+	* @param column - The column to filter on
+	* @param values - The values array to filter with
 	*
 	* @category Database
 	* @subcategory Using filters
@@ -2813,8 +1580,8 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	* ```ts
 	* const { data, error } = await supabase
 	*   .from('characters')
-	*   .select('name')
-	*   .match({ id: 2, name: 'Leia' })
+	*   .select()
+	*   .in('name', ['Leia', 'Han'])
 	* ```
 	*
 	* @exampleSql With `select()`
@@ -2835,7 +1602,12 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	* {
 	*   "data": [
 	*     {
+	*       "id": 2,
 	*       "name": "Leia"
+	*     },
+	*     {
+	*       "id": 3,
+	*       "name": "Han"
 	*     }
 	*   ],
 	*   "status": 200,
@@ -2843,6 +1615,74 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	* }
 	* ```
 	*/
+	in(column, values) {
+		const cleanedValues = Array.from(new Set(values)).map((s) => {
+			if (typeof s === "string" && PostgrestReservedCharsRegexp.test(s)) return `"${s}"`;
+			else return `${s}`;
+		}).join(",");
+		this.url.searchParams.append(column, `in.(${cleanedValues})`);
+		return 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(column, values) {
+		const cleanedValues = Array.from(new Set(values)).map((s) => {
+			if (typeof s === "string" && PostgrestReservedCharsRegexp.test(s)) return `"${s}"`;
+			else return `${s}`;
+		}).join(",");
+		this.url.searchParams.append(column, `not.in.(${cleanedValues})`);
+		return this;
+	}
+	contains(column, value) {
+		if (typeof value === "string") this.url.searchParams.append(column, `cs.${value}`);
+		else if (Array.isArray(value)) this.url.searchParams.append(column, `cs.{${value.join(",")}}`);
+		else this.url.searchParams.append(column, `cs.${JSON.stringify(value)}`);
+		return this;
+	}
+	containedBy(column, value) {
+		if (typeof value === "string") this.url.searchParams.append(column, `cd.${value}`);
+		else if (Array.isArray(value)) this.url.searchParams.append(column, `cd.{${value.join(",")}}`);
+		else this.url.searchParams.append(column, `cd.${JSON.stringify(value)}`);
+		return this;
+	}
+	rangeGt(column, range) {
+		this.url.searchParams.append(column, `sr.${range}`);
+		return this;
+	}
+	rangeGte(column, range) {
+		this.url.searchParams.append(column, `nxl.${range}`);
+		return this;
+	}
+	rangeLt(column, range) {
+		this.url.searchParams.append(column, `sl.${range}`);
+		return this;
+	}
+	rangeLte(column, range) {
+		this.url.searchParams.append(column, `nxr.${range}`);
+		return this;
+	}
+	rangeAdjacent(column, range) {
+		this.url.searchParams.append(column, `adj.${range}`);
+		return this;
+	}
+	overlaps(column, value) {
+		if (typeof value === "string") this.url.searchParams.append(column, `ov.${value}`);
+		else this.url.searchParams.append(column, `ov.{${value.join(",")}}`);
+		return this;
+	}
+	textSearch(column, query, { config, type } = {}) {
+		let typePart = "";
+		if (type === "plain") typePart = "pl";
+		else if (type === "phrase") typePart = "ph";
+		else if (type === "websearch") typePart = "w";
+		const configPart = config === void 0 ? "" : `(${config})`;
+		this.url.searchParams.append(column, `${typePart}fts${configPart}.${query}`);
+		return this;
+	}
 	match(query) {
 		Object.entries(query).filter(([_, value]) => value !== void 0).forEach(([column, value]) => {
 			this.url.searchParams.append(column, `eq.${value}`);
@@ -3068,119 +1908,6 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 		this.url.searchParams.append(key, `(${filters})`);
 		return 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(column, operator, value) {
 		this.url.searchParams.append(column, `${operator}.${value}`);
 		return this;
@@ -4909,13 +3636,6 @@ var PostgrestClient = class PostgrestClient {
 		else this.fetch = originalFetch;
 		this.retry = retry;
 	}
-	/**
-	* Perform a query on a table or a view.
-	*
-	* @param relation - The table or view name to query
-	*
-	* @category Database
-	*/
 	from(relation) {
 		if (!relation || typeof relation !== "string" || relation.trim() === "") throw new Error("Invalid relation name: relation must be a non-empty string.");
 		return new PostgrestQueryBuilder(new URL(`${this.url}/${relation}`), {