better-supabase 0.8.0 → 0.9.0

package/dist/index-BfxOaOYs.d.ts

@@ -1,245 +0,0 @@
-import { b as DbError, f as Result, t as AsyncResult } from "./result-BchM1XZn.js";
-import { C as BucketClient, D as BucketPolicy, F as StorageAdminClient, Q as StoragePath, S as Bucket, T as BucketConnectOptions, r as StorageClient, w as BucketConfig } from "./storage-api-CB7Zl1Ci.js";
-import { SupabaseClient } from "@supabase/supabase-js";
-//#region src/storage/errors.d.ts
-/** Maps a Storage error (`StorageApiError`, fetch failures) to a `DbError`. */
-declare function fromStorageError(raw: unknown, table?: string): DbError;
-//#endregion
-//#region src/storage/image-url.d.ts
-interface StorageImageOptions {
-  /** Project URL, e.g. `import.meta.env.PUBLIC_SUPABASE_URL`. */
-  readonly url: string;
-  /** Resize mode for the transform. Defaults to Storage's own (`cover`). */
-  readonly resize?: "cover" | "contain" | "fill";
-}
-/** The size and quality to render an image at. */
-interface StorageImageSize {
-  readonly width: number;
-  readonly height?: number | undefined;
-  readonly quality?: number | undefined;
-}
-/**
- * Turns public Storage object URLs into Supabase image transformation URLs
- * (`/render/image/public`) at a given size. Any other URL (local files,
- * other hosts, signed URLs) comes back as `undefined`: a signed URL's token
- * covers the transform it was signed with, so sign it with `renderUrl()`.
- *
- * ```ts
- * const imageUrl = storageImageUrl({ url: SUPABASE_URL })
- * imageUrl(avatar, { width: 96 }) ?? avatar
- * ```
- */
-declare function storageImageUrl(options: StorageImageOptions): (src: string, size: StorageImageSize) => string | undefined;
-//#endregion
-//#region src/storage/registry.d.ts
-/** Any bucket definition from `defineBucket` or a preset. */
-type AnyBucket = Bucket<string>;
-type BucketMap = Readonly<Record<string, AnyBucket>>;
-/** The bucket ids of a registry's buckets. */
-type BucketIdOf<B extends BucketMap> = B[keyof B]["id"];
-/** The bucket of a registry whose id is `I`. */
-type BucketWithId<B extends BucketMap, I extends string> = Extract<B[keyof B], {
-  readonly id: I;
-}>;
-/** A stored object as rows keep it: the bucket id and the object path. */
-interface StoredRef {
-  /** The bucket id, e.g. a `bucket_id` column. */
-  readonly bucket: string;
-  readonly path: string;
-}
-/** A stored reference whose bucket is registered and whose path matches one of its templates. */
-interface ResolvedRef<B extends BucketMap> {
-  readonly bucket: B[keyof B];
-  readonly path: StoragePath<BucketIdOf<B>>;
-}
-/** A resolved reference with a client of its bucket. */
-interface ConnectedRef<B extends BucketMap> extends ResolvedRef<B> {
-  readonly storage: BucketClient<string, BucketIdOf<B>>;
-}
-interface Buckets<B extends BucketMap> {
-  /** The bucket definitions, by the names given. */
-  readonly buckets: B;
-  /** Every registered bucket id, in the order given. */
-  readonly ids: readonly BucketIdOf<B>[];
-  /** Whether `id` names a registered bucket. */
-  has(id: string): id is BucketIdOf<B>;
-  /** The bucket with this id, or `invalid_input` for an id no bucket has. */
-  byId<I extends BucketIdOf<B>>(id: I): Result<BucketWithId<B, I>>;
-  byId(id: string): Result<B[keyof B]>;
-  /**
-   * Checks a stored `{ bucket, path }`: the bucket must be registered and the
-   * path must match one of its templates. Either failure is `invalid_input`.
-   */
-  resolve(ref: StoredRef): Result<ResolvedRef<B>>;
-  /**
-   * `resolve`, then `connect` the bucket and check the path with the
-   * connected client, so a bucket with `tenant` also refuses another
-   * tenant's path (`forbidden`). No request is made.
-   */
-  connectStored(client: StorageClient, ref: StoredRef, options?: BucketConnectOptions): Result<ConnectedRef<B>>;
-}
-/**
- * A registry of bucket definitions by id, for rows that store a bucket id
- * next to an object path (files, attachments, sources). An id no bucket
- * has, and a path outside the bucket's templates, are errors, never a
- * fallback bucket.
- *
- * ```ts
- * export const buckets = defineBuckets({ files, attachments, logos });
- *
- * const ref = buckets.connectStored(supabase, {
- *   bucket: row.bucketId,
- *   path: row.path,
- * }, { context: db.$context });
- * if (ref.ok) await ref.data.storage.signedUrl(ref.data.path);
- * ```
- */
-declare function defineBuckets<const B extends BucketMap>(buckets: B): Buckets<B>;
-//#endregion
-//#region src/storage/presets.d.ts
-/** The image types browsers display everywhere. */
-declare const IMAGE_TYPES: readonly string[];
-interface ImageBucketOptions<P extends string, Id extends string> {
-  readonly id?: Id;
-  /** The path template; keep the preset's placeholders the policy relies on. */
-  readonly path?: P | readonly [P, ...P[]];
-  /** Defaults to `true`: images load from their public URL without signing. */
-  readonly public?: boolean;
-  readonly fileSizeLimit?: string | number;
-  readonly allowedMimeTypes?: readonly string[];
-  /** Replaces the preset's policy. */
-  readonly policy?: BucketPolicy;
-}
-type AvatarBucketOptions<P extends string, Id extends string> = ImageBucketOptions<P, Id>;
-interface OrganizationLogoBucketOptions<P extends string, Id extends string> extends ImageBucketOptions<P, Id> {
-  /**
-   * The permission that may upload, replace and delete a logo, checked
-   * through the access contract. Defaults to `organization.update`, the
-   * `organizations` module's update permission.
-   */
-  readonly permission?: string;
-  /**
-   * The tenant segment connected clients are held to. `false` lets one
-   * client upload for any organization the policy allows. Defaults to
-   * `{ param: 'organizationId' }`.
-   */
-  readonly tenant?: BucketConfig["tenant"] | false;
-}
-declare const AVATAR_PATH = "{userId}/avatar-{version}.{ext}";
-declare const LOGO_PATH = "{organizationId}/logo-{version}.{ext}";
-/**
- * A bucket for profile pictures: `{userId}/avatar-{version}.{ext}`, public,
- * 2 MiB of images, written only by their owner (the `owner` policy).
- */
-declare function avatarBucket<const P extends string = typeof AVATAR_PATH, const Id extends string = "avatars">(options?: AvatarBucketOptions<P, Id>): Bucket<P, Id>;
-/**
- * A bucket for organization logos: `{organizationId}/logo-{version}.{ext}`, public,
- * 2 MiB of images, written by members with the update permission through
- * the access contract (`tenant_ids_with`), so it follows the app's roles.
- */
-declare function organizationLogoBucket<const P extends string = typeof LOGO_PATH, const Id extends string = "organization-logos">(options?: OrganizationLogoBucketOptions<P, Id>): Bucket<P, Id>;
-//#endregion
-//#region src/storage/analytics-bucket.d.ts
-/** The Iceberg REST catalog of an analytics bucket, from `storage.analytics.from(id)`. */
-type AnalyticsCatalog = ReturnType<SupabaseClient["storage"]["analytics"]["from"]>;
-interface AnalyticsBucketClient {
-  /** Creates the bucket when it is missing. Needs the secret key. */
-  apply(): AsyncResult<{
-    readonly created: boolean;
-  }>;
-  /** The bucket's Iceberg catalog: namespaces and tables, each call returning `{ data, error }`. */
-  catalog(): AnalyticsCatalog;
-}
-interface AnalyticsBucket<Id extends string> {
-  readonly id: Id;
-  connect(client: StorageAdminClient): AnalyticsBucketClient;
-}
-/**
- * A Storage analytics bucket: Apache Iceberg tables that query engines read
- * through the Iceberg REST catalog.
- *
- * ```ts
- * export const events = defineAnalyticsBucket({ id: "events" });
- * await events.connect(admin).apply().orThrow();
- * ```
- */
-declare function defineAnalyticsBucket<const Id extends string>(config: {
-  readonly id: Id;
-}): AnalyticsBucket<Id>;
-//#endregion
-//#region src/storage/vector-bucket.d.ts
-type VectorDistance = "cosine" | "euclidean" | "dotproduct";
-interface VectorIndexConfig {
-  /** Number of values in every vector, e.g. 1536 for `text-embedding-3-small`. */
-  readonly dimension: number;
-  /** Defaults to `cosine`. */
-  readonly distanceMetric?: VectorDistance;
-  /** Metadata keys stored with each vector but not usable in `filter`. */
-  readonly nonFilterableMetadataKeys?: readonly string[];
-}
-interface VectorBucketConfig<Id extends string, I extends Readonly<Record<string, VectorIndexConfig>>> {
-  readonly id: Id;
-  readonly indexes: I;
-}
-type VectorMetadata = Readonly<Record<string, unknown>>;
-interface VectorRecord<M extends VectorMetadata = VectorMetadata> {
-  readonly key: string;
-  readonly vector: readonly number[];
-  readonly metadata?: M;
-}
-interface VectorHit<M extends VectorMetadata = VectorMetadata> {
-  readonly key: string;
-  /** Set by `query()`: smaller is closer for every metric. */
-  readonly distance?: number;
-  readonly metadata?: M;
-  readonly vector?: readonly number[];
-}
-interface VectorQueryOptions {
-  /** Number of matches, defaults to 10. */
-  readonly topK?: number;
-  /** A metadata filter, e.g. `{ organizationId: "o1" }` or `{ year: { $gte: 2024 } }`. */
-  readonly filter?: VectorMetadata;
-  /** Return each match's metadata. Defaults to `true`. */
-  readonly metadata?: boolean;
-}
-interface VectorIndexClient<M extends VectorMetadata = VectorMetadata> {
-  readonly name: string;
-  readonly dimension: number;
-  /** Inserts or replaces vectors by key, in batches of 500. */
-  put(records: readonly VectorRecord<M>[]): AsyncResult<number>;
-  /** The nearest vectors, closest first. */
-  query(vector: readonly number[], options?: VectorQueryOptions): AsyncResult<readonly VectorHit<M>[]>;
-  /** Vectors by key; missing keys are left out. */
-  get(keys: readonly string[], options?: {
-    readonly vector?: boolean;
-  }): AsyncResult<readonly VectorHit<M>[]>;
-  remove(keys: readonly string[]): AsyncResult<readonly string[]>;
-}
-interface VectorBucketClient<I extends string> {
-  /** Creates the bucket and any missing index. An index with another dimension or metric is a `conflict`. */
-  apply(): AsyncResult<{
-    readonly created: readonly string[];
-  }>;
-  index<M extends VectorMetadata = VectorMetadata>(name: I): VectorIndexClient<M>;
-}
-interface VectorBucket<Id extends string, I extends Readonly<Record<string, VectorIndexConfig>>> {
-  readonly id: Id;
-  readonly indexes: I;
-  connect(client: StorageAdminClient): VectorBucketClient<keyof I & string>;
-}
-/**
- * A Storage vector bucket with typed indexes. Storage keeps the vectors
- * outside Postgres; use the `vector-search` module for pgvector in a table.
- *
- * ```ts
- * export const embeddings = defineVectorBucket({
- *   id: "embeddings",
- *   indexes: { documents: { dimension: 1536 } },
- * });
- * const docs = embeddings.connect(admin).index("documents");
- * await docs.put([{ key: doc.id, vector, metadata: { organizationId } }]);
- * ```
- */
-declare function defineVectorBucket<const Id extends string, const I extends Readonly<Record<string, VectorIndexConfig>>>(config: VectorBucketConfig<Id, I>): VectorBucket<Id, I>;
-//#endregion
-export { defineBuckets as A, BucketIdOf as C, ConnectedRef as D, Buckets as E, StorageImageSize as M, storageImageUrl as N, ResolvedRef as O, fromStorageError as P, AnyBucket as S, BucketWithId as T, IMAGE_TYPES as _, VectorHit as a, avatarBucket as b, VectorMetadata as c, defineVectorBucket as d, AnalyticsBucket as f, AvatarBucketOptions as g, defineAnalyticsBucket as h, VectorDistance as i, StorageImageOptions as j, StoredRef as k, VectorQueryOptions as l, AnalyticsCatalog as m, VectorBucketClient as n, VectorIndexClient as o, AnalyticsBucketClient as p, VectorBucketConfig as r, VectorIndexConfig as s, VectorBucket as t, VectorRecord as u, ImageBucketOptions as v, BucketMap as w, organizationLogoBucket as x, OrganizationLogoBucketOptions as y };

package/dist/index-CicIyqOe.d.ts

@@ -1,55 +0,0 @@
-import { P as SchemaMeta } from "./types-CoE5Zwy4.js";
-import { h as MutationIntent } from "./executor-Drzu3dBK.js";
-import { a as EventHub, s as MutationNotice } from "./events-D1BOCll8.js";
-import { i as EventSink, n as CloudEventOptions, t as CloudEvent } from "./cloud-event-Dune0KI7.js";
-//#region src/events/index.d.ts
-declare const ROW_EVENT_TYPES: { readonly [K in MutationIntent]: string; };
-interface RowEventData {
-  readonly table: string;
-  readonly row: Readonly<Record<string, unknown>>;
-  readonly actorId?: string;
-}
-/**
- * One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
- * app-cased row and the actor in `data`, the primary key as `subject` and the
- * tenant as `partitionkey`. Writes that return no rows (soft
- * deletes, `returning: false`) send one event per known primary key, with the
- * key as `row`.
- */
-declare function toCloudEvents(notice: MutationNotice, options: CloudEventOptions & {
-  readonly meta?: SchemaMeta;
-}): CloudEvent<RowEventData>[];
-interface ForwardOptions extends CloudEventOptions {
-  /** Only forward these tables or kinds. */
-  readonly filter?: (notice: MutationNotice) => boolean;
-  /** Sink failures never fail the mutation. Defaults to the `Logger`. */
-  readonly onError?: (error: unknown, events: readonly CloudEvent[]) => void;
-}
-/**
- * Sends a CloudEvent for every mutation to `sink`. Returns a function that
- * stops forwarding. Sends in flight are tracked on `betterSupabase.events`
- * (`settled()`), which the Next adapter hands to `after()` and the edge
- * entry to `waitUntil`. Use an outbox (SQL modules) when events must not be lost.
- */
-declare function forwardMutations(betterSupabase: {
-  readonly events: EventHub;
-  readonly meta: SchemaMeta;
-}, sink: EventSink, options: ForwardOptions): () => void;
-type HttpMode = "structured" | "binary" | "batch";
-/** The HTTP protocol binding: headers and body for one event (or a batch). */
-declare function toHttp(events: CloudEvent | readonly CloudEvent[], mode?: HttpMode): {
-  headers: Record<string, string>;
-  body: string;
-}[];
-declare function isCloudEvent(value: unknown): value is CloudEvent;
-/** Reads CloudEvents from a request in any of the three HTTP modes. */
-declare function fromHttp(request: Request): Promise<CloudEvent[]>;
-interface HttpSinkOptions {
-  readonly mode?: HttpMode;
-  readonly headers?: Readonly<Record<string, string>>;
-  readonly fetch?: typeof fetch;
-}
-/** POSTs events to `url`. Non-2xx responses reject. */
-declare function httpSink(url: string | URL, options?: HttpSinkOptions): EventSink;
-//#endregion
-export { RowEventData as a, httpSink as c, toHttp as d, ROW_EVENT_TYPES as i, isCloudEvent as l, HttpMode as n, forwardMutations as o, HttpSinkOptions as r, fromHttp as s, ForwardOptions as t, toCloudEvents as u };

package/dist/index-D69h4QqD.d.ts

@@ -1,74 +0,0 @@
-import { x as SubscriptionStatus } from "./index-BCHR4Ucl.js";
-//#region src/blocks/inbox/react/index.d.ts
-/** Loads one list, e.g. a server action that calls `inbox.conversations.list()`. */
-type InboxSource<T> = () => Promise<readonly T[]>;
-interface UseInboxOptions<T> {
-  /** The organization; the hook joins `inbox:org:<id>`. `null` waits. */
-  readonly organizationId: string | null;
-  readonly load: InboxSource<T>;
-  /** `sql.modules.inbox.options.topic`. Defaults to `inbox`. */
-  readonly topic?: string;
-  /** Runs for each broadcast, e.g. to show a toast for `message`. */
-  readonly onMessage?: (event: string, payload: unknown) => void;
-}
-interface InboxListState<T> {
-  /** `undefined` until the first load. */
-  readonly items: readonly T[] | undefined;
-  readonly status: SubscriptionStatus;
-  readonly error: unknown;
-  readonly refresh: () => Promise<void>;
-}
-/**
- * The staff view of an organization's conversations, kept current: loads,
- * then loads again after each ping on `inbox:org:<id>` and on rejoin.
- */
-declare function useInbox<T>(options: UseInboxOptions<T>): InboxListState<T>;
-interface UseConversationOptions<T> {
-  /** `null` waits, e.g. before the widget opens a conversation. */
-  readonly conversationId: string | null;
-  /** The messages, oldest first. */
-  readonly load: InboxSource<T>;
-  readonly topic?: string;
-  /** How long a typing ping counts. Defaults to 5000 ms. */
-  readonly typingMs?: number;
-}
-interface ConversationState<T> extends InboxListState<T> {
-  /** User ids typing now, the caller left out. */
-  readonly typing: readonly string[];
-  /** Tells the others the caller is typing; call it on input, throttled. */
-  readonly setTyping: (typing: boolean) => void;
-}
-/**
- * One conversation's messages, kept current over `inbox:<id>`, with typing
- * pings between staff and the contact. Notes never reach this topic.
- */
-declare function useConversation<T>(options: UseConversationOptions<T>): ConversationState<T>;
-interface UseInboxWidgetOptions<T> {
-  /**
-   * Opens the visitor's conversation, e.g. a server action that calls
-   * `inbox.conversations.open(inboxId, { message })` with the visitor's
-   * transport. Returns its id.
-   */
-  readonly open: (message: string) => Promise<string>;
-  /** Sends into the open conversation. */
-  readonly send: (conversationId: string, message: string) => Promise<void>;
-  readonly load: (conversationId: string) => Promise<readonly T[]>;
-  /** Remembers the conversation across reloads. Defaults to `better-supabase:inbox-widget`. */
-  readonly storageKey?: string | null;
-  readonly topic?: string;
-}
-interface InboxWidgetState<T> extends ConversationState<T> {
-  readonly conversationId: string | null;
-  /** Opens the conversation with the first message, or sends into it. */
-  readonly submit: (message: string) => Promise<void>;
-  /** Forgets the conversation, so the next message opens a new one. */
-  readonly reset: () => void;
-}
-/**
- * The visitor side of an in-app inbox: the first message opens the
- * conversation, later ones go into it, and the messages and typing pings
- * stay current. Visitors without an account sign in anonymously first.
- */
-declare function useInboxWidget<T>(options: UseInboxWidgetOptions<T>): InboxWidgetState<T>;
-//#endregion
-export { UseConversationOptions as a, useConversation as c, InboxWidgetState as i, useInbox as l, InboxListState as n, UseInboxOptions as o, InboxSource as r, UseInboxWidgetOptions as s, ConversationState as t, useInboxWidget as u };

package/dist/index-DG2SUXDQ.d.ts

@@ -1,58 +0,0 @@
-import { c as SpecDiagnostic, r as DocumentFormat } from "./format-DTXdu8ya.js";
-import { r as ResourceDescription } from "./resource--vTrBe6I.js";
-import { C as ApiSource, _ as OpenApiDocuments, b as OpenApiVersion, l as AnyOpenApiDocument, n as DefineApiOptions, x as RenderedOpenApi } from "./api-Dnf2q-Ht.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/index-DoNVLHOU.d.ts

@@ -1,206 +0,0 @@
-import { n as DbException } from "./escape-like-DDWoHzh_.js";
-import { E as PrimaryKeyValue, H as Update, L as TableKey, V as UniqueWhere, a as AnyModels, i as AnyFunctions, x as Insert } from "./types-CoE5Zwy4.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-DmcfoNXB.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 };