better-supabase 0.13.0 → 0.14.0

package/dist/index-C7CrdGgz.d.ts

@@ -0,0 +1,562 @@
+import { b as DbError, f as Result, t as AsyncResult } from "./result-C6jDfedy.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, k as BlockEventsMatching } from "./events-DbLjvxDX.js";
+import { J as QuerySpec } from "./define-Dw7pRO4h.js";
+import { $ as TemplateValues, C as UploadOptions, O as TtlPreset, S as UploadBody, l as ImageTransform, w as UrlOptions, x as TransformOptions } from "./bucket-TkB7_xv8.js";
+import { P as SectionName, S as SectionWritesOf, _ as PlainSections, d as FeatureBlocks, h as Plain, m as FeatureWriteOutput, p as FeatureWriteInput, v as RecordCan, x as RecordWriteInput, y as RecordFeature } from "./index-DbXWcrOI.js";
+import { c as RealtimeClient, d as SubscribeOptions, g as TopicHandlers, i as PresenceOptions, m as Topic, p as SubscriptionStatus, r as PresenceMember, s as PresenceSubscription, t as EventSchemas } from "./topic-D9j8G2dw.js";
+import { t as AuthSnapshot } from "./bind-Dz8y3T5T.js";
+import { t as AuthSession } from "./view-2_I-2ukO.js";
+import { r as LiveCountSeed } from "./index-eTY4kJzo.js";
+import { _ as LiveQueryHookOptions, a as BlockQueryActions, b as ProfileOf, f as BroadcastOptions, h as LiveCountHookOptions, i as BlockMutationState, l as ActionInputOf, m as ClientLike, n as BlockEventSource, o as BlockQueryOptions, p as ClaimsOf, r as BlockMutationActions, s as BlockQueryState, u as ActionResultOf, x as UseActionOptions } from "./field-errors-vshYTVKr.js";
+import { i as BlockMethodName, n as BlockDataOf, t as BlockArgsOf } from "./block-method-hsPAGFi5.js";
+import { s as EntityFormValues, t as EntityForm } from "./entity-form-B67vq97h.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ReactNode, SubmitEvent } from "react";
+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>>;
+}
+/**
+ * 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/record.d.ts
+/** What a write resolves to: a `Result`, or a Server Action's `ActionResult`. */
+type WriteSettled<T> = Result<T> | {
+  readonly ok: true;
+  readonly data: T;
+  readonly error: null;
+} | {
+  readonly ok: false;
+  readonly data: null;
+  readonly error: DbError;
+};
+/**
+ * Server Actions for a feature's writes, such as `recordServer(...).actions`
+ * re-exported from a `"use server"` file. A write with none runs on the client
+ * over the provider's supabase-js client.
+ */
+type RecordWriteHandlers<B extends FeatureBlocks, N extends string> = { readonly [S in N]?: { readonly [W in SectionWritesOf<B, S>]?: (input: RecordWriteInput<FeatureWriteInput<B, S, W>>) => Promise<WriteSettled<Plain<FeatureWriteOutput<B, S, W>>>>; }; };
+/** What the server loaded, such as `recordServer(...).load(id)`. */
+interface RecordInitial<B extends FeatureBlocks, N extends string> {
+  readonly sections?: Partial<PlainSections<B, N>>;
+  readonly can?: RecordCan<B, N>;
+}
+interface RecordProviderProps<B extends FeatureBlocks, N extends string> {
+  /** The record's id. */
+  readonly id: string;
+  /** Sections and flags the server loaded, shown until the client loads. */
+  readonly initial?: RecordInitial<B, N>;
+  /** Server Actions for the writes; the rest run on the client. */
+  readonly writes?: RecordWriteHandlers<B, N>;
+  /**
+   * The private topic that hears of the record's changes, such as its block
+   * events. A section reloads when the topic carries one of its events.
+   */
+  readonly topic?: string | null;
+  readonly children?: ReactNode;
+}
+interface RecordState<B extends FeatureBlocks, N extends string> {
+  readonly subject: SubjectRef;
+  /** Each section settled, with Temporal values as ISO strings. */
+  readonly sections: Partial<PlainSections<B, N>>;
+  /** What the caller may do; every flag is `true` without `initial.can`. */
+  readonly can: RecordCan<B, N>;
+  readonly status: SubscriptionStatus;
+}
+interface RecordActionsOf<B extends FeatureBlocks, N extends string> {
+  /** Loads the named sections again, or every section. */
+  refresh(names?: readonly N[]): Promise<void>;
+  /** Runs one section write, then loads that section again. */
+  write<const S extends N, const W extends SectionWritesOf<B, S>>(section: S, write: W, input: FeatureWriteInput<B, S, W>): Promise<WriteSettled<Plain<FeatureWriteOutput<B, S, W>>>>;
+}
+/** The record context: `{ state, actions, meta }`. */
+interface RecordContextValue<T extends string, B extends FeatureBlocks, N extends string> {
+  readonly state: RecordState<B, N>;
+  readonly actions: RecordActionsOf<B, N>;
+  readonly meta: {
+    readonly feature: RecordFeature<T, B>;
+  };
+}
+interface RecordProviderKit<T extends string, B extends FeatureBlocks, N extends string> {
+  /** Loads the record's sections and follows `topic` for its children. */
+  readonly RecordProvider: (props: RecordProviderProps<B, N>) => ReactNode;
+  /** The record context; throws outside the provider. */
+  readonly useRecord: () => RecordContextValue<T, B, N>;
+}
+/**
+ * A provider and hook for one generated feature (ADR 0030): the provider holds
+ * a record controller over the client's blocks and the hook reads `{ state,
+ * actions, meta }`, so the record page's cards compose without prop drilling.
+ * Writes run through `writes` (Server Actions) when given, else on the client.
+ *
+ * ```tsx
+ * const { RecordProvider, useRecord } =
+ *   createRecordProvider(customerFeature);
+ *
+ * <RecordProvider id={id} initial={view} writes={customerActions}>
+ *   <CommentsCard />
+ * </RecordProvider>;
+ * ```
+ */
+declare function createRecordProvider<T extends string, B extends FeatureBlocks, N extends SectionName<B>>(feature: RecordFeature<T, B> & {
+  readonly sections: readonly N[];
+}): RecordProviderKit<T, B, N>;
+//#endregion
+//#region src/react/record-list.d.ts
+/**
+ * The list a record list's URL state belongs to: a `defineListQuery`
+ * definition, or a `defineRecordList`'s `list`.
+ */
+interface RecordListUrl<Q> {
+  /** The query with every default, for URL state the list refuses. */
+  readonly defaults: Q;
+  parse(input: URLSearchParams): {
+    readonly ok: true;
+    readonly value: Q;
+  } | {
+    readonly ok: false;
+  };
+  toSearchParams(query: Partial<Q>): URLSearchParams;
+}
+/** The URL state nuqs holds: one key per parser, `null` when absent. */
+type RecordListUrlState = Readonly<Record<string, unknown>>;
+/**
+ * What nuqs' `useQueryStates(list.nuqs(createParser))` returns: the state and
+ * its setter.
+ */
+type RecordListQueryStates = readonly [RecordListUrlState, (patch: Readonly<Record<string, unknown>>) => unknown];
+/** What `useRecordListState` returns. */
+interface RecordListState<Q> {
+  /** The URL state, one key per list parameter (`null` when unset). */
+  readonly state: RecordListUrlState;
+  /**
+   * The URL state parsed by the list, defaults filled in and typed; the
+   * defaults alone when the URL holds a value the list refuses.
+   */
+  readonly query: Q;
+  /**
+   * The URL state as query params, defaults left out, for the list route or
+   * `recordList.load` on the server.
+   */
+  readonly searchParams: URLSearchParams;
+  /**
+   * Sets keys and goes back to the first page, as a filter or sort change
+   * should.
+   */
+  set(patch: Readonly<Record<string, unknown>>): void;
+  /** Moves to a page number (offset lists) or an `after` cursor (cursor lists). */
+  setPage(page: number | string | null): void;
+  /** Clears every key the list owns. */
+  reset(): void;
+}
+/**
+ * A record list's URL state from nuqs, with the query params the server parses.
+ * Filter and sort changes reset the page. better-supabase doesn't import nuqs:
+ * pass what `useQueryStates` returns.
+ *
+ * ```tsx
+ * import { createParser, useQueryStates } from "nuqs";
+ *
+ * const parsers = customerList.nuqs(createParser);
+ *
+ * function Customers() {
+ *   const list = useRecordListState(customerList, useQueryStates(parsers));
+ *   list.set({ q: "acme" });
+ *   // fetch(`/api/customers/list?${list.searchParams}`)
+ * }
+ * ```
+ */
+declare function useRecordListState<Q>(list: RecordListUrl<Q>, queryStates: RecordListQueryStates): RecordListState<Q>;
+//#endregion
+//#region src/react/entity-form.d.ts
+interface UseEntityFormOptions<T> {
+  /** The values the form starts with, by field key. */
+  readonly initial?: Readonly<Record<string, unknown>>;
+  /** Receives the block input and the custom values once they validate. */
+  readonly onSubmit: (values: EntityFormValues<T>) => unknown;
+}
+/** What `useEntityForm` returns. */
+interface EntityFormState {
+  readonly values: Readonly<Record<string, unknown>>;
+  /** One message per field key, from the last submit. */
+  readonly errors: Readonly<Record<string, string>>;
+  /** True while `onSubmit` runs. */
+  readonly pending: boolean;
+  set(key: string, value: unknown): void;
+  /** Validates, then calls `onSubmit`; pass it to a form's `onSubmit`. */
+  submit(event?: {
+    preventDefault(): void;
+  }): Promise<void>;
+  reset(): void;
+}
+/**
+ * The state of a form from `entityForm`: the values by key, the errors of the
+ * last submit, and `submit`, which validates with the entity schema before it
+ * calls `onSubmit`.
+ *
+ * ```tsx
+ * const state = useEntityForm(form, {
+ *   onSubmit: (values) => create(values),
+ * });
+ * <form onSubmit={state.submit}>…</form>;
+ * ```
+ */
+declare function useEntityForm<T>(form: EntityForm<T>, options: UseEntityFormOptions<T>): EntityFormState;
+//#endregion
+//#region src/react/block-hooks.d.ts
+/**
+ * Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
+ * on mount and when its arguments change. `refetchOn` calls it again on block
+ * events.
+ */
+declare function useBlockQuery<C extends object, const K extends BlockMethodName<C>>(client: C, method: K, args: BlockArgsOf<C, K>, options?: BlockQueryOptions): BlockQueryState<BlockDataOf<C, K>> & BlockQueryActions;
+/** Calls a write method of any block client and tracks its state. */
+declare function useBlockMutation<C extends object, const K extends BlockMethodName<C>>(client: C, method: K): BlockMutationState<BlockDataOf<C, K>> & BlockMutationActions<BlockArgsOf<C, K>, BlockDataOf<C, K>>;
+/**
+ * Calls `handler` for each block event matching `pattern` (`"task.*"`), typed
+ * by `events` (`blockEvents` from `blocks.generated.ts`). `source` is the
+ * client's `betterSupabase`.
+ */
+declare function useBlockEvent<M extends EventMap, const P extends BlockEventPattern<M>>(source: BlockEventSource, events: Events<M>, pattern: P, handler: (event: BlockEvent<M, BlockEventsMatching<M, P>>) => void): void;
+//#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 `useImage` calls. */
+interface ImageSource<T, V extends string = never> {
+  readonly bucket: {
+    readonly id: string;
+    readonly public: boolean;
+    readonly variants: Readonly<Record<V, TransformOptions>>;
+  };
+  publicUrl(target: T, options?: {
+    readonly transform?: TransformOptions;
+    readonly cacheNonce?: string;
+  }): Result<string>;
+  signedUrl(target: T, options?: UrlOptions): AsyncResult<string>;
+}
+interface UseImageOptions {
+  /** Pixel densities for `srcSet`. Defaults to `[1, 2]`. */
+  readonly densities?: readonly number[];
+  /** How long signed URLs of a private bucket last. Defaults to `hour`. */
+  readonly ttl?: number | TtlPreset;
+  /** Added to the URLs so browsers fetch a replaced object again. */
+  readonly cacheNonce?: string;
+}
+interface StorageImage {
+  /** The URL at the first density; `undefined` while loading or paused. */
+  readonly src: string | undefined;
+  /** `url 1x, url 2x`; `undefined` while loading, paused, or for one density. */
+  readonly srcSet: string | undefined;
+  /** The transform's width and height, for the `<img>` attributes. */
+  readonly width: number | undefined;
+  readonly height: number | undefined;
+  readonly error: DbError | undefined;
+  readonly loading: boolean;
+}
+/**
+ * The `src` and `srcSet` of a stored image at a variant or transform. Public
+ * buckets build the URLs during render, with no request. Private buckets sign
+ * one URL per density and sign them again before they expire, since a signed
+ * URL's token covers the size it was signed at. Pass `null` as the target to
+ * pause.
+ *
+ * ```tsx
+ * const avatar = useImage(
+ *   avatars,
+ *   user ? { userId: user.id, version, ext } : null,
+ *   "md",
+ * );
+ * <img
+ *   src={avatar.src}
+ *   srcSet={avatar.srcSet}
+ *   width={avatar.width}
+ *   height={avatar.height}
+ *   alt=""
+ * />;
+ * ```
+ */
+declare function useImage<T, V extends string = never>(source: ImageSource<T, V>, target: T | null | undefined, transform: ImageTransform<V>, options?: UseImageOptions): StorageImage;
+/** 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 { useSupabase as $, useRecordListState as A, ActionHandle as B, EntityFormState as C, RecordListState as D, RecordListQueryStates as E, RecordProviderProps as F, BetterSupabaseProvider as G, useAction as H, RecordState as I, createHooks as J, BetterSupabaseProviderProps as K, RecordWriteHandlers as L, RecordContextValue as M, RecordInitial as N, RecordListUrl as O, RecordProviderKit as P, useLiveQuery as Q, createRecordProvider as R, useBlockQuery as S, useEntityForm as T, useActionForm as U, UseActionFormOptions as V, BetterHooks as W, useBroadcast as X, useAuth as Y, useLiveCount as Z, PresenceHookOptions as _, Upload as a, useBlockEvent as b, UseImageOptions as c, useSignedUrl as d, useUpload as f, Presence as g, useDebouncedSearch as h, StorageImage as i, RecordActionsOf as j, RecordListUrlState as k, UseUploadOptions as l, DebouncedSearchOptions as m, SignedUrl as n, UploadStatus as o, DebouncedSearch as p, LiveCount as q, SignedUrlSource as r, UploadTarget as s, ImageSource as t, useImage as u, PresenceTopic as v, UseEntityFormOptions as w, useBlockMutation as x, usePresence as y, ActionForm as z };