@cloudbase/wx-cloud-client-sdk 1.6.0 → 1.7.1-alpha.0

package/lib/db/mysql/MySqlClient.d.ts

@@ -0,0 +1,26 @@
+import "./polyfill";
+import MySqlQueryBuilder from "./MySqlQueryBuilder";
+import { ClientServerOptions, GetGenericDatabaseWithOptions } from "../postgrest";
+import { Fetch, GenericSchema } from "../postgrest/types";
+/**
+ * MySQL client.
+ */
+export default class MySqlClient<Database = any, ClientOptions extends ClientServerOptions = GetGenericDatabaseWithOptions<Database, {}>["options"]> {
+    protected url: string;
+    protected headers: Headers;
+    protected fetch?: Fetch;
+    /**
+     * Creates a MySQL client.
+     *
+     * @param url - URL of the MySQL endpoint
+     * @param options - Named parameters
+     * @param options.headers - Custom headers
+     * @param options.fetch - Custom fetch
+     */
+    constructor(url: string, { headers, fetch, }?: {
+        headers?: HeadersInit;
+        fetch?: Fetch;
+    });
+    from<Schema extends GenericSchema, TableName extends string & keyof Schema["Tables"], Table extends Schema["Tables"][TableName]>(relation: TableName): MySqlQueryBuilder<ClientOptions, Schema, Table, TableName>;
+    from<Schema extends GenericSchema, ViewName extends string & keyof Schema["Views"], View extends Schema["Views"][ViewName]>(relation: ViewName): MySqlQueryBuilder<ClientOptions, Schema, View, ViewName>;
+}

package/lib/db/mysql/MySqlFilterBuilder.d.ts

@@ -0,0 +1,11 @@
+import { ClientServerOptions, PostgrestFilterBuilder } from "../postgrest";
+import { GenericSchema } from "../postgrest/types";
+declare class MySqlFilterBuilder<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, Result, RelationName = unknown, Relationships = unknown, Method extends "GET" | "POST" | "HEAD" | "PATCH" | "DELETE" = "GET"> extends PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method> {
+    constructor({ method, url, headers, fetch, }: {
+        method: Method;
+        url: URL;
+        headers?: HeadersInit;
+        fetch?: any;
+    });
+}
+export default MySqlFilterBuilder;

package/lib/db/mysql/MySqlQueryBuilder.d.ts

@@ -0,0 +1,11 @@
+import { ClientServerOptions, PostgrestQueryBuilder } from "../postgrest";
+import { GenericSchema, GenericTable, GenericView } from "../postgrest/types";
+declare class MySqlQueryBuilder<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Relation extends GenericTable | GenericView, RelationName = unknown, Relationships = Relation extends {
+    Relationships: infer R;
+} ? R : unknown> extends PostgrestQueryBuilder<ClientOptions, Schema, Relation, RelationName, Relationships> {
+    constructor(url: URL, { headers, fetch, }: {
+        headers?: HeadersInit;
+        fetch?: any;
+    });
+}
+export default MySqlQueryBuilder;

package/lib/db/mysql/index.d.ts

@@ -0,0 +1,7 @@
+import MySqlClient from "./MySqlClient";
+export { MySqlClient };
+declare const _default: {
+    MySqlClient: typeof MySqlClient;
+};
+export default _default;
+export type { PostgrestResponse, PostgrestResponseFailure, PostgrestResponseSuccess, PostgrestSingleResponse, PostgrestMaybeSingleResponse, ClientServerOptions, GetGenericDatabaseWithOptions, } from "../postgrest";

package/lib/db/mysql/polyfill.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Headers polyfill for environments without native Headers support
+ * 兼容的Headers类实现
+ */
+declare class _Headers {
+    private map;
+    constructor(init?: HeadersInit | Record<string, string> | string[][]);
+    /**
+     * 添加头部信息，如果已存在则追加
+     * @param name 头部名称
+     * @param value 头部值
+     */
+    append(name: string, value: string): void;
+    /**
+     * 删除指定头部
+     * @param name 头部名称
+     */
+    delete(name: string): void;
+    /**
+     * 迭代所有头部
+     * @param callback 回调函数
+     * @param thisArg 回调函数的this指向
+     */
+    forEach(callback: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+    /**
+     * 获取指定头部的值
+     * @param name 头部名称
+     * @returns 头部值，不存在则返回null
+     */
+    get(name: string): string | null;
+    /**
+     * 检查指定头部是否存在
+     * @param name 头部名称
+     * @returns 是否存在
+     */
+    has(name: string): boolean;
+    /**
+     * 设置头部信息，如果已存在则覆盖
+     * @param name 头部名称
+     * @param value 头部值
+     */
+    set(name: string, value: string): void;
+    /**
+     * 生成迭代器，用于for...of循环
+     * @returns 迭代器
+     */
+    entries(): IterableIterator<[string, string]>;
+    /**
+     * 生成键名迭代器
+     * @returns 键名迭代器
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * 生成值迭代器
+     * @returns 值迭代器
+     */
+    values(): IterableIterator<string>;
+    /**
+     * 获取所有Set-Cookie头部值
+     * @returns Set-Cookie值的数组
+     */
+    getSetCookie(): string[];
+    /**
+     * 转换为普通对象
+     * @returns 包含所有头部的对象
+     */
+    toJSON(): Record<string, string>;
+    /**
+     * 迭代器接口，用于for...of循环
+     */
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+}

package/lib/db/postgrest/PostgrestBuilder.d.ts

@@ -0,0 +1,70 @@
+import type { Fetch, PostgrestSingleResponse, PostgrestResponseSuccess, CheckMatchingArrayTypes, MergePartialResult, IsValidResultOverride, ClientServerOptions } from "./types";
+import { ContainsNull } from "./select-query-parser/types";
+export default abstract class PostgrestBuilder<ClientOptions extends ClientServerOptions, Result, ThrowOnError extends boolean = false> implements PromiseLike<ThrowOnError extends true ? PostgrestResponseSuccess<Result> : PostgrestSingleResponse<Result>> {
+    protected method: "GET" | "HEAD" | "POST" | "PATCH" | "DELETE";
+    protected url: URL;
+    protected headers: Headers;
+    protected schema?: string;
+    protected body?: unknown;
+    protected shouldThrowOnError: boolean;
+    protected signal?: AbortSignal;
+    protected fetch: Fetch;
+    protected isMaybeSingle: boolean;
+    constructor(builder: {
+        method: "GET" | "HEAD" | "POST" | "PATCH" | "DELETE";
+        url: URL;
+        headers: HeadersInit;
+        schema?: string;
+        body?: unknown;
+        shouldThrowOnError?: boolean;
+        signal?: AbortSignal;
+        fetch?: Fetch;
+        isMaybeSingle?: boolean;
+    });
+    /**
+     * If there's an error with the query, throwOnError will reject the promise by
+     * throwing the error instead of returning it as part of a successful response.
+     *
+     * {@link https://github.com/supabase/supabase-js/issues/92}
+     */
+    throwOnError(): this & PostgrestBuilder<ClientOptions, Result, true>;
+    /**
+     * Set an HTTP header for the request.
+     */
+    setHeader(name: string, value: string): this;
+    then<TResult1 = ThrowOnError extends true ? PostgrestResponseSuccess<Result> : PostgrestSingleResponse<Result>, TResult2 = never>(onfulfilled?: ((value: ThrowOnError extends true ? PostgrestResponseSuccess<Result> : PostgrestSingleResponse<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * Override the type of the returned `data`.
+     *
+     * @typeParam NewResult - The new result type to override with
+     * @deprecated Use overrideTypes<yourType, { merge: false }>() method at the end of your call chain instead
+     */
+    returns<NewResult>(): PostgrestBuilder<ClientOptions, CheckMatchingArrayTypes<Result, NewResult>, ThrowOnError>;
+    /**
+     * Override the type of the returned `data` field in the response.
+     *
+     * @typeParam NewResult - The new type to cast the response data to
+     * @typeParam Options - Optional type configuration (defaults to { merge: true })
+     * @typeParam Options.merge - When true, merges the new type with existing return type. When false, replaces the existing types entirely (defaults to true)
+     * @example
+     * ```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 }>()
+     * ```
+     * @returns A PostgrestBuilder instance with the new type
+     */
+    overrideTypes<NewResult, Options extends {
+        merge?: boolean;
+    } = {
+        merge: true;
+    }>(): PostgrestBuilder<ClientOptions, IsValidResultOverride<Result, NewResult, false, false> extends true ? ContainsNull<Result> extends true ? MergePartialResult<NewResult, NonNullable<Result>, Options> | null : MergePartialResult<NewResult, Result, Options> : CheckMatchingArrayTypes<Result, NewResult>, ThrowOnError>;
+}

package/lib/db/postgrest/PostgrestClient.d.ts

@@ -0,0 +1,73 @@
+import PostgrestQueryBuilder from "./PostgrestQueryBuilder";
+import PostgrestFilterBuilder from "./PostgrestFilterBuilder";
+import { Fetch, GenericSchema, ClientServerOptions, GetGenericDatabaseWithOptions } from "./types";
+/**
+ * PostgREST client.
+ *
+ * @typeParam Database - Types for the schema from the [type
+ * generator](https://supabase.com/docs/reference/javascript/next/typescript-support)
+ *
+ * @typeParam SchemaName - Postgres schema to switch to. Must be a string
+ * literal, the same one passed to the constructor. If the schema is not
+ * `"public"`, this must be supplied manually.
+ */
+export default class PostgrestClient<Database = any, ClientOptions extends ClientServerOptions = GetGenericDatabaseWithOptions<Database, {
+    PostgrestVersion: "12";
+}>["options"], SchemaName extends string & keyof GetGenericDatabaseWithOptions<Database>["db"] = "public" extends keyof GetGenericDatabaseWithOptions<Database>["db"] ? "public" : string & keyof GetGenericDatabaseWithOptions<Database>["db"], Schema extends GenericSchema = GetGenericDatabaseWithOptions<Database>["db"][SchemaName] extends GenericSchema ? GetGenericDatabaseWithOptions<Database>["db"][SchemaName] : any> {
+    url: string;
+    headers: Headers;
+    schemaName?: SchemaName;
+    fetch?: Fetch;
+    /**
+     * Creates a PostgREST client.
+     *
+     * @param url - URL of the PostgREST endpoint
+     * @param options - Named parameters
+     * @param options.headers - Custom headers
+     * @param options.schema - Postgres schema to switch to
+     * @param options.fetch - Custom fetch
+     */
+    constructor(url: string, { headers, schema, fetch, }?: {
+        headers?: HeadersInit;
+        schema?: SchemaName;
+        fetch?: Fetch;
+    });
+    from<TableName extends string & keyof Schema["Tables"], Table extends Schema["Tables"][TableName]>(relation: TableName): PostgrestQueryBuilder<ClientOptions, Schema, Table, TableName>;
+    from<ViewName extends string & keyof Schema["Views"], View extends Schema["Views"][ViewName]>(relation: ViewName): PostgrestQueryBuilder<ClientOptions, Schema, View, ViewName>;
+    /**
+     * Select a schema to query or perform an function (rpc) call.
+     *
+     * The schema needs to be on the list of exposed schemas inside Supabase.
+     *
+     * @param schema - The schema to query
+     */
+    schema<DynamicSchema extends string & keyof GetGenericDatabaseWithOptions<Database>["db"]>(schema: DynamicSchema): PostgrestClient<Database, ClientOptions, DynamicSchema, Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any>;
+    /**
+     * Perform a function call.
+     *
+     * @param fn - The function name to call
+     * @param args - The arguments to pass to the function call
+     * @param options - Named parameters
+     * @param options.head - When set to `true`, `data` will not be returned.
+     * Useful if you only need the count.
+     * @param options.get - When set to `true`, the function will be called with
+     * read-only access mode.
+     * @param options.count - Count algorithm to use to count rows returned by the
+     * function. Only applicable for [set-returning
+     * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+     *
+     * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+     * hood.
+     *
+     * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+     * statistics under the hood.
+     *
+     * `"estimated"`: Uses exact count for low numbers and planned count for high
+     * numbers.
+     */
+    rpc<FnName extends string & keyof Schema["Functions"], Fn extends Schema["Functions"][FnName]>(fn: FnName, args?: Fn["Args"], { head, get, count, }?: {
+        head?: boolean;
+        get?: boolean;
+        count?: "exact" | "planned" | "estimated";
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Fn["Returns"] extends any[] ? Fn["Returns"][number] extends Record<string, unknown> ? Fn["Returns"][number] : never : never, Fn["Returns"], FnName, null, "RPC">;
+}

package/lib/db/postgrest/PostgrestError.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Error format
+ *
+ * {@link https://postgrest.org/en/stable/api.html?highlight=options#errors-and-http-status-codes}
+ */
+export default class PostgrestError extends Error {
+    details: string;
+    hint: string;
+    code: string;
+    constructor(context: {
+        message: string;
+        details: string;
+        hint: string;
+        code: string;
+    });
+}

package/lib/db/postgrest/PostgrestFilterBuilder.d.ts

@@ -0,0 +1,107 @@
+import PostgrestTransformBuilder from "./PostgrestTransformBuilder";
+import { JsonPathToAccessor, JsonPathToType } from "./select-query-parser/utils";
+import { ClientServerOptions, GenericSchema } from "./types";
+type FilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "like" | "ilike" | "is" | "in" | "cs" | "cd" | "sl" | "sr" | "nxl" | "nxr" | "adj" | "ov" | "fts" | "plfts" | "phfts" | "wfts";
+export type IsStringOperator<Path extends string> = Path extends `${string}->>${string}` ? true : false;
+type ResolveFilterValue<Schema extends GenericSchema, Row extends Record<string, unknown>, ColumnName extends string> = ColumnName extends `${infer RelationshipTable}.${infer Remainder}` ? Remainder extends `${infer _}.${infer _}` ? ResolveFilterValue<Schema, Row, Remainder> : ResolveFilterRelationshipValue<Schema, RelationshipTable, Remainder> : ColumnName extends keyof Row ? Row[ColumnName] : IsStringOperator<ColumnName> extends true ? string : JsonPathToType<Row, JsonPathToAccessor<ColumnName>> extends infer JsonPathValue ? JsonPathValue extends never ? never : JsonPathValue : never;
+type ResolveFilterRelationshipValue<Schema extends GenericSchema, RelationshipTable extends string, RelationshipColumn extends string> = Schema["Tables"] & Schema["Views"] extends infer TablesAndViews ? RelationshipTable extends keyof TablesAndViews ? "Row" extends keyof TablesAndViews[RelationshipTable] ? RelationshipColumn extends keyof TablesAndViews[RelationshipTable]["Row"] ? TablesAndViews[RelationshipTable]["Row"][RelationshipColumn] : unknown : unknown : unknown : never;
+export type InvalidMethodError<S extends string> = {
+    Error: S;
+};
+export default class PostgrestFilterBuilder<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, Result, RelationName = unknown, Relationships = unknown, Method = unknown> extends PostgrestTransformBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method> {
+    /**
+     * Match only rows where `column` is equal to `value`.
+     *
+     * To check if the value of `column` is NULL, you should use `.is()` instead.
+     *
+     * @param column - The column to filter on
+     * @param value - The value to filter with
+     */
+    eq<ColumnName extends string>(column: ColumnName, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? NonNullable<unknown> : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? NonNullable<ResolvedFilterValue> : never): this;
+    /**
+     * Match only rows where `column` is not equal to `value`.
+     *
+     * @param column - The column to filter on
+     * @param value - The value to filter with
+     */
+    neq<ColumnName extends string>(column: ColumnName, value: ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never): this;
+    gt<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+    gt(column: string, value: unknown): this;
+    gte<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+    gte(column: string, value: unknown): this;
+    lt<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+    lt(column: string, value: unknown): this;
+    lte<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName]): this;
+    lte(column: string, value: unknown): this;
+    like<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
+    like(column: string, pattern: string): this;
+    likeAllOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+    likeAllOf(column: string, patterns: readonly string[]): this;
+    likeAnyOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+    likeAnyOf(column: string, patterns: readonly string[]): this;
+    ilike<ColumnName extends string & keyof Row>(column: ColumnName, pattern: string): this;
+    ilike(column: string, pattern: string): this;
+    ilikeAllOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+    ilikeAllOf(column: string, patterns: readonly string[]): this;
+    ilikeAnyOf<ColumnName extends string & keyof Row>(column: ColumnName, patterns: readonly string[]): this;
+    ilikeAnyOf(column: string, patterns: readonly string[]): this;
+    is<ColumnName extends string & keyof Row>(column: ColumnName, value: Row[ColumnName] & (boolean | null)): this;
+    is(column: string, value: boolean | null): this;
+    /**
+     * Match only rows where `column` is included in the `values` array.
+     *
+     * @param column - The column to filter on
+     * @param values - The values array to filter with
+     */
+    in<ColumnName extends string>(column: ColumnName, values: ReadonlyArray<ResolveFilterValue<Schema, Row, ColumnName> extends never ? unknown : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue ? ResolvedFilterValue : never>): this;
+    contains<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]> | Record<string, unknown>): this;
+    contains(column: string, value: string | readonly unknown[] | Record<string, unknown>): this;
+    containedBy<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]> | Record<string, unknown>): this;
+    containedBy(column: string, value: string | readonly unknown[] | Record<string, unknown>): this;
+    rangeGt<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+    rangeGt(column: string, range: string): this;
+    rangeGte<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+    rangeGte(column: string, range: string): this;
+    rangeLt<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+    rangeLt(column: string, range: string): this;
+    rangeLte<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+    rangeLte(column: string, range: string): this;
+    rangeAdjacent<ColumnName extends string & keyof Row>(column: ColumnName, range: string): this;
+    rangeAdjacent(column: string, range: string): this;
+    overlaps<ColumnName extends string & keyof Row>(column: ColumnName, value: string | ReadonlyArray<Row[ColumnName]>): this;
+    overlaps(column: string, value: string | readonly unknown[]): this;
+    textSearch<ColumnName extends string & keyof Row>(column: ColumnName, query: string, options?: {
+        config?: string;
+        type?: "plain" | "phrase" | "websearch";
+    }): this;
+    textSearch(column: string, query: string, options?: {
+        config?: string;
+        type?: "plain" | "phrase" | "websearch";
+    }): this;
+    match<ColumnName extends string & keyof Row>(query: Record<ColumnName, Row[ColumnName]>): this;
+    match(query: Record<string, unknown>): this;
+    not<ColumnName extends string & keyof Row>(column: ColumnName, operator: FilterOperator, value: Row[ColumnName]): this;
+    not(column: string, operator: string, value: unknown): this;
+    /**
+     * Match only rows which satisfy at least one of the filters.
+     *
+     * Unlike most filters, `filters` is used as-is and needs to follow [PostgREST
+     * 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.
+     *
+     * @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: string, { foreignTable, referencedTable, }?: {
+        foreignTable?: string;
+        referencedTable?: string;
+    }): this;
+    filter<ColumnName extends string & keyof Row>(column: ColumnName, operator: `${"" | "not."}${FilterOperator}`, value: unknown): this;
+    filter(column: string, operator: string, value: unknown): this;
+}
+export {};

package/lib/db/postgrest/PostgrestQueryBuilder.d.ts

@@ -0,0 +1,116 @@
+import PostgrestFilterBuilder from "./PostgrestFilterBuilder";
+import { GetResult } from "./select-query-parser/result";
+import { ClientServerOptions, Fetch, GenericSchema, GenericTable, GenericView } from "./types";
+export default class PostgrestQueryBuilder<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Relation extends GenericTable | GenericView, RelationName = unknown, Relationships = Relation extends {
+    Relationships: infer R;
+} ? R : unknown> {
+    url: URL;
+    headers: Headers;
+    schema?: string;
+    signal?: AbortSignal;
+    fetch?: Fetch;
+    constructor(url: URL, { headers, schema, fetch, }: {
+        headers?: HeadersInit;
+        schema?: string;
+        fetch?: Fetch;
+    });
+    /**
+     * Perform a SELECT query on the table or view.
+     *
+     * @param columns - The columns to retrieve, separated by commas. Columns can be renamed when returned with `customName:columnName`
+     *
+     * @param options - Named parameters
+     *
+     * @param options.head - When set to `true`, `data` will not be returned.
+     * Useful if you only need the count.
+     *
+     * @param options.count - Count algorithm to use to count rows in the table or view.
+     *
+     * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+     * hood.
+     *
+     * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+     * statistics under the hood.
+     *
+     * `"estimated"`: Uses exact count for low numbers and planned count for high
+     * numbers.
+     */
+    select<Query extends string = "*", ResultOne = GetResult<Schema, Relation["Row"], RelationName, Relationships, Query, ClientOptions>>(columns?: Query, { head, count, }?: {
+        head?: boolean;
+        count?: "exact" | "planned" | "estimated";
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], ResultOne[], RelationName, Relationships, "GET">;
+    insert<Row extends Relation extends {
+        Insert: unknown;
+    } ? Relation["Insert"] : never>(values: Row, options?: {
+        count?: "exact" | "planned" | "estimated";
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "POST">;
+    insert<Row extends Relation extends {
+        Insert: unknown;
+    } ? Relation["Insert"] : never>(values: Row[], options?: {
+        count?: "exact" | "planned" | "estimated";
+        defaultToNull?: boolean;
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "POST">;
+    upsert<Row extends Relation extends {
+        Insert: unknown;
+    } ? Relation["Insert"] : never>(values: Row, options?: {
+        onConflict?: string;
+        ignoreDuplicates?: boolean;
+        count?: "exact" | "planned" | "estimated";
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "POST">;
+    upsert<Row extends Relation extends {
+        Insert: unknown;
+    } ? Relation["Insert"] : never>(values: Row[], options?: {
+        onConflict?: string;
+        ignoreDuplicates?: boolean;
+        count?: "exact" | "planned" | "estimated";
+        defaultToNull?: boolean;
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "POST">;
+    /**
+     * Perform an UPDATE on the table or view.
+     *
+     * By default, updated rows are not returned. To return it, chain the call
+     * with `.select()` after filters.
+     *
+     * @param values - The values to update with
+     *
+     * @param options - Named parameters
+     *
+     * @param options.count - Count algorithm to use to count updated rows.
+     *
+     * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+     * hood.
+     *
+     * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+     * statistics under the hood.
+     *
+     * `"estimated"`: Uses exact count for low numbers and planned count for high
+     * numbers.
+     */
+    update<Row extends Relation extends {
+        Update: unknown;
+    } ? Relation["Update"] : never>(values: Row, { count, }?: {
+        count?: "exact" | "planned" | "estimated";
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "PATCH">;
+    /**
+     * Perform a DELETE on the table or view.
+     *
+     * By default, deleted rows are not returned. To return it, chain the call
+     * with `.select()` after filters.
+     *
+     * @param options - Named parameters
+     *
+     * @param options.count - Count algorithm to use to count deleted rows.
+     *
+     * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+     * hood.
+     *
+     * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+     * statistics under the hood.
+     *
+     * `"estimated"`: Uses exact count for low numbers and planned count for high
+     * numbers.
+     */
+    delete({ count, }?: {
+        count?: "exact" | "planned" | "estimated";
+    }): PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE">;
+}