better-supabase 0.7.1 → 0.9.0

package/dist/index-CewnYSpv.d.ts

@@ -1,267 +0,0 @@
-import { b as DbError, f as Result, t as AsyncResult } from "./result-D7y2fT87.js";
-import { it as QuerySpec } from "./define-CJJkkr1-.js";
-import { C as UrlOptions, S as UploadOptions, x as UploadBody } from "./bucket-Cl46E3jS.js";
-import { n as TemplateValues } from "./template-CwO38Do8.js";
-import { t as AuthSnapshot } from "./bind-Bu_ZNa3W.js";
-import { t as AuthSession } from "./view-CF7ihnkg.js";
-import { S as Topic, _ as RealtimeClient, f as PresenceMember, g as PresenceSubscription, p as PresenceOptions, r as LiveCountSeed, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus, y as SubscribeOptions } from "./index-DunNRdnT.js";
-import { a as BroadcastOptions, f as UseActionOptions, l as LiveQueryHookOptions, n as ActionInputOf, o as ClientLike, r as ActionResultOf, s as LiveCountHookOptions } from "./field-errors-BFOa7WhB.js";
-import { SupabaseClient } from "@supabase/supabase-js";
-import { ReactNode, SubmitEvent } from "react";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-import { QueryClient } from "@tanstack/query-core";
-//#region src/react/hooks.d.ts
-interface BetterSupabaseProviderProps {
-  readonly client: ClientLike;
-  /** better-supabase queries are removed when the user signs out or changes. */
-  readonly queryClient?: QueryClient;
-  readonly children?: ReactNode;
-}
-/** Provides the better-supabase client to the hooks. */
-declare function BetterSupabaseProvider(props: BetterSupabaseProviderProps): ReactNode;
-/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
-declare function useAuth(): AuthSnapshot;
-declare function useSupabase(): SupabaseClient;
-interface BetterHooks<B extends ClientLike> {
-  /** Repositories bound to the current session. Re-renders when the user changes. */
-  readonly useDb: () => B["db"];
-  /** TanStack Query option factories: `useQuery(useQueries().customers.findMany())`. */
-  readonly useQueries: () => B["queries"];
-  readonly useSupabase: () => SupabaseClient;
-  readonly useAuth: () => AuthSnapshot;
-  /** `useSession()` typed by the client's `betterSupabase.claims(schema)` and `betterSupabase.userMetadata(schema)`. */
-  readonly useSession: () => AuthSession<ClaimsOf<B>, ProfileOf<B>>;
-}
-/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
-type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
-  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
-} ? C : unknown;
-/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
-type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
-  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
-} ? P : unknown;
-/**
- * Hooks typed for your schema.
- *
- * ```ts
- * export const { useDb, useQueries, useAuth } = createHooks<typeof bs>();
- * ```
- */
-declare function createHooks<B extends ClientLike>(): BetterHooks<B>;
-/**
- * Subscribes to a topic while mounted. Pass `null` values to pause. It
- * resubscribes when the topic or the signed-in user changes.
- *
- * ```ts
- * useBroadcast(customersTopic, organizationId ? { organizationId } : null, {}, { invalidate: ['customers'] });
- * ```
- */
-declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: TemplateValues<P> | null | undefined, handlers?: TopicHandlers<E>, options?: BroadcastOptions): SubscriptionStatus;
-/**
- * Keeps a query fresh: invalidates every cached query that read a table the
- * spec touches whenever one of them changes. Pass `null` to pause. It
- * resubscribes when the spec, tenant or user changes.
- *
- * ```ts
- * const spec = betterSupabase.spec.customers.findMany({ include: { notes: true } });
- * const { data } = useQuery(q.$spec(spec));
- * useLiveQuery(spec);
- * ```
- */
-declare function useLiveQuery(spec: QuerySpec | null | undefined, options?: LiveQueryHookOptions): SubscriptionStatus;
-interface LiveCount {
-  /** `undefined` until the first count arrives. */
-  readonly count: number | undefined;
-  readonly status: SubscriptionStatus;
-  /** The last failed refetch; the previous count stays. */
-  readonly error: DbError | undefined;
-}
-/**
- * A count that stays current: refetches only the `count` spec (a HEAD
- * request) after each debounced change to a table it reads, and after the
- * channel rejoins. Takes a spec or a `bs.liveCount()` seed; pass `null` to
- * pause. Doesn't need a `QueryClient`.
- *
- * ```tsx
- * const { count } = useLiveCount(seed); // seed = await bs.liveCount(spec)
- * ```
- */
-declare function useLiveCount(source: QuerySpec<string, "count", number> | LiveCountSeed | null | undefined, options?: LiveCountHookOptions): LiveCount;
-//#endregion
-//#region src/react/actions.d.ts
-interface ActionHandle<I, T> {
-  /** Runs the action in a transition; resolves with its result. */
-  run(input: I): Promise<ActionResultOf<T>>;
-  /** True while a run is in flight, including the router update it causes. */
-  readonly pending: boolean;
-  /** The inputs of the runs in flight, e.g. to dim one table row. */
-  readonly pendingInputs: readonly I[];
-  /** The input of the latest run in flight. */
-  readonly pendingInput: I | undefined;
-  /** The data of the last successful run. */
-  readonly data: T | undefined;
-  /** The error of the last run, until the next one starts. */
-  readonly error: DbError | undefined;
-  reset(): void;
-}
-/**
- * Calls a Server Action from an event handler: tracks pending inputs and the
- * last result, and calls `onSuccess` or `onError`.
- *
- * ```tsx
- * const remove = useAction(removeMember, { onError: (e) => toast.error(message(e)) });
- * <Button disabled={remove.pendingInputs.some((p) => p.userId === id)} onClick={() => remove.run({ userId: id })} />
- * ```
- */
-declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
-interface UseActionFormOptions<T> {
-  readonly onSuccess?: (data: T, form: HTMLFormElement) => void;
-  readonly onError?: (error: DbError, form: HTMLFormElement) => void;
-  /** Clear the fields after a successful run. Defaults to true. */
-  readonly resetOnSuccess?: boolean;
-}
-interface ActionForm<T> {
-  /** Spread on the `<form>`. */
-  readonly formProps: {
-    readonly onSubmit: (event: SubmitEvent<HTMLFormElement>) => void;
-  };
-  readonly pending: boolean;
-  readonly data: T | undefined;
-  readonly error: DbError | undefined;
-  /** The first message per top-level field of a `validation` error. */
-  readonly fieldErrors: Readonly<Partial<Record<string, string>>>;
-  reset(): void;
-}
-/**
- * A `<form>` that submits `FormData` to a Server Action. Fields keep what
- * the user typed when the action fails (a `<form action>` resets them) and
- * clear only on success.
- *
- * ```tsx
- * const form = useActionForm(createCustomer, { onSuccess: () => toast.success('Saved') });
- * <form {...form.formProps}>
- *   <Input name="name" aria-invalid={form.fieldErrors.name !== undefined} />
- * </form>
- * ```
- */
-declare function useActionForm<T>(action: (input: FormData) => Promise<ActionResultOf<T>>, options?: UseActionFormOptions<T>): ActionForm<T>;
-//#endregion
-//#region src/react/presence.d.ts
-interface PresenceHookOptions<I> {
-  /**
-   * The state this client shares while mounted. It is tracked after the
-   * join and tracked again when its JSON changes; `null` stays untracked.
-   */
-  readonly state?: I | null;
-  /** A supabase-js client for apps without `<BetterSupabaseProvider>`. */
-  readonly client?: SupabaseClient;
-}
-interface Presence<I, O> {
-  /** Everyone on the topic, this client included, from the last sync. */
-  readonly members: readonly PresenceMember<O>[];
-  readonly status: SubscriptionStatus;
-  /** Shares a state now; the `state` option tracks one for you. */
-  readonly track: (state: I) => Promise<DbError | undefined>;
-  readonly untrack: () => Promise<DbError | undefined>;
-}
-/** The parts of a `defineTopic(..., { presence })` topic the hook uses. */
-interface PresenceTopic<P extends string, I, O> {
-  topic(values: TemplateValues<P>): string;
-  match(topic: string): TemplateValues<P> | null;
-  subscribe(client: RealtimeClient, values: TemplateValues<P>, handlers: Readonly<Record<string, never>>, options?: SubscribeOptions & PresenceOptions<O>): PresenceSubscription<I, O>;
-}
-/**
- * Joins a presence topic while mounted and returns who is on it. Pass
- * `null` values to pause. It rejoins when the topic or the user changes.
- *
- * ```tsx
- * const { members } = usePresence(roomTopic, { roomId }, { state: { name } });
- * ```
- */
-declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: TemplateValues<P> | null | undefined, options?: PresenceHookOptions<I>): Presence<I, O>;
-//#endregion
-//#region src/react/search.d.ts
-interface DebouncedSearchOptions {
-  /** Defaults to 250 ms. */
-  readonly delayMs?: number;
-  /** Shorter terms count as no search. Defaults to 1. */
-  readonly minLength?: number;
-}
-interface DebouncedSearch {
-  /** What the input shows; updates on every keystroke. */
-  readonly value: string;
-  readonly setValue: (value: string) => void;
-  /** The trimmed value once typing pauses, or `undefined` below `minLength`. */
-  readonly term: string | undefined;
-  /** `term` with `%` and `_` escaped and wrapped in `%`, for `like` and `ilike`. */
-  readonly pattern: string | undefined;
-  /** `value` changed and `term` hasn't caught up yet. */
-  readonly pending: boolean;
-}
-/**
- * A search box's value, debounced. Pass `term` to `contains` (which
- * escapes it) or `pattern` to `ilike`; both are `undefined` while empty.
- *
- * ```tsx
- * const search = useDebouncedSearch();
- * useQuery(q.customers.findMany({ where: search.term ? { name: { contains: search.term } } : {} }));
- * ```
- */
-declare function useDebouncedSearch(initial?: string, options?: DebouncedSearchOptions): DebouncedSearch;
-//#endregion
-//#region src/react/storage.d.ts
-/** The part of a connected bucket `useSignedUrl` calls. */
-interface SignedUrlSource<T> {
-  signedUrl(target: T, options?: UrlOptions): AsyncResult<string>;
-}
-interface SignedUrl {
-  /** `undefined` until the first URL arrives, and while paused. */
-  readonly url: string | undefined;
-  readonly error: DbError | undefined;
-  readonly loading: boolean;
-}
-/**
- * A signed URL for an object, signed again before it expires. Pass `null`
- * as the target to pause. Connect the bucket with `cacheSignedUrls: true`
- * so components showing the same object share one URL.
- *
- * ```tsx
- * const { url } = useSignedUrl(avatars, user ? { userId: user.id } : null, { ttl: 'hour' });
- * ```
- */
-declare function useSignedUrl<T>(bucket: SignedUrlSource<T>, target: T | null | undefined, options?: UrlOptions): SignedUrl;
-/** The part of a connected bucket `useUpload` calls. */
-interface UploadTarget<T, R> {
-  upload(target: T, body: UploadBody, options?: UploadOptions): AsyncResult<R>;
-}
-type UploadStatus = "idle" | "uploading" | "done" | "error";
-interface Upload<T, R> {
-  readonly status: UploadStatus;
-  /** 0 to 1 while uploading; see `UploadOptions.onProgress` for when it is exact. */
-  readonly progress: number;
-  readonly data: R | undefined;
-  readonly error: DbError | undefined;
-  /** Starts an upload; a new one aborts the one in flight. */
-  readonly upload: (target: T, body: UploadBody, options?: Omit<UploadOptions, "signal" | "onProgress">) => Promise<Result<R>>;
-  /** Cancels the upload in flight. */
-  readonly abort: () => void;
-  /** Back to `idle`. */
-  readonly reset: () => void;
-}
-interface UseUploadOptions<R> {
-  readonly onSuccess?: (data: R) => void;
-  readonly onError?: (error: DbError) => void;
-}
-/**
- * Uploads to a connected bucket with progress, abort and status state.
- * Unmounting aborts the upload in flight.
- *
- * ```tsx
- * const avatar = useUpload(avatars, { onSuccess: ({ path }) => save(path) });
- * <input type="file" onChange={(e) => avatar.upload({ userId }, e.target.files[0], { upsert: true })} />
- * <progress value={avatar.progress} />
- * ```
- */
-declare function useUpload<T, R>(bucket: UploadTarget<T, R>, options?: UseUploadOptions<R>): Upload<T, R>;
-//#endregion
-export { useLiveCount as A, BetterSupabaseProviderProps as C, createHooks as D, ProfileOf as E, useSupabase as M, useAuth as O, BetterSupabaseProvider as S, LiveCount as T, ActionHandle as _, UploadTarget as a, useActionForm as b, useUpload as c, useDebouncedSearch as d, Presence as f, ActionForm as g, usePresence as h, UploadStatus as i, useLiveQuery as j, useBroadcast as k, DebouncedSearch as l, PresenceTopic as m, SignedUrlSource as n, UseUploadOptions as o, PresenceHookOptions as p, Upload as r, useSignedUrl as s, SignedUrl as t, DebouncedSearchOptions as u, UseActionFormOptions as v, ClaimsOf as w, BetterHooks as x, useAction as y };

package/dist/index-ClmjK_o-.d.ts

@@ -1,55 +0,0 @@
-import { P as SchemaMeta } from "./types-6BdhkmZe.js";
-import { h as MutationIntent } from "./executor-DvsBbNBS.js";
-import { a as EventHub, s as MutationNotice } from "./events-DWDhx77e.js";
-import { n as CloudEventOptions, r as EventSink, t as CloudEvent } from "./cloud-event-C1JCc1bH.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-D48jVS-N.d.ts

@@ -1,246 +0,0 @@
-import { b as DbError, f as Result, t as AsyncResult } from "./result-D7y2fT87.js";
-import { n as StoragePath } from "./path-Cv__-OTj.js";
-import { a as BucketConnectOptions, h as StorageClient, i as BucketConfig, n as Bucket, r as BucketClient, s as BucketPolicy } from "./bucket-Cl46E3jS.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: StorageClient): 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: StorageClient): 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-DQh4VCc9.d.ts

@@ -1,98 +0,0 @@
-import { P as SchemaMeta, u as ClaimsMeta } from "./types-6BdhkmZe.js";
-import { h as Generator } from "./config-D44Y7PAv.js";
-//#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/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>>;
-  };
-}
-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;
-}
-type JsonSchema = Record<string, unknown>;
-/** JSON Schema (2020-12) `$defs` for every table: `customersRow`, `customersInsert`, ... */
-declare function buildJsonSchema(input: DocsSource, id?: string): JsonSchema;
-/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
-declare function jsonSchema(options?: JsonSchemaGeneratorOptions): 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>>;
-}
-/** Zod 4 schemas for every table's Row, Insert and Update shape. */
-declare function zod(options?: ZodGeneratorOptions): Generator;
-//#endregion
-export { JsonSchemaGeneratorOptions as a, ClaimPaths as c, tenantClaimPaths as d, valibot as i, DEFAULT_CLAIMS as l, zod as n, buildJsonSchema as o, ValibotGeneratorOptions as r, jsonSchema as s, ZodGeneratorOptions as t, claimPaths as u };