better-supabase 0.11.0 → 0.13.0

package/dist/index-B5XcM3VY.d.ts

@@ -0,0 +1,230 @@
+import { F as SchemaMeta, u as ClaimsMeta } from "./types-DmshMaXz.js";
+import { a as Generator, u as JsonSchemaSource, x as ResolvedConfig, y as BetterSupabaseConfig } from "./codegen-DGtOsqz9.js";
+//#region src/config/defaults.d.ts
+/**
+ * Every default `resolveConfig` fills in. Other modules (the SQL module
+ * registry, the CLI) read their fallbacks from here instead of repeating the
+ * literals.
+ */
+declare const CONFIG_DEFAULTS: {
+  readonly output: string;
+  readonly schemas: readonly string[];
+  readonly casing: "snake";
+  readonly postgrestVersion: string;
+  readonly codecs: {
+    readonly timestamptz: "string";
+    readonly int8: "number";
+    readonly numeric: "number";
+  };
+  readonly sql: {
+    readonly dir: string;
+    readonly prefix: string;
+    readonly testsDir: string;
+  };
+  readonly seed: {
+    readonly entry: string;
+    readonly output: string;
+    readonly perTenant: string;
+  };
+  readonly openapi: {
+    readonly entry: string;
+    readonly output: string;
+  };
+  readonly specs: {
+    readonly failOn: "error";
+  };
+  readonly doctor: {
+    readonly format: "text";
+    readonly sources: readonly string[];
+    readonly policyHelperLimit: number;
+  };
+  readonly gen: {
+    readonly watchInterval: number;
+  };
+  readonly env: {
+    readonly output: string;
+  };
+};
+//#endregion
+//#region src/config/json.d.ts
+/**
+ * The JSON Schema document for a `json[...].schema` entry. A Standard Schema
+ * converts for `target` (2020-12 by default); a JSON Schema object is returned
+ * as it is.
+ */
+declare function resolveJsonSchema(source: JsonSchemaSource, target?: "draft-2020-12" | "draft-07" | "openapi-3.0"): Readonly<Record<string, unknown>>;
+//#endregion
+//#region src/config/resolve.d.ts
+declare const CONFIG_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/config-v1.json";
+/**
+ * Types `better-supabase.config.ts`. With `preset`, it expands the preset into
+ * `blocks` and its conventions first, and the keys you set win.
+ */
+declare function defineConfig(config: BetterSupabaseConfig): BetterSupabaseConfig;
+/** Applies defaults. Paths stay relative to `root`. */
+declare function resolveConfig(input: BetterSupabaseConfig, root: string): ResolvedConfig;
+//#endregion
+//#region src/core/claims.d.ts
+declare const DEFAULT_CLAIMS: ClaimsMeta;
+/**
+ * Where an adapter reads each claim the SQL modules and the provider's hook
+ * write.
+ */
+interface ClaimPaths {
+  /**
+   * The active tenant: the top-level claim, then the same key in
+   * `app_metadata`.
+   */
+  readonly tenant: readonly [string, string];
+  /** `{ [tenantId]: string[] }` of plan features. */
+  readonly features: string;
+  /**
+   * The caller's memberships, a list of `{ scope, id, roles }` or a map of
+   * tenant id to role.
+   */
+  readonly memberships: string;
+  /** The `scope` of tenant entries in the memberships list. */
+  readonly scope: string;
+}
+/**
+ * The claim paths for `config.claims`, with defaults. For a generated schema,
+ * pass `claimsOf(meta)`.
+ */
+declare function claimPaths(claims?: Partial<ClaimsMeta>): ClaimPaths;
+/**
+ * Where the active tenant is read from: the top-level claim, then
+ * `app_metadata`.
+ */
+declare function tenantClaimPaths(tenant?: string): readonly [string, string];
+//#endregion
+//#region src/generators/json-schema-target.d.ts
+/** The JSON Schema dialects the generators and MCP emit. */
+type JsonSchemaTarget = "draft-2020-12" | "draft-07" | "openapi-3.0";
+//#endregion
+//#region src/generators/shared.d.ts
+/** What field planning reads: the metadata and the typed-jsonb config. */
+interface SchemaSource {
+  readonly meta: SchemaMeta;
+  readonly config: {
+    readonly json: Readonly<Record<string, unknown>>;
+  };
+  readonly runtimeImport?: string;
+}
+interface CommentEntry {
+  readonly id: number;
+  readonly schema: string;
+  readonly name: string;
+  readonly comment: string | null;
+}
+/**
+ * The catalog parts docs read: `GeneratorInput` satisfies it. Runtime callers
+ * that only have `meta` (OpenAPI, MCP) pass none and get no docs.
+ */
+interface DocsSource extends SchemaSource {
+  readonly introspection?: {
+    readonly tables: readonly CommentEntry[];
+    readonly views: readonly CommentEntry[];
+    readonly materializedViews?: readonly CommentEntry[];
+    readonly columns: readonly {
+      readonly table_id: number;
+      readonly name: string;
+      readonly comment: string | null;
+      readonly check: string | null;
+    }[];
+  };
+  readonly extras?: {
+    readonly tables: readonly {
+      readonly schema: string;
+      readonly name: string;
+      readonly checks: readonly {
+        readonly definition: string;
+      }[];
+    }[];
+  };
+}
+//#endregion
+//#region src/generators/json-schema.d.ts
+interface JsonSchemaGeneratorOptions {
+  /**
+   * Output path relative to the project root. Defaults to
+   * `<output>.schema.json`.
+   */
+  readonly output?: string;
+  /** `$id` of the document. */
+  readonly id?: string;
+  /**
+   * The dialect. `draft-2020-12` (the default) writes `$defs`; `draft-07` and
+   * `openapi-3.0` (`nullable`, `example`) write `definitions`.
+   */
+  readonly target?: JsonSchemaTarget;
+}
+type JsonSchema = Record<string, unknown>;
+/**
+ * JSON Schema `$defs` for every table: `customersRow`, `customersInsert`, ...
+ * `target` lowers the document to draft-07 or the OpenAPI 3.0 dialect, which
+ * keep the schemas under `definitions`.
+ */
+declare function buildJsonSchema(input: DocsSource, id?: string, target?: JsonSchemaTarget): JsonSchema;
+/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
+declare function jsonSchema(options?: JsonSchemaGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/standard-schema.d.ts
+interface StandardSchemaGeneratorOptions {
+  /**
+   * Output path relative to the project root. Defaults to
+   * `<output>.standard.ts`.
+   */
+  readonly output?: string;
+  /**
+   * Standard Schemas for typed jsonb columns: `{ 'customers.metadata':
+   * './schemas.ts#metadata' }`.
+   */
+  readonly json?: Readonly<Record<string, string>>;
+}
+/**
+ * Standard Schemas for every table's Row, Insert and Update shape, with no
+ * validation library. Each one also converts to JSON Schema (Standard JSON
+ * Schema), and `validators` plugs into the validation plugin.
+ */
+declare function standardSchema(options?: StandardSchemaGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/valibot.d.ts
+interface ValibotGeneratorOptions {
+  /**
+   * Output path relative to the project root. Defaults to
+   * `<output>.valibot.ts`.
+   */
+  readonly output?: string;
+  /**
+   * Schemas for typed jsonb columns: `{ 'customers.metadata':
+   * './schemas.ts#metadata' }`.
+   */
+  readonly json?: Readonly<Record<string, string>>;
+}
+/** Valibot schemas for every table's Row, Insert and Update shape. */
+declare function valibot(options?: ValibotGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/zod.d.ts
+interface ZodGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.zod.ts`. */
+  readonly output?: string;
+  /**
+   * Schemas for typed jsonb columns: `{ 'customers.metadata':
+   * './schemas.ts#metadata' }`.
+   */
+  readonly json?: Readonly<Record<string, string>>;
+  /**
+   * `classic` (the default) imports `zod` and chains methods; `mini` imports
+   * `zod/mini` and uses its functional API (`z.nullable(...)`, `.check(...)`),
+   * which tree-shakes to a smaller bundle. Both need zod 4.
+   */
+  readonly flavor?: ZodFlavor;
+}
+type ZodFlavor = "classic" | "mini";
+/**
+ * Zod 4 schemas for every table's Row, Insert and Update shape, for `zod` or,
+ * with `flavor: 'mini'`, `zod/mini`.
+ */
+declare function zod(options?: ZodGeneratorOptions): Generator;
+//#endregion
+export { defineConfig as _, valibot as a, CONFIG_DEFAULTS as b, JsonSchemaGeneratorOptions as c, JsonSchemaTarget as d, ClaimPaths as f, CONFIG_SCHEMA_URL as g, tenantClaimPaths as h, ValibotGeneratorOptions as i, buildJsonSchema as l, claimPaths as m, ZodGeneratorOptions as n, StandardSchemaGeneratorOptions as o, DEFAULT_CLAIMS as p, zod as r, standardSchema as s, ZodFlavor as t, jsonSchema as u, resolveConfig as v, resolveJsonSchema as y };

package/dist/index-B5dVVZtW.d.ts

@@ -0,0 +1,142 @@
+import { t as AsyncResult } from "./result-mijqfoJN.js";
+import { a as AnyModels, i as AnyFunctions } from "./types-DmshMaXz.js";
+import { l as PublicEnv } from "./index-NRMMhhEi.js";
+import { h as SessionEncoding } from "./resolve-D57oDWNr.js";
+import { t as BetterSupabase } from "./define-D0LSXmUP.js";
+import { i as KeyboardPort, l as StoragePort, n as DeepLinkPort, r as FilePickerPort, s as PushTokenPort, t as ClientPorts } from "./ports-n3ZWSS_I.js";
+import { r as BetterClient } from "./bind-DcXLU1ul.js";
+import { n as FunctionContract } from "./function-contract-4vfi93Y5.js";
+import { FunctionInvokeOptions, SupabaseClient, SupabaseClientOptions } from "@supabase/supabase-js";
+//#region src/client/functions.d.ts
+/**
+ * `supabase.functions.invoke` options, without the body: `invoke` sends the
+ * input.
+ */
+type InvokeOptions = Omit<FunctionInvokeOptions, "body">;
+/** Edge Function contracts by function name. */
+type FunctionContracts = Readonly<Record<string, FunctionContract>>;
+/** Anything with supabase-js's `functions` client, e.g. a `SupabaseClient`. */
+interface FunctionsHost {
+  readonly functions: {
+    invoke(name: string, options?: FunctionInvokeOptions): Promise<{
+      data: unknown;
+      error: unknown;
+      response?: Response;
+    }>;
+  };
+}
+interface TypedFunctions<Contracts extends FunctionContracts> {
+  /**
+   * Calls the function with `input` as the JSON body. Problem Details from the
+   * function come back as their `DbError`; a network or relay failure is a
+   * `network` error.
+   */
+  invoke<N extends keyof Contracts & string>(name: N, ...[input, options]: undefined extends Contracts[N]["input"] ? [input?: Contracts[N]["input"], options?: InvokeOptions] : [input: Contracts[N]["input"], options?: InvokeOptions]): AsyncResult<Contracts[N]["output"]>;
+}
+/**
+ * Typed Edge Function calls over supabase-js's `functions` client. The
+ * contracts come from the functions' own code, imported as types:
+ *
+ * ```ts
+ * import type { SendInvite } from "../supabase/functions/send-invite/index.ts";
+ *
+ * const fns = functions<{ "send-invite": SendInvite }>(supabase);
+ * const invite = await fns.invoke("send-invite", { email }).orThrow();
+ * ```
+ */
+declare function functions<Contracts extends FunctionContracts>(host: FunctionsHost): TypedFunctions<Contracts>;
+//#endregion
+//#region src/client/web-ports.d.ts
+/** The part of a `ServiceWorkerRegistration` the push token port uses. */
+interface PushRegistrationLike {
+  readonly pushManager: {
+    getSubscription(): Promise<unknown>;
+    subscribe(options: {
+      readonly userVisibleOnly: boolean;
+      readonly applicationServerKey: Uint8Array<ArrayBuffer>;
+    }): Promise<unknown>;
+  };
+}
+/**
+ * The storage port over `localStorage` (or `sessionStorage`). Reads resolve
+ * with `null` and writes do nothing where storage is missing or blocked.
+ */
+declare function webStorage(kind?: "local" | "session"): StoragePort;
+/** The keyboard port over `keydown` on `window`; `mod` matches Cmd and Ctrl. */
+declare function webKeyboard(): KeyboardPort;
+/** The file picker port over a hidden `<input type="file">`. */
+declare function webFilePicker(): FilePickerPort;
+/** The deep link port over `location`, `popstate` and `hashchange`. */
+declare function webDeepLinks(): DeepLinkPort;
+interface WebPushTokenOptions {
+  /** The VAPID public key, base64url-encoded. */
+  readonly vapidPublicKey: string;
+  /**
+   * The service worker that receives the pushes. Default
+   * `navigator.serviceWorker.ready`.
+   */
+  readonly registration?: () => Promise<PushRegistrationLike>;
+}
+/**
+ * The push token port over the Push API: the token is the JSON of the browser's
+ * push subscription, which a Web Push sender needs.
+ */
+declare function webPushToken(options: WebPushTokenOptions): PushTokenPort;
+/**
+ * The web ports `createClient` uses: storage, the keyboard, the file picker and
+ * deep links.
+ */
+declare function webPorts(): ClientPorts;
+//#endregion
+//#region src/client/index.d.ts
+interface ClientOptions {
+  /** URL and publishable key. Not needed when `client` is given. */
+  readonly env?: PublicEnv;
+  /**
+   * Bring your own supabase-js client (custom storage). React Native apps use
+   * `better-supabase/client/native`, which doesn't load `@supabase/ssr`.
+   */
+  readonly client?: SupabaseClient;
+  /**
+   * `cookies` (default) shares the session with the server through
+   * `@supabase/ssr`; `local` keeps it in localStorage for SPAs without a
+   * server.
+   */
+  readonly storage?: "cookies" | "local";
+  readonly cookies?: {
+    /**
+     * `tokens-only` keeps the user object out of the cookie (it lives in
+     * `auth.userStorage`, localStorage by default), so cookies stay small. Use
+     * the same value as the server's `encode`. Defaults to `user-and-tokens`.
+     */
+    readonly encode?: SessionEncoding;
+  };
+  readonly auth?: {
+    /** Where auth-js keeps the user object with `cookies.encode: 'tokens-only'`. */
+    readonly userStorage?: UserStorage;
+  };
+  /**
+   * `staleTime` for every query option in `bs.queries`. Above zero, a remount
+   * or a window focus reuses cached rows instead of refetching.
+   */
+  readonly staleTime?: number;
+  /**
+   * Platform services for the block hooks, over the web defaults (`webPorts()`
+   * and an upload port over Supabase Storage).
+   */
+  readonly ports?: ClientPorts;
+}
+type UserStorage = NonNullable<NonNullable<SupabaseClientOptions<"public">["auth"]>["userStorage"]>;
+/**
+ * The browser side: a supabase-js client, repositories that follow the session,
+ * TanStack Query options and an auth store for UI state.
+ *
+ * ```ts
+ * export const bs = createClient(betterSupabase, {
+ *   env: { url, publishableKey },
+ * });
+ * ```
+ */
+declare function createClient$1<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: ClientOptions): BetterClient<M, F, E, C, P>;
+//#endregion
+export { webDeepLinks as a, webPorts as c, FunctionContracts as d, FunctionsHost as f, functions as h, WebPushTokenOptions as i, webPushToken as l, TypedFunctions as m, createClient$1 as n, webFilePicker as o, InvokeOptions as p, PushRegistrationLike as r, webKeyboard as s, ClientOptions as t, webStorage as u };

package/dist/index-Brm8I8iZ.d.ts

@@ -0,0 +1,232 @@
+import { n as DbException } from "./escape-like-DuKupGUV.js";
+import { B as TableKey, D as PrimaryKeyValue, G as Update, S as Insert, W as UniqueWhere, a as AnyModels, i as AnyFunctions } from "./types-DmshMaXz.js";
+import { Ct as ReadArgs, J as QuerySpec, O as UpdateArgs, St as Payload, T as Returned, Ut as CacheAdapter, a as CursorPageArgs, c as DeleteArgs, ct as CountArgs, dt as FindManyArgs, et as AggregateArgs, ft as FindOnlyArgs, g as OffsetRangeArgs, h as OffsetPageArgs, i as CursorPage, j as WriteArgs, k as UpsertArgs, kt as WhereInput, l as DeleteExt, m as OffsetPage, o as Db, q as InferResult, rt as AggregateResult, t as BetterSupabase, u as FindExt, ut as FindFirstArgs } from "./define-D0LSXmUP.js";
+import { t as BetterQueryMeta } from "./invalidate-BLiBFbLy.js";
+import { DataTag, InfiniteData, QueryClient, SkipToken } from "@tanstack/query-core";
+//#region src/query/queries.d.ts
+type QueryKeyOf<T> = DataTag<readonly unknown[], T, DbException>;
+type QueryFnOf<T> = ((context: {
+  readonly signal: AbortSignal;
+}) => Promise<T>) | SkipToken;
+/**
+ * Options for `useQuery`, `createQuery`, `injectQuery`,
+ * `queryClient.fetchQuery` and `prefetchQuery`.
+ */
+interface QueryOptionsOf<T> {
+  readonly queryKey: QueryKeyOf<T>;
+  readonly queryFn: QueryFnOf<T>;
+  readonly meta: BetterQueryMeta;
+  readonly staleTime?: number;
+}
+/**
+ * Options for infinite queries over cursor (`string | null`) or offset
+ * (`number`) pages.
+ */
+interface InfiniteOptionsOf<P, Param> {
+  readonly queryKey: DataTag<readonly unknown[], InfiniteData<P>, DbException>;
+  readonly queryFn: (context: {
+    readonly signal: AbortSignal;
+    readonly pageParam: Param;
+  }) => Promise<P>;
+  readonly initialPageParam: Param;
+  readonly getNextPageParam: (last: P) => Param | undefined;
+  /**
+   * Set on numbered pages, so a window trimmed by `maxPages` can load
+   * backwards.
+   */
+  readonly getPreviousPageParam?: (first: P) => Param | undefined;
+  readonly maxPages?: number;
+  readonly meta: BetterQueryMeta;
+  readonly staleTime?: number;
+}
+interface InfiniteExtras {
+  /**
+   * Pages kept in the cache; older ones are dropped as new ones load. Keeps
+   * long feeds from holding every page in memory and refetching them all.
+   */
+  readonly maxPages?: number;
+}
+/** Options for `useMutation`. Invalidates every query that read a changed table. */
+interface MutationOptionsOf<V, R> {
+  readonly mutationKey: readonly unknown[];
+  readonly mutationFn: (variables: V) => Promise<R>;
+  readonly onSuccess: (data: R, variables: V, onMutateResult: unknown, context: {
+    readonly client: QueryClient;
+  }) => Promise<void>;
+}
+interface TableQueries<M extends AnyModels, T extends TableKey<M>, E> {
+  /** Prefix of every key for this table's own queries. */
+  readonly key: readonly ["bs", T];
+  findMany<const A extends FindManyArgs<M, T> & FindExt<E, M, T>>(args?: A | SkipToken): QueryOptionsOf<Payload<M, T, A>[]>;
+  findFirst<const A extends FindFirstArgs<M, T> & FindExt<E, M, T>>(args?: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
+  findOnly<const A extends FindOnlyArgs<M, T> & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
+  findUnique<const A extends ReadArgs<M, T> & {
+    readonly where: UniqueWhere<M, T>;
+  } & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
+  findById<const A extends ReadArgs<M, T> & FindExt<E, M, T>>(id: PrimaryKeyValue<M, T> | SkipToken, args?: A): QueryOptionsOf<Payload<M, T, A>>;
+  count(args?: (CountArgs<M, T> & FindExt<E, M, T>) | SkipToken): QueryOptionsOf<number>;
+  aggregate<const A extends AggregateArgs<M, T> & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<AggregateResult<M, T, A>>;
+  exists(args?: ({
+    readonly where?: WhereInput<M, T>;
+  } & FindExt<E, M, T>) | SkipToken): QueryOptionsOf<boolean>;
+  paginate<const A extends (OffsetPageArgs<M, T> | OffsetRangeArgs<M, T>) & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<OffsetPage<Payload<M, T, A>>>;
+  /** Cursor pages for `useInfiniteQuery`. */
+  infinite<const A extends Omit<CursorPageArgs<M, T>, "after"> & FindExt<E, M, T>>(args: A, options?: InfiniteExtras): InfiniteOptionsOf<CursorPage<Payload<M, T, A>>, string | null>;
+  /** Numbered pages for `useInfiniteQuery`, starting at `args.page` (default 1). */
+  infinitePages<const A extends OffsetPageArgs<M, T> & FindExt<E, M, T>>(args: A, options?: InfiniteExtras): InfiniteOptionsOf<OffsetPage<Payload<M, T, A>>, number>;
+  create<const A extends WriteArgs<M, T> = {}>(args?: A): MutationOptionsOf<Insert<M, T>, Returned<M, T, A>>;
+  update<const A extends UpdateArgs<M, T> = {}>(args?: A): MutationOptionsOf<{
+    readonly id: PrimaryKeyValue<M, T>;
+    readonly patch: Update<M, T>;
+  }, Returned<M, T, A>>;
+  upsert<const A extends UpsertArgs<M, T> = {}>(args?: A): MutationOptionsOf<Insert<M, T>, Returned<M, T, A>>;
+  delete(args?: DeleteArgs & DeleteExt<E, M, T>): MutationOptionsOf<PrimaryKeyValue<M, T>, void>;
+}
+type RpcArgsOf<F extends AnyFunctions, N extends keyof F> = F[N]["Args"];
+interface QueryHelpers<M extends AnyModels, F extends AnyFunctions> {
+  /** Prefix of every better-supabase key. */
+  readonly $key: readonly ["bs"];
+  /**
+   * Query options for a `QuerySpec`, for example one sent from a Server
+   * Component.
+   */
+  $spec<S extends QuerySpec<TableKey<M>>>(spec: S | SkipToken): QueryOptionsOf<InferResult<S>>;
+  /** Fetches a spec into `queryClient` for server rendering and hydration. */
+  $prefetch(queryClient: QueryClient, spec: QuerySpec<TableKey<M>>): Promise<void>;
+  /**
+   * Query options for a database function. `tables` lists what it reads, for
+   * invalidation.
+   */
+  $rpc<N extends Extract<keyof F, string>>(name: N, args?: RpcArgsOf<F, N> | SkipToken, options?: {
+    readonly tables?: readonly TableKey<M>[];
+  }): QueryOptionsOf<F[N]["Returns"]>;
+  /**
+   * Mutation options for a database function; invalidates what
+   * `betterSupabase.defineRpc` declared.
+   */
+  $rpcMutation<N extends Extract<keyof F, string>>(name: N): MutationOptionsOf<RpcArgsOf<F, N>, F[N]["Returns"]>;
+}
+type BetterQueries<M extends AnyModels, E, F extends AnyFunctions = AnyFunctions> = { readonly [T in TableKey<M>]: TableQueries<M, T, E>; } & QueryHelpers<M, F>;
+interface QueriesOptions {
+  /**
+   * `staleTime` for every query option. Set it above zero when rendering on the
+   * server so hydrated data isn't refetched on mount.
+   */
+  readonly staleTime?: number;
+  /**
+   * Appended to every query key. Give each executor its own scope (`'local'`
+   * for PowerSync, for instance) when several share one QueryClient, so their
+   * results never land in the same cache entry. Invalidation by table still
+   * reaches every scope.
+   */
+  readonly scope?: string;
+}
+/**
+ * TanStack Query option factories for every table, framework-neutral: pass them
+ * to `useQuery` (React), `createQuery` (Svelte, Solid), `useQuery` (Vue) or
+ * `injectQuery` (Angular). Payload types flow into the cache, errors are
+ * `DbException`s, and mutations invalidate every query that read a changed
+ * table.
+ *
+ * ```ts
+ * const q = createQueries(betterSupabase, () => bs.db);
+ * const { data } = useQuery(
+ *   q.customers.findMany({ select: ["id", "name"] }),
+ * );
+ * ```
+ */
+declare function createQueries<M extends AnyModels, D, F extends AnyFunctions, E>(betterSupabase: BetterSupabase<M, D, F, E>, db: Db<M, F, E, unknown> | (() => Db<M, F, E, unknown>), options?: QueriesOptions): BetterQueries<M, E, F>;
+/** Invalidates every query that read a table in the target. */
+declare function queryCache(client: QueryClient): CacheAdapter;
+/**
+ * Invalidates affected queries for every mutation and declared RPC
+ * `betterSupabase` performs in this runtime.
+ */
+declare function invalidateOnMutation<M extends AnyModels, D, F extends AnyFunctions, E>(betterSupabase: BetterSupabase<M, D, F, E>, client: QueryClient): () => void;
+//#endregion
+//#region src/query/user-change.d.ts
+/** The part of `createClient().auth` that `clearOnUserChange` reads. */
+interface UserChangeSource {
+  subscribe(listener: () => void): () => void;
+  current(): {
+    readonly status: string;
+    readonly user: {
+      readonly id: string;
+    } | null;
+    readonly claims?: Readonly<Record<string, unknown>> | null;
+  };
+}
+/**
+ * Resets every `['bs', ...]` query when the caller changes: another user,
+ * signing out, or new claims for the same user (an organization switch, a role
+ * change). Mounted queries refetch, so no one sees the previous identity's
+ * rows. Returns the function that stops listening. `BetterSupabaseProvider`
+ * calls it for React; call it yourself with Vue, Solid, Svelte or Angular
+ * Query.
+ *
+ * Queries that fetched while the session was still loading ran as anon, so they
+ * are reset when a user arrives. Data already in the cache when loading started
+ * (hydrated from the server) stays.
+ *
+ * ```ts
+ * const stop = clearOnUserChange(queryClient, bs.auth);
+ * ```
+ */
+declare function clearOnUserChange(queryClient: Pick<QueryClient, "resetQueries" | "getQueryCache">, auth: UserChangeSource): () => void;
+//#endregion
+//#region src/query/optimistic.d.ts
+/**
+ * A query whose cached data an optimistic update rewrites: any `q.<table>.*()`
+ * option.
+ */
+interface OptimisticTarget<T> {
+  readonly queryKey: QueryKeyOf<T>;
+}
+interface MutationContext {
+  readonly client: QueryClient;
+}
+/** What `onMutate` returns: the data each target held before the change. */
+interface OptimisticSnapshot {
+  readonly previous: readonly (readonly [queryKey: readonly unknown[], data: unknown])[];
+}
+/**
+ * `onMutate`, `onError` and `onSettled` for `useMutation`: spread them next to
+ * a mutation option, which keeps its `onSuccess` invalidation.
+ */
+interface OptimisticHandlers<V> {
+  onMutate(variables: V, context: MutationContext): Promise<OptimisticSnapshot>;
+  onError(error: Error, variables: V, snapshot: OptimisticSnapshot | undefined, context: MutationContext): void;
+  onSettled(data: unknown, error: Error | null, variables: V, snapshot: OptimisticSnapshot | undefined, context: MutationContext): Promise<void>;
+}
+type Targets<T> = OptimisticTarget<T> | readonly OptimisticTarget<T>[];
+type Keyed<R> = Extract<keyof R, string>;
+/**
+ * Optimistic updates for list queries (`findMany`), keyed by a row column (`id`
+ * by default):
+ *
+ * - `optimistic.create(list, (input) => row)` adds the row the input will make.
+ * - `optimistic.update(list)` merges `{ id, patch }` into the matching row.
+ * - `optimistic.remove(list)` drops the row whose key is the deleted id.
+ * - `optimistic(target, apply)` rewrites any cached data.
+ *
+ * ```ts
+ * const list = q.todos.findMany({ where: { done: false } });
+ * useMutation({ ...q.todos.update(), ...optimistic.update(list) });
+ * ```
+ */
+declare const optimistic: (<T, V>(targets: Targets<T>, apply: (current: T, variables: V) => T) => OptimisticHandlers<V>) & {
+  create<R, V>(targets: Targets<R[]>, toRow: (variables: V) => R, options?: {
+    readonly position?: "start" | "end";
+  }): OptimisticHandlers<V>;
+  update<R, K extends Keyed<R> = Keyed<R> & "id">(targets: Targets<R[]>, options?: {
+    readonly key?: K;
+  }): OptimisticHandlers<{
+    readonly id: R[K];
+    readonly patch: Partial<R>;
+  }>;
+  remove<R, K extends Keyed<R> = Keyed<R> & "id">(targets: Targets<R[]>, options?: {
+    readonly key?: K;
+  }): OptimisticHandlers<R[K]>;
+};
+//#endregion
+export { invalidateOnMutation as _, UserChangeSource as a, InfiniteExtras as c, QueriesOptions as d, QueryHelpers as f, createQueries as g, TableQueries as h, optimistic as i, InfiniteOptionsOf as l, QueryOptionsOf as m, OptimisticSnapshot as n, clearOnUserChange as o, QueryKeyOf as p, OptimisticTarget as r, BetterQueries as s, OptimisticHandlers as t, MutationOptionsOf as u, queryCache as v };