better-supabase 0.12.0 → 0.14.0

package/dist/index-XcTBR4Gb.d.ts

@@ -1,206 +0,0 @@
-import { n as DbException } from "./escape-like-B339PlP-.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-BrpW5ixT.js";
-import { B as UpsertArgs, Bt as WhereInput, Ct as FindOnlyArgs, D as OffsetRangeArgs, E as OffsetPageArgs, H as WriteArgs, I as Returned, Nt as Payload, Pt as ReadArgs, St as FindManyArgs, T as OffsetPage, _ as Db, at as QuerySpec, b as DeleteExt, dt as AggregateArgs, g as CursorPageArgs, h as CursorPage, it as InferResult, mt as AggregateResult, s as CacheAdapter, t as BetterSupabase, x as FindExt, xt as FindFirstArgs, y as DeleteArgs, yt as CountArgs, z as UpdateArgs } from "./define-DYZnvAbs.js";
-import { t as BetterQueryMeta } from "./invalidate-BBqhpxyB.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 };

package/dist/index-k-rrfG1g.d.ts

@@ -1,202 +0,0 @@
-import { F as SchemaMeta, u as ClaimsMeta } from "./types-BrpW5ixT.js";
-import { a as Generator, u as JsonSchemaSource, x as ResolvedConfig, y as BetterSupabaseConfig } from "./codegen-C64C0NZG.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 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-wTnPJUhv.d.ts

@@ -1,58 +0,0 @@
-import { c as SpecDiagnostic, r as DocumentFormat } from "./format-CNwSjXUU.js";
-import { r as ResourceDescription } from "./resource-DYEtc-KN.js";
-import { C as ApiSource, _ as OpenApiDocuments, b as OpenApiVersion, l as AnyOpenApiDocument, n as DefineApiOptions, x as RenderedOpenApi } from "./api-DoWK3dTw.js";
-//#region src/openapi/format.d.ts
-/**
- * OpenAPI as a `DocumentFormat`. 3.1 is the default; 3.0 is legacy (schemas
- * lowered to the 3.0 Schema Object); 3.2 has native `$self`, nested tags,
- * `itemSchema`, `oauth2MetadataUrl` and `query`; `3.3-preview` follows the
- * v3.3-dev branch at `SPEC_PINS.openapi33Preview`, with Path Item
- * `security` and the Security Profiles proposal. Below 3.2, the 3.2 fields
- * travel as the registered `x-oai-*` extensions where one exists, and as
- * the model's prefixed extensions otherwise.
- */
-declare const openapiFormat: DocumentFormat<"openapi", OpenApiVersion, AnyOpenApiDocument, OpenApiDocuments>;
-//#endregion
-//#region src/openapi/schema30.d.ts
-type Json = Record<string, unknown>;
-/**
- * Rewrites a JSON Schema 2020-12 schema into the OpenAPI 3.0 Schema Object:
- * `null` in `type` or in an `anyOf`/`oneOf` becomes `nullable`, a type list
- * becomes `anyOf`, `const` becomes a one-value `enum`, `examples` becomes
- * `example`, numeric `exclusiveMinimum`/`exclusiveMaximum` become the
- * boolean form, `contentEncoding: base64` becomes `format: byte`, and a
- * `$ref` with siblings is wrapped in `allOf`. Keywords 3.0 does not have
- * are left out. The input is not changed.
- */
-declare function toOpenApi30Schema(schema: Readonly<Json>): Json;
-//#endregion
-//#region src/openapi/index.d.ts
-/** How one table is published; see `defineApi`'s `resources`. */
-type ResourceOptions<Ref = string> = ResourceDescription<Ref>;
-interface OpenApiOptions<V extends OpenApiVersion = "3.1", Ref = string> extends DefineApiOptions<Ref> {
-  /** Defaults to 3.1. `3.3-preview` follows a draft. */
-  readonly version?: V;
-  /** Last change to the document before overlays; see `RenderOptions.transform`. */
-  readonly transform?: (rendered: Extract<RenderedOpenApi, {
-    readonly version: V;
-  }>) => OpenApiDocuments[OpenApiVersion] | undefined;
-  readonly overlays?: readonly unknown[];
-  /** Hears every warning and info finding. Errors throw. */
-  readonly onDiagnostic?: (diagnostic: SpecDiagnostic) => void;
-}
-/**
- * An OpenAPI document for REST resources over your tables, with schemas
- * from the generated metadata, list-query parameters, Supabase security
- * schemes and Problem Details errors. Throws when building or checking the
- * document finds an error; use `defineApi` to read every finding instead.
- *
- * ```ts
- * const doc = createOpenApi(betterSupabase, {
- *   info: { title: "CRM API", version: "1.0.0" },
- *   resources: { customers: { list: customerList }, notes: { operations: ["list", "get"] } },
- * });
- * ```
- */
-declare function createOpenApi<V extends OpenApiVersion = "3.1", Ref = string>(betterSupabase: ApiSource, options: OpenApiOptions<V, Ref>): OpenApiDocuments[V];
-//#endregion
-export { openapiFormat as a, toOpenApi30Schema as i, ResourceOptions as n, createOpenApi as r, OpenApiOptions as t };

package/dist/invalidate-BBqhpxyB.d.ts

@@ -1,19 +0,0 @@
-import { QueryClient, QueryMeta } from "@tanstack/query-core";
-//#region src/query/invalidate.d.ts
-/**
- * Carried by every better-supabase query: the tables whose changes make it
- * stale, on top of the app's `Register['queryMeta']`, so the options stay
- * assignable to `useQuery` when the app narrows its query meta.
- */
-type BetterQueryMeta = QueryMeta & {
-  readonly bsTables: readonly string[];
-};
-/**
- * Invalidates every query that read one of `tables`: better-supabase queries
- * by their `meta.bsTables`, and other `['bs', table, ...]` keys by prefix.
- * An index from table to queries finds them, so a write to a table nothing
- * read skips the cache scan.
- */
-declare function invalidateTables(client: QueryClient, tables: readonly string[]): Promise<void>;
-//#endregion
-export { invalidateTables as n, BetterQueryMeta as t };

package/dist/iso4217-A8ev-CNW.js

@@ -1,176 +0,0 @@
-//#region src/commerce/iso4217.ts
-/**
-* Minor units per ISO 4217 currency code, from ISO 4217 List One as
-* published on the date in `SPEC_PINS.iso4217`. Codes without minor units
-* (precious metals, SDR and testing codes) are left out: they are not money
-* a price or a payment can carry.
-*/
-const ISO_4217_MINOR_UNITS = Object.freeze({
-	AED: 2,
-	AFN: 2,
-	ALL: 2,
-	AMD: 2,
-	AOA: 2,
-	ARS: 2,
-	AUD: 2,
-	AWG: 2,
-	AZN: 2,
-	BAM: 2,
-	BBD: 2,
-	BDT: 2,
-	BHD: 3,
-	BIF: 0,
-	BMD: 2,
-	BND: 2,
-	BOB: 2,
-	BOV: 2,
-	BRL: 2,
-	BSD: 2,
-	BTN: 2,
-	BWP: 2,
-	BYN: 2,
-	BZD: 2,
-	CAD: 2,
-	CDF: 2,
-	CHE: 2,
-	CHF: 2,
-	CHW: 2,
-	CLF: 4,
-	CLP: 0,
-	CNY: 2,
-	COP: 2,
-	COU: 2,
-	CRC: 2,
-	CUP: 2,
-	CVE: 2,
-	CZK: 2,
-	DJF: 0,
-	DKK: 2,
-	DOP: 2,
-	DZD: 2,
-	EGP: 2,
-	ERN: 2,
-	ETB: 2,
-	EUR: 2,
-	FJD: 2,
-	FKP: 2,
-	GBP: 2,
-	GEL: 2,
-	GHS: 2,
-	GIP: 2,
-	GMD: 2,
-	GNF: 0,
-	GTQ: 2,
-	GYD: 2,
-	HKD: 2,
-	HNL: 2,
-	HTG: 2,
-	HUF: 2,
-	IDR: 2,
-	ILS: 2,
-	INR: 2,
-	IQD: 3,
-	IRR: 2,
-	ISK: 0,
-	JMD: 2,
-	JOD: 3,
-	JPY: 0,
-	KES: 2,
-	KGS: 2,
-	KHR: 2,
-	KMF: 0,
-	KPW: 2,
-	KRW: 0,
-	KWD: 3,
-	KYD: 2,
-	KZT: 2,
-	LAK: 2,
-	LBP: 2,
-	LKR: 2,
-	LRD: 2,
-	LSL: 2,
-	LYD: 3,
-	MAD: 2,
-	MDL: 2,
-	MGA: 2,
-	MKD: 2,
-	MMK: 2,
-	MNT: 2,
-	MOP: 2,
-	MRU: 2,
-	MUR: 2,
-	MVR: 2,
-	MWK: 2,
-	MXN: 2,
-	MXV: 2,
-	MYR: 2,
-	MZN: 2,
-	NAD: 2,
-	NGN: 2,
-	NIO: 2,
-	NOK: 2,
-	NPR: 2,
-	NZD: 2,
-	OMR: 3,
-	PAB: 2,
-	PEN: 2,
-	PGK: 2,
-	PHP: 2,
-	PKR: 2,
-	PLN: 2,
-	PYG: 0,
-	QAR: 2,
-	RON: 2,
-	RSD: 2,
-	RUB: 2,
-	RWF: 0,
-	SAR: 2,
-	SBD: 2,
-	SCR: 2,
-	SDG: 2,
-	SEK: 2,
-	SGD: 2,
-	SHP: 2,
-	SLE: 2,
-	SOS: 2,
-	SRD: 2,
-	SSP: 2,
-	STN: 2,
-	SVC: 2,
-	SYP: 2,
-	SZL: 2,
-	THB: 2,
-	TJS: 2,
-	TMT: 2,
-	TND: 3,
-	TOP: 2,
-	TRY: 2,
-	TTD: 2,
-	TWD: 2,
-	TZS: 2,
-	UAH: 2,
-	UGX: 0,
-	USD: 2,
-	USN: 2,
-	UYI: 0,
-	UYU: 2,
-	UYW: 4,
-	UZS: 2,
-	VED: 2,
-	VES: 2,
-	VND: 0,
-	VUV: 0,
-	WST: 2,
-	XAD: 2,
-	XAF: 0,
-	XCD: 2,
-	XCG: 2,
-	XOF: 0,
-	XPF: 0,
-	YER: 2,
-	ZAR: 2,
-	ZMW: 2,
-	ZWG: 2
-});
-//#endregion
-export { ISO_4217_MINOR_UNITS as t };

package/dist/json-CEnpTHlZ.js

@@ -1,16 +0,0 @@
-//#region src/core/json.ts
-/** A `JSON.stringify` replacer: `bigint` values become decimal strings, as the wire codec writes them. */
-function jsonReplacer(_key, value) {
-	return typeof value === "bigint" ? value.toString() : value;
-}
-/** `Response.json` that writes `bigint` values as decimal strings instead of throwing. */
-function jsonResponse(data, init = {}) {
-	const headers = new Headers(init.headers);
-	if (!headers.has("content-type")) headers.set("content-type", "application/json");
-	return new Response(JSON.stringify(data, jsonReplacer), {
-		...init,
-		headers
-	});
-}
-//#endregion
-export { jsonResponse as n, jsonReplacer as t };