better-supabase 0.12.0 → 0.14.0

package/dist/client-Bj0xrUzr.js

@@ -0,0 +1,437 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as defineController } from "./controller-BEliOBOv.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+import { a as readAllFields, l as writeFields, n as blockFields, o as readFields, s as rowFields } from "./block-fields-DBSJSeaO.js";
+import { t as rankBetweenResult } from "./rank-result-C_sHjkiz.js";
+//#region src/blocks/saved-views/saved-views.ts
+const SAVED_VIEW_KINDS = [
+	"table",
+	"board",
+	"calendar",
+	"timeline",
+	"gantt"
+];
+const SAVED_VIEW_SCOPES = [
+	"user",
+	"team",
+	"tenant"
+];
+const SAVED_VIEW_DENSITIES = [
+	"compact",
+	"default",
+	"comfortable"
+];
+const strings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function columnIssues(value) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) return [{
+		message: "columns must be an object",
+		path: ["columns"]
+	}];
+	const issues = [];
+	for (const key of ["visible", "order"]) if (value[key] !== void 0 && !strings(value[key])) issues.push({
+		message: `columns.${key} must be a list of column ids`,
+		path: ["columns", key]
+	});
+	const sizes = value["sizes"];
+	if (sizes !== void 0 && !(isRecord(sizes) && Object.values(sizes).every(Number.isFinite))) issues.push({
+		message: "columns.sizes must map column ids to numbers",
+		path: ["columns", "sizes"]
+	});
+	const pinned = value["pinned"];
+	if (pinned !== void 0 && !(isRecord(pinned) && (pinned["left"] === void 0 || strings(pinned["left"])) && (pinned["right"] === void 0 || strings(pinned["right"])))) issues.push({
+		message: "columns.pinned must have left and right lists",
+		path: ["columns", "pinned"]
+	});
+	return issues;
+}
+/**
+* Checks a view's state, and its `query` against `list` when given. An empty
+* list means the state is valid.
+*/
+function savedViewIssues(state, list) {
+	if (!isRecord(state)) return [{ message: "state must be an object" }];
+	const issues = columnIssues(state["columns"]);
+	if (state["grouping"] !== void 0 && !strings(state["grouping"])) issues.push({
+		message: "grouping must be a list of column ids",
+		path: ["grouping"]
+	});
+	const density = state["density"];
+	if (density !== void 0 && !SAVED_VIEW_DENSITIES.some((item) => item === density)) issues.push({
+		message: `density must be one of ${SAVED_VIEW_DENSITIES.join(", ")}`,
+		path: ["density"]
+	});
+	if (state["layout"] !== void 0 && !isRecord(state["layout"])) issues.push({
+		message: "layout must be an object",
+		path: ["layout"]
+	});
+	if (state["collectionId"] !== void 0 && typeof state["collectionId"] !== "string") issues.push({
+		message: "collectionId must be a collection id",
+		path: ["collectionId"]
+	});
+	const query = state["query"];
+	if (query !== void 0) {
+		if (!isRecord(query)) issues.push({
+			message: "query must be an object",
+			path: ["query"]
+		});
+		else if (list) {
+			const parsed = list.parse(withoutPage(query));
+			for (const issue of parsed.ok ? [] : parsed.issues ?? []) issues.push({
+				message: issue.message,
+				path: ["query", ...issue.path ?? []]
+			});
+		}
+	}
+	return issues;
+}
+/** The JSON Schema of a view's state, with `query` from the list's schema. */
+function savedViewStateSchema(list) {
+	const ids = {
+		type: "array",
+		items: { type: "string" }
+	};
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		type: "object",
+		properties: {
+			query: list ? list.jsonSchema : { type: "object" },
+			columns: {
+				type: "object",
+				properties: {
+					visible: ids,
+					order: ids,
+					sizes: {
+						type: "object",
+						additionalProperties: { type: "number" }
+					},
+					pinned: {
+						type: "object",
+						properties: {
+							left: ids,
+							right: ids
+						},
+						additionalProperties: false
+					}
+				},
+				additionalProperties: false
+			},
+			grouping: ids,
+			density: { enum: [...SAVED_VIEW_DENSITIES] },
+			layout: { type: "object" },
+			collectionId: {
+				type: "string",
+				format: "uuid"
+			}
+		}
+	};
+}
+function storedState(state) {
+	if (!state.query) return { ...state };
+	return {
+		...state,
+		query: withoutPage(state.query)
+	};
+}
+function withoutPage(query) {
+	return Object.fromEntries(Object.entries(query).filter(([key]) => key !== "page" && key !== "after"));
+}
+function oneOfOr(values, value, fallback) {
+	return values.find((item) => item === value) ?? fallback;
+}
+function preferenceOf(value) {
+	const row = isRecord(value) ? value : {};
+	return {
+		isDefault: row["isDefault"] === true,
+		hidden: row["hidden"] === true,
+		pinned: row["pinned"] === true
+	};
+}
+function savedOf(value) {
+	const row = recordOf(value, "saved view");
+	return {
+		id: textOf(row["id"]),
+		rank: textOf(row["rank"]),
+		fields: rowFields(row["fields"])
+	};
+}
+function viewOf(value) {
+	const row = recordOf(value, "saved view");
+	const state = row["state"];
+	return {
+		id: textOf(row["id"]),
+		list: textOf(row["list"]),
+		scope: oneOfOr(SAVED_VIEW_SCOPES, row["scope"], "user"),
+		ownerId: optionalText(row["ownerId"]) ?? null,
+		teamId: optionalText(row["teamId"]) ?? null,
+		name: textOf(row["name"]),
+		kind: oneOfOr(SAVED_VIEW_KINDS, row["kind"], "table"),
+		state: isRecord(state) ? state : {},
+		rank: optionalText(row["rank"]) ?? "V",
+		isDefault: row["isDefault"] === true,
+		preference: preferenceOf(row["preference"]),
+		fields: rowFields(row["fields"])
+	};
+}
+function createSavedViews(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "saved view fields");
+	return withBlockHooks({
+		save: (input) => {
+			const issues = savedViewIssues(input.state, options.lists?.[input.list]);
+			if (issues.length > 0) return AsyncResult.err(dbError("validation", "the saved view's state is not valid", { issues }));
+			return writeFields(fields, input.fields, (checked) => call("save_view", {
+				tenant: input.organizationId,
+				list: input.list,
+				name: input.name,
+				kind: input.kind ?? "table",
+				scope: input.scope ?? "user",
+				team: input.teamId ?? null,
+				state: storedState(input.state),
+				view_id: input.id ?? null,
+				fields: checked
+			}, savedOf)).andThen((saved) => readFields(fields, saved));
+		},
+		list: (organizationId, list) => call("list_views", {
+			tenant: organizationId,
+			list
+		}, (value) => recordsOf(value, "list_views").map(viewOf)).andThen((views) => readAllFields(fields, views)),
+		reorder: (id, neighbors) => {
+			const key = rankBetweenResult(neighbors);
+			if (!key.ok) return AsyncResult.err(key.error);
+			return call("rank_view", {
+				view_id: id,
+				rank: key.data
+			}, () => key.data);
+		},
+		setDefault: (id, on = true) => call("set_default_view", {
+			view_id: id,
+			on_default: on
+		}, (value) => value === true),
+		setPreference: (id, preference) => call("set_view_preference", {
+			view_id: id,
+			make_default: preference.isDefault ?? null,
+			hide: preference.hidden ?? null,
+			pin: preference.pinned ?? null
+		}, preferenceOf),
+		duplicate: (id, input = {}) => call("duplicate_view", {
+			view_id: id,
+			scope: input.scope ?? "user",
+			name: input.name ?? null,
+			team: input.teamId ?? null
+		}, savedOf).andThen((saved) => readFields(fields, saved)),
+		delete: (id) => call("delete_view", { view_id: id }, (value) => value === true)
+	}, options.hooks, {
+		block: "saved-views",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/**
+* The view that opens first: the caller's preferred default, then the user's
+* slot default, a team default, the tenant's, then the first view. Views the
+* caller hid are skipped.
+*/
+function defaultView(views) {
+	const shown = views.filter((view) => view.preference?.hidden !== true);
+	const preferred = shown.find((view) => view.preference?.isDefault === true);
+	if (preferred) return preferred;
+	for (const scope of SAVED_VIEW_SCOPES) {
+		const match = shown.find((view) => view.isDefault && view.scope === scope);
+		if (match) return match;
+	}
+	return shown[0];
+}
+//#endregion
+//#region src/blocks/saved-views/query-state.ts
+const RESERVED = /* @__PURE__ */ new Set([
+	"q",
+	"sort",
+	"page",
+	"after",
+	"size",
+	"filter"
+]);
+const isStrings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const isFilter = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A list's URL state as the typed query a view stores, without the page. */
+function queryFromUrlState(state) {
+	const facets = {};
+	for (const [key, value] of Object.entries(state)) if (!RESERVED.has(key) && isStrings(value) && value.length > 0) facets[key] = value;
+	const q = state["q"];
+	const sort = state["sort"];
+	const size = state["size"];
+	const filter = state["filter"];
+	return {
+		...typeof q === "string" && q !== "" && { q },
+		...typeof sort === "string" && { sort },
+		...typeof size === "number" && { size },
+		...isFilter(filter) && { filter },
+		...Object.keys(facets).length > 0 && { facets }
+	};
+}
+/**
+* The URL state that opens a view's query: every key in `keys` (the current
+* state's), `null` unless the query sets it, so applying a view clears what the
+* previous one set. The page goes back to the first.
+*/
+function urlStateFromQuery(query, keys) {
+	const facets = query?.facets ?? {};
+	const next = {};
+	for (const key of keys) switch (key) {
+		case "q":
+			next[key] = query?.q ?? null;
+			break;
+		case "sort":
+			next[key] = query?.sort ?? null;
+			break;
+		case "size":
+			next[key] = query?.size ?? null;
+			break;
+		case "filter":
+			next[key] = query?.filter ?? null;
+			break;
+		case "page":
+		case "after":
+			next[key] = null;
+			break;
+		default: next[key] = facets[key]?.length ? facets[key] : null;
+	}
+	return next;
+}
+function canonical(value) {
+	if (Array.isArray(value)) return value.map(canonical);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0 && item !== null).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)]));
+	return value;
+}
+/** A view's state without `query`: the part `onApplyState` shows. */
+function displayStateOf(state) {
+	const { query: _query, ...display } = state;
+	return display;
+}
+/** Whether two states show the same columns, grouping, density and layout. */
+function sameDisplayState(a, b) {
+	const strip = (state) => canonical(state ? displayStateOf(state) : {});
+	return JSON.stringify(strip(a)) === JSON.stringify(strip(b));
+}
+/** Whether two stored queries select the same rows in the same order. */
+function sameQuery(a, b) {
+	const strip = (query) => {
+		if (!query) return {};
+		const { page: _page, after: _after, facets, ...rest } = query;
+		const kept = Object.entries(facets ?? {}).filter(([, values]) => values !== void 0 && values.length > 0);
+		return canonical(kept.length > 0 ? {
+			...rest,
+			facets: Object.fromEntries(kept)
+		} : rest);
+	};
+	return JSON.stringify(strip(a)) === JSON.stringify(strip(b));
+}
+//#endregion
+//#region src/blocks/saved-views/client.ts
+/** Matches the URL state and the display state against the loaded views. */
+function matchSavedViews(snapshot, urlState, display) {
+	const query = queryFromUrlState(urlState);
+	const shows = (view) => sameQuery(view.state.query, query) && (display === void 0 || sameDisplayState(view.state, display));
+	return {
+		active: snapshot.views?.find(shows),
+		query,
+		state: {
+			...display,
+			query
+		},
+		isDirty: snapshot.opened !== void 0 && !shows(snapshot.opened)
+	};
+}
+function needs(value, name) {
+	if (value === void 0) throw new Error(`better-supabase: saved views need \`${name}\``);
+	return value;
+}
+/**
+* Saved views of one list, synced with its URL state and, through `getState`
+* and `onApplyState`, with the table's columns, grouping, density and layout.
+*/
+function createSavedViewsController(options) {
+	return defineController({
+		views: void 0,
+		opened: void 0,
+		error: void 0
+	}, (state) => {
+		const apply = (view) => {
+			state.set({ opened: view });
+			options.setUrlState(urlStateFromQuery(view.state.query, Object.keys(options.urlState())));
+			options.onApplyState?.(displayStateOf(view.state), view);
+		};
+		const refresh = async () => {
+			try {
+				state.set({
+					views: await options.load(),
+					error: void 0
+				});
+			} catch (cause) {
+				state.set({ error: cause });
+			}
+		};
+		return {
+			actions: {
+				apply,
+				refresh,
+				saveCurrent: async (name, id) => {
+					const save = needs(options.save, "save");
+					const query = queryFromUrlState(options.urlState());
+					await save({
+						name,
+						query,
+						state: {
+							...options.getState?.(),
+							query
+						},
+						...id !== void 0 && { id }
+					});
+					await refresh();
+				},
+				remove: async (id) => {
+					await needs(options.remove, "remove")(id);
+					state.set((current) => ({ opened: current.opened?.id === id ? void 0 : current.opened }));
+					await refresh();
+				},
+				duplicate: async (id, name, scope) => {
+					await needs(options.duplicate, "duplicate")({
+						id,
+						name,
+						...scope !== void 0 && { scope }
+					});
+					await refresh();
+				},
+				setPreference: async (id, preference) => {
+					await needs(options.setPreference, "setPreference")(id, preference);
+					await refresh();
+				}
+			},
+			start: () => {
+				if (state.get().views !== void 0) return;
+				const run = state.run();
+				(async () => {
+					try {
+						const loaded = await options.load();
+						if (run !== state.run()) return;
+						state.set({
+							views: loaded,
+							error: void 0
+						});
+						if (options.openDefault !== false && sameQuery(queryFromUrlState(options.urlState()), void 0)) {
+							const first = defaultView(loaded.filter((view) => view.isDefault || view.preference?.isDefault === true));
+							if (first) apply(first);
+						}
+					} catch (cause) {
+						if (run === state.run()) state.set({ error: cause });
+					}
+				})();
+			}
+		};
+	});
+}
+//#endregion
+export { sameDisplayState as a, SAVED_VIEW_DENSITIES as c, createSavedViews as d, defaultView as f, queryFromUrlState as i, SAVED_VIEW_KINDS as l, savedViewStateSchema as m, matchSavedViews as n, sameQuery as o, savedViewIssues as p, displayStateOf as r, urlStateFromQuery as s, createSavedViewsController as t, SAVED_VIEW_SCOPES as u };

package/dist/client-Bn0qqRBg.d.ts

@@ -0,0 +1,37 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+import { a as Usage, h as UsageStatus } from "./usage-DBcVGqnr.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/usage/client.d.ts
+interface UsageMeterControllerOptions {
+  /** `createUsage({ transport })`, or a `Pick` with `overview`. */
+  readonly client: Pick<Usage, "overview">;
+  readonly auth: AuthPort;
+  /** The organization whose usage to read; the meter waits without one. */
+  readonly organizationId: string | null;
+  /**
+   * Only these meters, in this order. Default every meter with usage or a
+   * quota.
+   */
+  readonly meters?: readonly string[];
+}
+/** One meter against its quota. */
+interface MeterReading extends UsageStatus {
+  /** `used / limit` from 0 to 1, or `undefined` without a limit. */
+  readonly fraction: number | undefined;
+  /** True once the period's quota is used up. */
+  readonly exceeded: boolean;
+}
+interface UsageMeterSnapshot {
+  /** `undefined` until the first load. */
+  readonly meters: readonly MeterReading[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface UsageMeterActions {
+  /** Reads the usage again, such as after the app records some. */
+  readonly refresh: () => Promise<void>;
+}
+type UsageMeterController = Controller<UsageMeterSnapshot, UsageMeterActions>;
+/** This period's usage of an organization against its plan's quotas, per meter. */
+declare function createUsageMeterController(options: UsageMeterControllerOptions): UsageMeterController;
+//#endregion
+export { UsageMeterSnapshot as a, UsageMeterControllerOptions as i, UsageMeterActions as n, createUsageMeterController as o, UsageMeterController as r, MeterReading as t };

package/dist/client-Bni68sve.d.ts

@@ -0,0 +1,136 @@
+import { D as ValidationIssue } from "./result-C6jDfedy.js";
+import { n as Controller } from "./controller-DAD4hbl4.js";
+import { a as FormDefinition, c as FormJson, f as FormStep, i as FormCondition, l as FormJsonSchema, o as FormField } from "./form-definition-BjEtH8BT.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/forms/validate.d.ts
+/** A submission's answers, by field key. */
+type FormAnswers = {
+  readonly [key: string]: FormJson;
+};
+/**
+ * Checks answers against a form version's schema with the keywords the
+ * generator emits, so a form can show errors before it submits. Postgres checks
+ * the same schema again on submit; this is not a general JSON Schema
+ * validator.
+ */
+declare function validateAnswers(schema: FormJsonSchema, answers: unknown): readonly ValidationIssue[];
+/** A form version's schema as a Standard Schema, for form libraries. */
+declare function answersSchema(schema: FormJsonSchema): StandardSchemaV1<unknown, FormAnswers>;
+//#endregion
+//#region src/blocks/forms/questionnaire.d.ts
+/**
+ * Whether `condition` holds for `answers`, with the semantics of its JSON
+ * Schema `if`.
+ */
+declare function conditionHolds(condition: FormCondition | undefined, answers: FormAnswers): boolean;
+/** The steps whose `showIf` holds. */
+declare function visibleSteps(definition: FormDefinition, answers: FormAnswers): readonly FormStep[];
+/** The step's fields whose `showIf` holds. */
+declare function visibleFields(step: FormStep, answers: FormAnswers): readonly FormField[];
+/**
+ * The answers without the ones for hidden steps and fields. Removing an answer
+ * can hide a later field, so it repeats until nothing changes.
+ */
+declare function pruneAnswers(definition: FormDefinition, answers: FormAnswers): FormAnswers;
+/** The schema's issues for the fields `step` shows. */
+declare function stepIssues(schema: FormJsonSchema, step: FormStep, answers: FormAnswers): readonly ValidationIssue[];
+interface QuestionnaireState {
+  /** The step on screen, by key. */
+  readonly step: string;
+  readonly answers: FormAnswers;
+  /** The steps that passed their checks on `next`. */
+  readonly completed: readonly string[];
+  /** The issues of the step on screen after a `next` or `submit` that failed. */
+  readonly issues: readonly ValidationIssue[];
+}
+type QuestionnaireAction = {
+  readonly type: "answer";
+  readonly key: string;
+  readonly value: FormJson | undefined;
+} | {
+  readonly type: "next";
+} | {
+  readonly type: "back";
+} | {
+  readonly type: "goTo";
+  readonly step: string;
+} | {
+  readonly type: "reset";
+  readonly answers?: FormAnswers;
+};
+interface QuestionnaireForm {
+  readonly definition: FormDefinition;
+  /** The version's generated schema. */
+  readonly schema: FormJsonSchema;
+}
+/** The state before the first answer. */
+declare function initialQuestionnaire(form: QuestionnaireForm, answers?: FormAnswers): QuestionnaireState;
+/**
+ * The questionnaire as a reducer: answers, the current step and the steps done.
+ * `next` checks the step's fields against the version's schema and stays put
+ * with `issues` when one fails; hidden steps are skipped.
+ */
+declare function questionnaireReducer(form: QuestionnaireForm, state: QuestionnaireState, action: QuestionnaireAction): QuestionnaireState;
+interface QuestionnaireStepView {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly fields: readonly FormField[];
+  readonly completed: boolean;
+  readonly active: boolean;
+}
+/** The visible steps with their status, in the shape a Stepper renders. */
+declare function questionnaireSteps(form: QuestionnaireForm, state: QuestionnaireState): readonly QuestionnaireStepView[];
+/** The pruned answers, or every issue when the whole form does not pass. */
+declare function finishQuestionnaire(form: QuestionnaireForm, state: QuestionnaireState): {
+  readonly ok: true;
+  readonly answers: FormAnswers;
+} | {
+  readonly ok: false;
+  readonly issues: readonly ValidationIssue[];
+};
+//#endregion
+//#region src/blocks/forms/client.d.ts
+interface QuestionnaireOptions {
+  /** A form version, or anything with its `definition` and `schema`. */
+  readonly form: QuestionnaireForm;
+  /** Answers to start from, such as a saved draft. */
+  readonly initialAnswers?: FormAnswers;
+  /** Receives the answers of the visible fields once the whole form passes. */
+  readonly onSubmit: (answers: FormAnswers) => Promise<void> | void;
+}
+interface QuestionnaireSnapshot {
+  /** The visible steps, for a Stepper's items. */
+  readonly steps: readonly QuestionnaireStepView[];
+  /** The step on screen. */
+  readonly step: QuestionnaireStepView | undefined;
+  readonly answers: FormAnswers;
+  /**
+   * Issues by field key: the step on screen's after `next`, every field's after
+   * a failed `submit`.
+   */
+  readonly issues: Readonly<Record<string, readonly string[]>>;
+  readonly isFirst: boolean;
+  readonly isLast: boolean;
+  readonly submitting: boolean;
+}
+interface QuestionnaireActions {
+  /** `undefined` removes the answer. */
+  readonly setAnswer: (key: string, value: FormJson | undefined) => void;
+  /** Checks the step and moves to the next visible one. */
+  readonly next: () => void;
+  readonly back: () => void;
+  /** Moves to a step whose earlier steps are done, for a clickable Stepper. */
+  readonly goTo: (step: string) => void;
+  /** Checks the whole form, then calls `onSubmit`. Returns whether it passed. */
+  readonly submit: () => Promise<boolean>;
+  readonly reset: (answers?: FormAnswers) => void;
+}
+type QuestionnaireController = Controller<QuestionnaireSnapshot, QuestionnaireActions>;
+/**
+ * A multi-step form over a form version: the visible steps, the answers, and
+ * per-field issues checked against the version's JSON Schema.
+ */
+declare function createQuestionnaireController(options: QuestionnaireOptions): QuestionnaireController;
+//#endregion
+export { visibleFields as _, createQuestionnaireController as a, answersSchema as b, QuestionnaireState as c, finishQuestionnaire as d, initialQuestionnaire as f, stepIssues as g, questionnaireSteps as h, QuestionnaireSnapshot as i, QuestionnaireStepView as l, questionnaireReducer as m, QuestionnaireController as n, QuestionnaireAction as o, pruneAnswers as p, QuestionnaireOptions as r, QuestionnaireForm as s, QuestionnaireActions as t, conditionHolds as u, visibleSteps as v, validateAnswers as x, FormAnswers as y };

package/dist/client-BrtwaIBh.d.ts

@@ -0,0 +1,74 @@
+import { b as DbError, f as Result } from "./result-C6jDfedy.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/billing/client.d.ts
+/**
+ * A plan the picker lists: a key from the app's plan catalog, plus whatever the
+ * app shows.
+ */
+interface PlanOption {
+  readonly key: string;
+  readonly name: string;
+}
+/** The plans to offer and the tenant's current plan. */
+interface PlanCatalog<P> {
+  readonly plans: readonly P[];
+  /** The key of the tenant's current plan, `undefined` without a subscription. */
+  readonly current: string | undefined;
+}
+/**
+ * Where Checkout continues: Stripe's hosted page, or `undefined` when the
+ * server finished the change itself.
+ */
+interface CheckoutStarted {
+  readonly url: string | undefined;
+}
+interface PlanPickerControllerOptions<P extends {
+  readonly key: string;
+} = PlanOption> {
+  readonly auth: AuthPort;
+  /**
+   * The plans and the current one, such as a server action that reads the app's
+   * plan catalog and the tenant's subscription. It throws on failure.
+   */
+  readonly load: () => Promise<PlanCatalog<P>>;
+  /** What a server already loaded: the first load is skipped. */
+  readonly initial?: PlanCatalog<P>;
+  /**
+   * Starts Checkout for a plan key on the server, such as a server action that
+   * calls `billing.checkout()`. The controller never talks to Stripe: the
+   * secret key stays on the server.
+   */
+  readonly checkout: (plan: string) => Promise<Result<CheckoutStarted>>;
+  /**
+   * Opens the Checkout URL: `location.assign(url)` on the web,
+   * `WebBrowser.openBrowserAsync(url)` from `expo-web-browser` in React
+   * Native.
+   */
+  readonly open: (url: string) => void | Promise<void>;
+}
+interface PlanPickerSnapshot<P> {
+  /** `undefined` until the first load. */
+  readonly plans: readonly P[] | undefined;
+  readonly current: string | undefined;
+  /** The plan whose Checkout is starting. */
+  readonly pending: string | undefined;
+  readonly error: DbError | undefined;
+}
+interface PlanPickerActions {
+  /**
+   * Starts Checkout for `plan` and opens its URL; a failure is also kept in
+   * `error`. Choosing the current plan does nothing.
+   */
+  readonly choose: (plan: string) => Promise<Result<CheckoutStarted>>;
+  readonly refresh: () => Promise<void>;
+}
+type PlanPickerController<P> = Controller<PlanPickerSnapshot<P>, PlanPickerActions>;
+/**
+ * The plans with the tenant's current one, for a plan picker: `choose` starts
+ * Checkout through the injected server action and opens the URL it returns.
+ */
+declare function createPlanPickerController<P extends {
+  readonly key: string;
+} = PlanOption>(options: PlanPickerControllerOptions<P>): PlanPickerController<P>;
+//#endregion
+export { PlanPickerController as a, createPlanPickerController as c, PlanPickerActions as i, PlanCatalog as n, PlanPickerControllerOptions as o, PlanOption as r, PlanPickerSnapshot as s, CheckoutStarted as t };