@supabase/postgrest-js 2.100.0-rc.0 → 2.100.1

package/dist/index.mjs

@@ -35,7 +35,19 @@ var PostgrestBuilder = class {
 	*
 	* @example
 	* ```ts
-	* import PostgrestQueryBuilder from '@supabase/postgrest-js'
+	* import { PostgrestQueryBuilder } from '@supabase/postgrest-js'
+	*
+	* const builder = new PostgrestQueryBuilder(
+	*   new URL('https://xyzcompany.supabase.co/rest/v1/users'),
+	*   { headers: new Headers({ apikey: 'public-anon-key' }) }
+	* )
+	* ```
+	*
+	* @category Database
+	*
+	* @example Creating a Postgrest query builder
+	* ```ts
+	* import { PostgrestQueryBuilder } from '@supabase/postgrest-js'
 	*
 	* const builder = new PostgrestQueryBuilder(
 	*   new URL('https://xyzcompany.supabase.co/rest/v1/users'),
@@ -63,6 +75,8 @@ var PostgrestBuilder = class {
 	* throwing the error instead of returning it as part of a successful response.
 	*
 	* {@link https://github.com/supabase/supabase-js/issues/92}
+	*
+	* @category Database
 	*/
 	throwOnError() {
 		this.shouldThrowOnError = true;
@@ -70,12 +84,17 @@ var PostgrestBuilder = class {
 	}
 	/**
 	* Set an HTTP header for the request.
+	*
+	* @category Database
 	*/
 	setHeader(name, value) {
 		this.headers = new Headers(this.headers);
 		this.headers.set(name, value);
 		return this;
 	}
+	/**  *
+	* @category Database
+	*/
 	then(onfulfilled, onrejected) {
 		var _this = this;
 		if (this.schema === void 0) {} else if (["GET", "HEAD"].includes(this.method)) this.headers.set("Accept-Profile", this.schema);
@@ -105,7 +124,7 @@ var PostgrestBuilder = class {
 				const countHeader = (_this$headers$get2 = _this.headers.get("Prefer")) === null || _this$headers$get2 === void 0 ? void 0 : _this$headers$get2.match(/count=(exact|planned|estimated)/);
 				const contentRange = (_res$headers$get = res$1.headers.get("content-range")) === null || _res$headers$get === void 0 ? void 0 : _res$headers$get.split("/");
 				if (countHeader && contentRange && contentRange.length > 1) count = parseInt(contentRange[1]);
-				if (_this.isMaybeSingle && _this.method === "GET" && Array.isArray(data)) if (data.length > 1) {
+				if (_this.isMaybeSingle && Array.isArray(data)) if (data.length > 1) {
 					error = {
 						code: "PGRST116",
 						details: `Results contain ${data.length} rows, application/vnd.pgrst.object+json requires 1 row`,
@@ -119,7 +138,6 @@ var PostgrestBuilder = class {
 				} else if (data.length === 1) data = data[0];
 				else data = null;
 			} else {
-				var _error$details;
 				const body = await res$1.text();
 				try {
 					error = JSON.parse(body);
@@ -135,11 +153,6 @@ var PostgrestBuilder = class {
 						statusText = "No Content";
 					} else error = { message: body };
 				}
-				if (error && _this.isMaybeSingle && (error === null || error === void 0 || (_error$details = error.details) === null || _error$details === void 0 ? void 0 : _error$details.includes("0 rows"))) {
-					error = null;
-					status = 200;
-					statusText = "OK";
-				}
 				if (error && _this.shouldThrowOnError) throw new PostgrestError(error);
 			}
 			return {
@@ -198,6 +211,8 @@ var PostgrestBuilder = class {
 	*
 	* @typeParam NewResult - The new result type to override with
 	* @deprecated Use overrideTypes<yourType, { merge: false }>() method at the end of your call chain instead
+	*
+	* @category Database
 	*/
 	returns() {
 		/* istanbul ignore next */
@@ -224,6 +239,77 @@ var PostgrestBuilder = class {
 	*   .overrideTypes<{ id: number; name: string }, { merge: false }>()
 	* ```
 	* @returns A PostgrestBuilder instance with the new type
+	*
+	* @category Database
+	*
+	* @example Complete Override type of successful response
+	* ```ts
+	* const { data } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .overrideTypes<Array<MyType>, { merge: false }>()
+	* ```
+	*
+	* @exampleResponse Complete Override type of successful response
+	* ```ts
+	* let x: typeof data // MyType[]
+	* ```
+	*
+	* @example Complete Override type of object response
+	* ```ts
+	* const { data } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .maybeSingle()
+	*   .overrideTypes<MyType, { merge: false }>()
+	* ```
+	*
+	* @exampleResponse Complete Override type of object response
+	* ```ts
+	* let x: typeof data // MyType | null
+	* ```
+	*
+	* @example Partial Override type of successful response
+	* ```ts
+	* const { data } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .overrideTypes<Array<{ status: "A" | "B" }>>()
+	* ```
+	*
+	* @exampleResponse Partial Override type of successful response
+	* ```ts
+	* let x: typeof data // Array<CountryRowProperties & { status: "A" | "B" }>
+	* ```
+	*
+	* @example Partial Override type of object response
+	* ```ts
+	* const { data } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .maybeSingle()
+	*   .overrideTypes<{ status: "A" | "B" }>()
+	* ```
+	*
+	* @exampleResponse Partial Override type of object response
+	* ```ts
+	* let x: typeof data // CountryRowProperties & { status: "A" | "B" } | null
+	* ```
+	*
+	* @example Example 5
+	* ```typescript
+	* // Merge with existing types (default behavior)
+	* const query = supabase
+	*   .from('users')
+	*   .select()
+	*   .overrideTypes<{ custom_field: string }>()
+	*
+	* // Replace existing types completely
+	* const replaceQuery = supabase
+	*   .from('users')
+	*   .select()
+	*   .overrideTypes<{ id: number; name: string }, { merge: false }>()
+	* ```
 	*/
 	overrideTypes() {
 		return this;
@@ -241,6 +327,41 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	* `data`.
 	*
 	* @param columns - The columns to retrieve, separated by commas
+	*
+	* @category Database
+	*
+	* @example With `upsert()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .upsert({ id: 1, name: 'Han Solo' })
+	*   .select()
+	* ```
+	*
+	* @exampleSql With `upsert()`
+	* ```sql
+	* create table
+	*   characters (id int8 primary key, name text);
+	*
+	* insert into
+	*   characters (id, name)
+	* values
+	*   (1, 'Han');
+	* ```
+	*
+	* @exampleResponse With `upsert()`
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "id": 1,
+	*       "name": "Han Solo"
+	*     }
+	*   ],
+	*   "status": 201,
+	*   "statusText": "Created"
+	* }
+	* ```
 	*/
 	select(columns) {
 		let quoted = false;
@@ -270,6 +391,176 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	* its columns
 	* @param options.foreignTable - Deprecated, use `options.referencedTable`
 	* instead
+	*
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('id, name')
+	*   .order('id', { ascending: false })
+	* ```
+	*
+	* @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"
+	*     },
+	*     {
+	*       "id": 2,
+	*       "name": "Leia"
+	*     },
+	*     {
+	*       "id": 1,
+	*       "name": "Luke"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @exampleDescription On a referenced table
+	* Ordering with `referencedTable` doesn't affect the ordering of the
+	* parent table.
+	*
+	* @example On a referenced table
+	* ```ts
+	*   const { data, error } = await supabase
+	*     .from('orchestral_sections')
+	*     .select(`
+	*       name,
+	*       instruments (
+	*         name
+	*       )
+	*     `)
+	*     .order('name', { referencedTable: 'instruments', ascending: false })
+	*
+	* ```
+	*
+	* @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, 1, 'harp'),
+	*   (2, 1, 'violin');
+	* ```
+	*
+	* @exampleResponse On a referenced table
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "name": "strings",
+	*       "instruments": [
+	*         {
+	*           "name": "violin"
+	*         },
+	*         {
+	*           "name": "harp"
+	*         }
+	*       ]
+	*     },
+	*     {
+	*       "name": "woodwinds",
+	*       "instruments": []
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @exampleDescription Order parent table by a referenced table
+	* Ordering with `referenced_table(col)` affects the ordering of the
+	* parent table.
+	*
+	* @example Order parent table by a referenced table
+	* ```ts
+	*   const { data, error } = await supabase
+	*     .from('instruments')
+	*     .select(`
+	*       name,
+	*       section:orchestral_sections (
+	*         name
+	*       )
+	*     `)
+	*     .order('section(name)', { ascending: true })
+	*
+	* ```
+	*
+	* @exampleSql Order parent table by 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 Order parent table by a referenced table
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "name": "violin",
+	*       "orchestral_sections": {"name": "strings"}
+	*     },
+	*     {
+	*       "name": "flute",
+	*       "orchestral_sections": {"name": "woodwinds"}
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	order(column, { ascending = true, nullsFirst, foreignTable, referencedTable = foreignTable } = {}) {
 		const key = referencedTable ? `${referencedTable}.order` : "order";
@@ -286,28 +577,156 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	* tables instead of the parent table
 	* @param options.foreignTable - Deprecated, use `options.referencedTable`
 	* instead
-	*/
-	limit(count, { foreignTable, referencedTable = foreignTable } = {}) {
-		const key = typeof referencedTable === "undefined" ? "limit" : `${referencedTable}.limit`;
-		this.url.searchParams.set(key, `${count}`);
-		return this;
-	}
-	/**
-	* Limit the query result by starting at an offset `from` and ending at the offset `to`.
-	* Only records within this range are returned.
-	* This respects the query order and if there is no order clause the range could behave unexpectedly.
-	* The `from` and `to` values are 0-based and inclusive: `range(1, 3)` will include the second, third
-	* and fourth rows of the query.
 	*
-	* @param from - The starting index from which to limit the result
-	* @param to - The last index to which to limit the result
-	* @param options - Named parameters
-	* @param options.referencedTable - Set this to limit rows of referenced
-	* tables instead of the parent table
-	* @param options.foreignTable - Deprecated, use `options.referencedTable`
-	* instead
-	*/
-	range(from, to, { foreignTable, referencedTable = foreignTable } = {}) {
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('name')
+	*   .limit(1)
+	* ```
+	*
+	* @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": [
+	*     {
+	*       "name": "Luke"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @example On a referenced table
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('orchestral_sections')
+	*   .select(`
+	*     name,
+	*     instruments (
+	*       name
+	*     )
+	*   `)
+	*   .limit(1, { referencedTable: 'instruments' })
+	* ```
+	*
+	* @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');
+	* insert into
+	*   instruments (id, section_id, name)
+	* values
+	*   (1, 1, 'harp'),
+	*   (2, 1, 'violin');
+	* ```
+	*
+	* @exampleResponse On a referenced table
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "name": "strings",
+	*       "instruments": [
+	*         {
+	*           "name": "violin"
+	*         }
+	*       ]
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*/
+	limit(count, { foreignTable, referencedTable = foreignTable } = {}) {
+		const key = typeof referencedTable === "undefined" ? "limit" : `${referencedTable}.limit`;
+		this.url.searchParams.set(key, `${count}`);
+		return this;
+	}
+	/**
+	* Limit the query result by starting at an offset `from` and ending at the offset `to`.
+	* Only records within this range are returned.
+	* This respects the query order and if there is no order clause the range could behave unexpectedly.
+	* The `from` and `to` values are 0-based and inclusive: `range(1, 3)` will include the second, third
+	* and fourth rows of the query.
+	*
+	* @param from - The starting index from which to limit the result
+	* @param to - The last index to which to limit the result
+	* @param options - Named parameters
+	* @param options.referencedTable - Set this to limit rows of referenced
+	* tables instead of the parent table
+	* @param options.foreignTable - Deprecated, use `options.referencedTable`
+	* instead
+	*
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('name')
+	*   .range(0, 1)
+	* ```
+	*
+	* @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": [
+	*     {
+	*       "name": "Luke"
+	*     },
+	*     {
+	*       "name": "Leia"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*/
+	range(from, to, { foreignTable, referencedTable = foreignTable } = {}) {
 		const keyOffset = typeof referencedTable === "undefined" ? "offset" : `${referencedTable}.offset`;
 		const keyLimit = typeof referencedTable === "undefined" ? "limit" : `${referencedTable}.limit`;
 		this.url.searchParams.set(keyOffset, `${from}`);
@@ -318,6 +737,66 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	* Set the AbortSignal for the fetch request.
 	*
 	* @param signal - The AbortSignal to use for the fetch request
+	*
+	* @category Database
+	*
+	* @remarks
+	* You can use this to set a timeout for the request.
+	*
+	* @exampleDescription Aborting requests in-flight
+	* You can use an [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) to abort requests.
+	* Note that `status` and `statusText` don't mean anything for aborted requests as the request wasn't fulfilled.
+	*
+	* @example Aborting requests in-flight
+	* ```ts
+	* const ac = new AbortController()
+	*
+	* const { data, error } = await supabase
+	*   .from('very_big_table')
+	*   .select()
+	*   .abortSignal(ac.signal)
+	*
+	* // Abort the request after 100 ms
+	* setTimeout(() => ac.abort(), 100)
+	* ```
+	*
+	* @exampleResponse Aborting requests in-flight
+	* ```json
+	*   {
+	*     "error": {
+	*       "message": "AbortError: The user aborted a request.",
+	*       "details": "",
+	*       "hint": "The request was aborted locally via the provided AbortSignal.",
+	*       "code": ""
+	*     },
+	*     "status": 0,
+	*     "statusText": ""
+	*   }
+	*
+	* ```
+	*
+	* @example Set a timeout
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('very_big_table')
+	*   .select()
+	*   .abortSignal(AbortSignal.timeout(1000 /* ms *\/))
+	* ```
+	*
+	* @exampleResponse Set a timeout
+	* ```json
+	*   {
+	*     "error": {
+	*       "message": "FetchError: The user aborted a request.",
+	*       "details": "",
+	*       "hint": "",
+	*       "code": ""
+	*     },
+	*     "status": 400,
+	*     "statusText": "Bad Request"
+	*   }
+	*
+	* ```
 	*/
 	abortSignal(signal) {
 		this.signal = signal;
@@ -328,6 +807,41 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	*
 	* Query result must be one row (e.g. using `.limit(1)`), otherwise this
 	* returns an error.
+	*
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('name')
+	*   .limit(1)
+	*   .single()
+	* ```
+	*
+	* @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": {
+	*     "name": "Luke"
+	*   },
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	single() {
 		this.headers.set("Accept", "application/vnd.pgrst.object+json");
@@ -338,15 +852,80 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	*
 	* Query result must be zero or one row (e.g. using `.limit(1)`), otherwise
 	* this returns an error.
+	*
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select()
+	*   .eq('name', 'Katniss')
+	*   .maybeSingle()
+	* ```
+	*
+	* @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
+	* {
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	maybeSingle() {
-		if (this.method === "GET") this.headers.set("Accept", "application/json");
-		else this.headers.set("Accept", "application/vnd.pgrst.object+json");
 		this.isMaybeSingle = true;
 		return this;
 	}
 	/**
 	* Return `data` as a string in CSV format.
+	*
+	* @category Database
+	*
+	* @exampleDescription Return data as CSV
+	* By default, the data is returned in JSON format, but can also be returned as Comma Separated Values.
+	*
+	* @example Return data as CSV
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select()
+	*   .csv()
+	* ```
+	*
+	* @exampleSql Return data as CSV
+	* ```sql
+	* create table
+	*   characters (id int8 primary key, name text);
+	*
+	* insert into
+	*   characters (id, name)
+	* values
+	*   (1, 'Luke'),
+	*   (2, 'Leia'),
+	*   (3, 'Han');
+	* ```
+	*
+	* @exampleResponse Return data as CSV
+	* ```json
+	* {
+	*   "data": "id,name\n1,Luke\n2,Leia\n3,Han",
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	csv() {
 		this.headers.set("Accept", "text/csv");
@@ -354,6 +933,8 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	}
 	/**
 	* Return `data` as an object in [GeoJSON](https://geojson.org) format.
+	*
+	* @category Database
 	*/
 	geojson() {
 		this.headers.set("Accept", "application/geo+json");
@@ -383,12 +964,82 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	*
 	* @param options.format - The format of the output, can be `"text"` (default)
 	* or `"json"`
-	*/
-	explain({ analyze = false, verbose = false, settings = false, buffers = false, wal = false, format = "text" } = {}) {
-		var _this$headers$get;
-		const options = [
-			analyze ? "analyze" : null,
-			verbose ? "verbose" : null,
+	*
+	* @category Database
+	*
+	* @exampleDescription Get the execution plan
+	* By default, the data is returned in TEXT format, but can also be returned as JSON by using the `format` parameter.
+	*
+	* @example Get the execution plan
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select()
+	*   .explain()
+	* ```
+	*
+	* @exampleSql Get the execution plan
+	* ```sql
+	* create table
+	*   characters (id int8 primary key, name text);
+	*
+	* insert into
+	*   characters (id, name)
+	* values
+	*   (1, 'Luke'),
+	*   (2, 'Leia'),
+	*   (3, 'Han');
+	* ```
+	*
+	* @exampleResponse Get the execution plan
+	* ```js
+	* Aggregate  (cost=33.34..33.36 rows=1 width=112)
+	*   ->  Limit  (cost=0.00..18.33 rows=1000 width=40)
+	*         ->  Seq Scan on characters  (cost=0.00..22.00 rows=1200 width=40)
+	* ```
+	*
+	* @exampleDescription Get the execution plan with analyze and verbose
+	* By default, the data is returned in TEXT format, but can also be returned as JSON by using the `format` parameter.
+	*
+	* @example Get the execution plan with analyze and verbose
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select()
+	*   .explain({analyze:true,verbose:true})
+	* ```
+	*
+	* @exampleSql Get the execution plan with analyze and verbose
+	* ```sql
+	* create table
+	*   characters (id int8 primary key, name text);
+	*
+	* insert into
+	*   characters (id, name)
+	* values
+	*   (1, 'Luke'),
+	*   (2, 'Leia'),
+	*   (3, 'Han');
+	* ```
+	*
+	* @exampleResponse Get the execution plan with analyze and verbose
+	* ```js
+	* Aggregate  (cost=33.34..33.36 rows=1 width=112) (actual time=0.041..0.041 rows=1 loops=1)
+	*   Output: NULL::bigint, count(ROW(characters.id, characters.name)), COALESCE(json_agg(ROW(characters.id, characters.name)), '[]'::json), NULLIF(current_setting('response.headers'::text, true), ''::text), NULLIF(current_setting('response.status'::text, true), ''::text)
+	*   ->  Limit  (cost=0.00..18.33 rows=1000 width=40) (actual time=0.005..0.006 rows=3 loops=1)
+	*         Output: characters.id, characters.name
+	*         ->  Seq Scan on public.characters  (cost=0.00..22.00 rows=1200 width=40) (actual time=0.004..0.005 rows=3 loops=1)
+	*               Output: characters.id, characters.name
+	* Query Identifier: -4730654291623321173
+	* Planning Time: 0.407 ms
+	* Execution Time: 0.119 ms
+	* ```
+	*/
+	explain({ analyze = false, verbose = false, settings = false, buffers = false, wal = false, format = "text" } = {}) {
+		var _this$headers$get;
+		const options = [
+			analyze ? "analyze" : null,
+			verbose ? "verbose" : null,
 			settings ? "settings" : null,
 			buffers ? "buffers" : null,
 			wal ? "wal" : null
@@ -402,6 +1053,8 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	* Rollback the query.
 	*
 	* `data` will still be returned, but the query is not committed.
+	*
+	* @category Database
 	*/
 	rollback() {
 		this.headers.append("Prefer", "tx=rollback");
@@ -412,6 +1065,38 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	*
 	* @typeParam NewResult - The new result type to override with
 	* @deprecated Use overrideTypes<yourType, { merge: false }>() method at the end of your call chain instead
+	*
+	* @category Database
+	*
+	* @remarks
+	* - Deprecated: use overrideTypes method instead
+	*
+	* @example Override type of successful response
+	* ```ts
+	* const { data } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .returns<Array<MyType>>()
+	* ```
+	*
+	* @exampleResponse Override type of successful response
+	* ```js
+	* let x: typeof data // MyType[]
+	* ```
+	*
+	* @example Override type of object response
+	* ```ts
+	* const { data } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .maybeSingle()
+	*   .returns<MyType>()
+	* ```
+	*
+	* @exampleResponse Override type of object response
+	* ```js
+	* let x: typeof data // MyType | null
+	* ```
 	*/
 	returns() {
 		return this;
@@ -421,6 +1106,8 @@ var PostgrestTransformBuilder = class extends PostgrestBuilder {
 	* Only available in PostgREST v13+ and only works with PATCH and DELETE methods.
 	*
 	* @param value - The maximum number of rows that can be affected
+	*
+	* @category Database
 	*/
 	maxAffected(value) {
 		this.headers.append("Prefer", "handling=strict");
@@ -440,6 +1127,43 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
+	*
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select()
+	*   .eq('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": 2,
+	*       "name": "Leia"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	eq(column, value) {
 		this.url.searchParams.append(column, `eq.${value}`);
@@ -450,6 +1174,47 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
+	*
+	* @category Database
+	*
+	* @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(column, value) {
 		this.url.searchParams.append(column, `neq.${value}`);
@@ -460,6 +1225,47 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
+	*
+	* @category Database
+	*
+	* @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}`);
@@ -470,6 +1276,47 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
+	*
+	* @category Database
+	*
+	* @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}`);
@@ -480,6 +1327,43 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
+	*
+	* @category Database
+	*
+	* @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}`);
@@ -490,18 +1374,96 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
-	*/
-	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
-	*/
-	like(column, pattern) {
+	* @category Database
+	*
+	* @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
+	*
+	* @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;
 	}
@@ -510,6 +1472,8 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param patterns - The patterns to match with
+	*
+	* @category Database
 	*/
 	likeAllOf(column, patterns) {
 		this.url.searchParams.append(column, `like(all).{${patterns.join(",")}}`);
@@ -520,6 +1484,8 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param patterns - The patterns to match with
+	*
+	* @category Database
 	*/
 	likeAnyOf(column, patterns) {
 		this.url.searchParams.append(column, `like(any).{${patterns.join(",")}}`);
@@ -530,6 +1496,43 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param pattern - The pattern to match with
+	*
+	* @category Database
+	*
+	* @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}`);
@@ -540,6 +1543,8 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param patterns - The patterns to match with
+	*
+	* @category Database
 	*/
 	ilikeAllOf(column, patterns) {
 		this.url.searchParams.append(column, `ilike(all).{${patterns.join(",")}}`);
@@ -550,6 +1555,8 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param patterns - The patterns to match with
+	*
+	* @category Database
 	*/
 	ilikeAnyOf(column, patterns) {
 		this.url.searchParams.append(column, `ilike(any).{${patterns.join(",")}}`);
@@ -588,6 +1595,47 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param value - The value to filter with
+	*
+	* @category Database
+	*
+	* @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}`);
@@ -612,6 +1660,47 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The column to filter on
 	* @param values - The values array to filter with
+	*
+	* @category Database
+	*
+	* @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) => {
@@ -641,72 +1730,506 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The jsonb, array, or range column to filter on
 	* @param value - The jsonb, array, or range value to filter with
-	*/
-	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
-	*/
-	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`.
+	* @category Database
 	*
-	* @param column - The range column to filter on
-	* @param range - The range to filter with
-	*/
-	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`.
+	* @example On array columns
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('issues')
+	*   .select()
+	*   .contains('tags', ['is:open', 'priority:low'])
+	* ```
 	*
-	* @param column - The range column to filter on
-	* @param range - The range to filter with
-	*/
-	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`.
+	* @exampleSql On array columns
+	* ```sql
+	* create table
+	*   issues (
+	*     id int8 primary key,
+	*     title text,
+	*     tags text[]
+	*   );
 	*
-	* @param column - The range column to filter on
-	* @param range - The range to filter with
-	*/
-	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`.
+	* 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']);
+	* ```
 	*
-	* @param column - The range column to filter on
-	* @param range - The range to filter with
-	*/
-	rangeLte(column, range) {
-		this.url.searchParams.append(column, `nxr.${range}`);
-		return this;
-	}
+	* @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
+	*
+	* @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
+	*
+	* @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
+	*
+	* @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
+	*
+	* @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
+	*
+	* @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
@@ -714,6 +2237,53 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param column - The range column to filter on
 	* @param range - The range to filter with
+	*
+	* @category Database
+	*
+	* @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}`);
@@ -723,23 +2293,200 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	* 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
-	*/
-	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;
-	}
-	/**
-	* Only relevant for text and tsvector columns. Match only rows where
-	* `column` matches the query string in `query`.
+	* @param column - The array or range column to filter on
+	* @param value - The array or range value to filter with
+	*
+	* @category Database
+	*
+	* @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(",")}}`);
+		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
+	*
+	* @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.
 	*
-	* @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
+	* - `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'
+	*   })
+	* ```
 	*/
 	textSearch(column, query, { config, type } = {}) {
 		let typePart = "";
@@ -756,9 +2503,45 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	*
 	* @param query - The object to filter with, with column names as keys mapped
 	* to their filter values
+	*
+	* @category Database
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('name')
+	*   .match({ id: 2, 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": [
+	*     {
+	*       "name": "Leia"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	match(query) {
-		Object.entries(query).forEach(([column, value]) => {
+		Object.entries(query).filter(([_, value]) => value !== void 0).forEach(([column, value]) => {
 			this.url.searchParams.append(column, `eq.${value}`);
 		});
 		return this;
@@ -775,6 +2558,51 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	* @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
+	*
+	* @remarks
+	* not() expects you to use the raw PostgREST syntax for the filter values.
+	*
+	* ```ts
+	* .not('id', 'in', '(5,6,7)')  // Use `()` for `in` filter
+	* .not('arraycol', 'cs', '{"a","b"}')  // Use `cs` for `contains()`, `{}` for array values
+	* ```
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('countries')
+	*   .select()
+	*   .not('name', 'is', null)
+	* ```
+	*
+	* @exampleSql With `select()`
+	* ```sql
+	* create table
+	*   countries (id int8 primary key, name text);
+	*
+	* insert into
+	*   countries (id, name)
+	* values
+	*   (1, 'null'),
+	*   (2, null);
+	* ```
+	*
+	* @exampleResponse With `select()`
+	* ```json
+	*   {
+	*     "data": [
+	*       {
+	*         "id": 1,
+	*         "name": "null"
+	*       }
+	*     ],
+	*     "status": 200,
+	*     "statusText": "OK"
+	*   }
+	*
+	* ```
 	*/
 	not(column, operator, value) {
 		this.url.searchParams.append(column, `not.${operator}.${value}`);
@@ -787,31 +2615,265 @@ var PostgrestFilterBuilder = class extends PostgrestTransformBuilder {
 	* syntax](https://postgrest.org/en/stable/api.html#operators). You also need
 	* to make sure it's properly sanitized.
 	*
-	* It's currently not possible to do an `.or()` filter across multiple tables.
+	* It's currently not possible to do an `.or()` filter across multiple tables.
+	*
+	* @param filters - The filters to use, following PostgREST syntax
+	* @param options - Named parameters
+	* @param options.referencedTable - Set this to filter on referenced tables
+	* instead of the parent table
+	* @param options.foreignTable - Deprecated, use `referencedTable` instead
+	*
+	* @category Database
+	*
+	* @remarks
+	* or() expects you to use the raw PostgREST syntax for the filter names and values.
+	*
+	* ```ts
+	* .or('id.in.(5,6,7), arraycol.cs.{"a","b"}')  // Use `()` for `in` filter, `{}` for array values and `cs` for `contains()`.
+	* .or('id.in.(5,6,7), arraycol.cd.{"a","b"}')  // Use `cd` for `containedBy()`
+	* ```
+	*
+	* @example With `select()`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('name')
+	*   .or('id.eq.2,name.eq.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": [
+	*     {
+	*       "name": "Leia"
+	*     },
+	*     {
+	*       "name": "Han"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @example Use `or` with `and`
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('characters')
+	*   .select('name')
+	*   .or('id.gt.3,and(id.eq.1,name.eq.Luke)')
+	* ```
+	*
+	* @exampleSql Use `or` with `and`
+	* ```sql
+	* create table
+	*   characters (id int8 primary key, name text);
+	*
+	* insert into
+	*   characters (id, name)
+	* values
+	*   (1, 'Luke'),
+	*   (2, 'Leia'),
+	*   (3, 'Han');
+	* ```
+	*
+	* @exampleResponse Use `or` with `and`
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "name": "Luke"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @example Use `or` on referenced tables
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('orchestral_sections')
+	*   .select(`
+	*     name,
+	*     instruments!inner (
+	*       name
+	*     )
+	*   `)
+	*   .or('section_id.eq.1,name.eq.guzheng', { referencedTable: 'instruments' })
+	* ```
+	*
+	* @exampleSql Use `or` on referenced tables
+	* ```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 Use `or` on referenced tables
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "name": "strings",
+	*       "instruments": [
+	*         {
+	*           "name": "violin"
+	*         }
+	*       ]
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*/
+	or(filters, { foreignTable, referencedTable = foreignTable } = {}) {
+		const key = referencedTable ? `${referencedTable}.or` : "or";
+		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
+	*
+	* @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')
+	* ```
 	*
-	* @param filters - The filters to use, following PostgREST syntax
-	* @param options - Named parameters
-	* @param options.referencedTable - Set this to filter on referenced tables
-	* instead of the parent table
-	* @param options.foreignTable - Deprecated, use `referencedTable` instead
-	*/
-	or(filters, { foreignTable, referencedTable = foreignTable } = {}) {
-		const key = referencedTable ? `${referencedTable}.or` : "or";
-		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.
+	* @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
+	*   );
 	*
-	* 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.
+	* 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');
+	* ```
 	*
-	* @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
+	* @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}`);
@@ -825,9 +2887,11 @@ var PostgrestQueryBuilder = class {
 	/**
 	* Creates a query builder scoped to a Postgres table or view.
 	*
-	* @example
+	* @category Database
+	*
+	* @example Creating a Postgrest query builder
 	* ```ts
-	* import PostgrestQueryBuilder from '@supabase/postgrest-js'
+	* import { PostgrestQueryBuilder } from '@supabase/postgrest-js'
 	*
 	* const query = new PostgrestQueryBuilder(
 	*   new URL('https://xyzcompany.supabase.co/rest/v1/users'),
@@ -2190,6 +4254,105 @@ var PostgrestQueryBuilder = class {
 	*
 	* `"estimated"`: Uses exact count for low numbers and planned count for high
 	* numbers.
+	*
+	* @category Database
+	*
+	* @remarks
+	* - `delete()` should always be combined with [filters](/docs/reference/javascript/using-filters) to target the item(s) you wish to delete.
+	* - If you use `delete()` with filters and you have
+	*   [RLS](/docs/learn/auth-deep-dive/auth-row-level-security) enabled, only
+	*   rows visible through `SELECT` policies are deleted. Note that by default
+	*   no rows are visible, so you need at least one `SELECT`/`ALL` policy that
+	*   makes the rows visible.
+	* - When using `delete().in()`, specify an array of values to target multiple rows with a single query. This is particularly useful for batch deleting entries that share common criteria, such as deleting users by their IDs. Ensure that the array you provide accurately represents all records you intend to delete to avoid unintended data removal.
+	*
+	* @example Delete a single record
+	* ```ts
+	* const response = await supabase
+	*   .from('countries')
+	*   .delete()
+	*   .eq('id', 1)
+	* ```
+	*
+	* @exampleSql Delete a single record
+	* ```sql
+	* create table
+	*   countries (id int8 primary key, name text);
+	*
+	* insert into
+	*   countries (id, name)
+	* values
+	*   (1, 'Mordor');
+	* ```
+	*
+	* @exampleResponse Delete a single record
+	* ```json
+	* {
+	*   "status": 204,
+	*   "statusText": "No Content"
+	* }
+	* ```
+	*
+	* @example Delete a record and return it
+	* ```ts
+	* const { data, error } = await supabase
+	*   .from('countries')
+	*   .delete()
+	*   .eq('id', 1)
+	*   .select()
+	* ```
+	*
+	* @exampleSql Delete a record and return it
+	* ```sql
+	* create table
+	*   countries (id int8 primary key, name text);
+	*
+	* insert into
+	*   countries (id, name)
+	* values
+	*   (1, 'Mordor');
+	* ```
+	*
+	* @exampleResponse Delete a record and return it
+	* ```json
+	* {
+	*   "data": [
+	*     {
+	*       "id": 1,
+	*       "name": "Mordor"
+	*     }
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @example Delete multiple records
+	* ```ts
+	* const response = await supabase
+	*   .from('countries')
+	*   .delete()
+	*   .in('id', [1, 2, 3])
+	* ```
+	*
+	* @exampleSql Delete multiple records
+	* ```sql
+	* create table
+	*   countries (id int8 primary key, name text);
+	*
+	* insert into
+	*   countries (id, name)
+	* values
+	*   (1, 'Rohan'), (2, 'The Shire'), (3, 'Mordor');
+	* ```
+	*
+	* @exampleResponse Delete multiple records
+	* ```json
+	* {
+	*   "status": 204,
+	*   "statusText": "No Content"
+	* }
+	* ```
 	*/
 	delete({ count } = {}) {
 		var _this$fetch4;
@@ -2298,7 +4461,34 @@ var PostgrestClient = class PostgrestClient {
 	* @param options.urlLengthLimit - Maximum URL length in characters before warnings/errors are triggered. Defaults to 8000.
 	* @example
 	* ```ts
-	* import PostgrestClient from '@supabase/postgrest-js'
+	* import { PostgrestClient } from '@supabase/postgrest-js'
+	*
+	* const postgrest = new PostgrestClient('https://xyzcompany.supabase.co/rest/v1', {
+	*   headers: { apikey: 'public-anon-key' },
+	*   schema: 'public',
+	*   timeout: 30000, // 30 second timeout
+	* })
+	* ```
+	*
+	* @category Database
+	*
+	* @remarks
+	* - A `timeout` option (in milliseconds) can be set to automatically abort requests that take too long.
+	* - A `urlLengthLimit` option (default: 8000) can be set to control when URL length warnings are included in error messages for aborted requests.
+	*
+	* @example Creating a Postgrest client
+	* ```ts
+	* import { PostgrestClient } from '@supabase/postgrest-js'
+	*
+	* const postgrest = new PostgrestClient('https://xyzcompany.supabase.co/rest/v1', {
+	*   headers: { apikey: 'public-anon-key' },
+	*   schema: 'public',
+	* })
+	* ```
+	*
+	* @example With timeout
+	* ```ts
+	* import { PostgrestClient } from '@supabase/postgrest-js'
 	*
 	* const postgrest = new PostgrestClient('https://xyzcompany.supabase.co/rest/v1', {
 	*   headers: { apikey: 'public-anon-key' },
@@ -2340,6 +4530,8 @@ var PostgrestClient = class PostgrestClient {
 	* 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.");
@@ -2356,6 +4548,8 @@ var PostgrestClient = class PostgrestClient {
 	* The schema needs to be on the list of exposed schemas inside Supabase.
 	*
 	* @param schema - The schema to query
+	*
+	* @category Database
 	*/
 	schema(schema) {
 		return new PostgrestClient(this.url, {
@@ -2396,6 +4590,139 @@ var PostgrestClient = class PostgrestClient {
 	*   .rpc('function_a', {})
 	*   .overrideTypes<{ id: string; user_id: string }[]>()
 	* ```
+	*
+	* @category Database
+	*
+	* @example Call a Postgres function without arguments
+	* ```ts
+	* const { data, error } = await supabase.rpc('hello_world')
+	* ```
+	*
+	* @exampleSql Call a Postgres function without arguments
+	* ```sql
+	* create function hello_world() returns text as $$
+	*   select 'Hello world';
+	* $$ language sql;
+	* ```
+	*
+	* @exampleResponse Call a Postgres function without arguments
+	* ```json
+	* {
+	*   "data": "Hello world",
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @example Call a Postgres function with arguments
+	* ```ts
+	* const { data, error } = await supabase.rpc('echo', { say: '👋' })
+	* ```
+	*
+	* @exampleSql Call a Postgres function with arguments
+	* ```sql
+	* create function echo(say text) returns text as $$
+	*   select say;
+	* $$ language sql;
+	* ```
+	*
+	* @exampleResponse Call a Postgres function with arguments
+	* ```json
+	*   {
+	*     "data": "👋",
+	*     "status": 200,
+	*     "statusText": "OK"
+	*   }
+	*
+	* ```
+	*
+	* @exampleDescription Bulk processing
+	* You can process large payloads by passing in an array as an argument.
+	*
+	* @example Bulk processing
+	* ```ts
+	* const { data, error } = await supabase.rpc('add_one_each', { arr: [1, 2, 3] })
+	* ```
+	*
+	* @exampleSql Bulk processing
+	* ```sql
+	* create function add_one_each(arr int[]) returns int[] as $$
+	*   select array_agg(n + 1) from unnest(arr) as n;
+	* $$ language sql;
+	* ```
+	*
+	* @exampleResponse Bulk processing
+	* ```json
+	* {
+	*   "data": [
+	*     2,
+	*     3,
+	*     4
+	*   ],
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @exampleDescription Call a Postgres function with filters
+	* Postgres functions that return tables can also be combined with [Filters](/docs/reference/javascript/using-filters) and [Modifiers](/docs/reference/javascript/using-modifiers).
+	*
+	* @example Call a Postgres function with filters
+	* ```ts
+	* const { data, error } = await supabase
+	*   .rpc('list_stored_countries')
+	*   .eq('id', 1)
+	*   .single()
+	* ```
+	*
+	* @exampleSql Call a Postgres function with filters
+	* ```sql
+	* create table
+	*   countries (id int8 primary key, name text);
+	*
+	* insert into
+	*   countries (id, name)
+	* values
+	*   (1, 'Rohan'),
+	*   (2, 'The Shire');
+	*
+	* create function list_stored_countries() returns setof countries as $$
+	*   select * from countries;
+	* $$ language sql;
+	* ```
+	*
+	* @exampleResponse Call a Postgres function with filters
+	* ```json
+	* {
+	*   "data": {
+	*     "id": 1,
+	*     "name": "Rohan"
+	*   },
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
+	*
+	* @example Call a read-only Postgres function
+	* ```ts
+	* const { data, error } = await supabase.rpc('hello_world', undefined, { get: true })
+	* ```
+	*
+	* @exampleSql Call a read-only Postgres function
+	* ```sql
+	* create function hello_world() returns text as $$
+	*   select 'Hello world';
+	* $$ language sql;
+	* ```
+	*
+	* @exampleResponse Call a read-only Postgres function
+	* ```json
+	* {
+	*   "data": "Hello world",
+	*   "status": 200,
+	*   "statusText": "OK"
+	* }
+	* ```
 	*/
 	rpc(fn, args = {}, { head = false, get = false, count } = {}) {
 		var _this$fetch;