better-supabase 0.12.0 → 0.13.0

package/dist/client-Ch-dDfTB.js

@@ -0,0 +1,437 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { t as AsyncResult } from "./result-DIT_qp4G.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-DwE32_gT.js";
+import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
+import { a as readAllFields, l as writeFields, n as blockFields, o as readFields, s as rowFields } from "./block-fields-Cwd4c8m-.js";
+import { t as rankBetweenResult } from "./rank-result-C6vsw27N.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-CuFD4o56.d.ts

@@ -0,0 +1,111 @@
+import { b as DbError, f as Result, t as AsyncResult } from "./result-mijqfoJN.js";
+import { t as StandardSchemaV1 } from "./standard-16AIDny5.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-DnXkMney.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-DyA5BAW4.js";
+import { n as BlockHooks } from "./block-hooks-BadAniNI.js";
+import { n as Controller, t as AuthPort } from "./controller-lWRcKqCl.js";
+import { t as RankNeighbors } from "./rank-result-DHflCNwo.js";
+//#region src/blocks/tags/tags.d.ts
+interface TagsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the tag's extra columns
+   * (`blocks.tags.options.extraColumns`), keyed by database name. It types and
+   * parses them on reads, and validates them on `create` and `update`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Tags<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A tag. `F` types the extra columns the `fields` schema describes. */
+interface Tag<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly name: string;
+  readonly slug: string;
+  /** Its rank key among the tenant's tags of the same kind, when it has one. */
+  readonly rank?: string;
+  /** Set on the tags `list` and `forSubject` return. */
+  readonly kind?: string;
+  readonly color?: string;
+  readonly description?: string;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface Tags<F extends object = Record<never, never>> {
+  /** Creates a tag; `fields` sets its extra columns. */
+  create(organizationId: string, kind: string, name: string, color?: string, description?: string, fields?: Partial<F>): AsyncResult<Tag<F>>;
+  /**
+   * Renames a tag (`name` null keeps it) and sets the extra columns `fields`
+   * names.
+   */
+  update(id: string, name: string | null, fields?: Partial<F>): AsyncResult<boolean>;
+  /**
+   * Moves a tag between the tags with rank keys `previous` and `next`. Resolves
+   * to its new key.
+   */
+  reorder(id: string, neighbors: RankNeighbors): AsyncResult<string>;
+  delete(id: string): AsyncResult<boolean>;
+  tag(organizationId: string, subjectType: string, subjectId: string, tagId: string): AsyncResult<boolean>;
+  untag(organizationId: string, subjectType: string, subjectId: string, tagId: string): AsyncResult<boolean>;
+  /** The tenant's tags of `kind` (every kind without it), in rank order. */
+  list(organizationId: string, kind?: string): AsyncResult<readonly Tag<F>[]>;
+  /** The tags on one subject, in rank order; the caller must be able to read it. */
+  forSubject(organizationId: string, subjectType: string, subjectId: string): AsyncResult<readonly Tag<F>[]>;
+}
+/** The `tags` SQL module as typed calls. */
+declare function createTags<S extends StandardSchemaV1 | undefined = undefined>(options: TagsOptions<S>): Tags<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/tags/client.d.ts
+/** A tag change on the subject that committed, for `onChanged`. */
+type TagChange = {
+  readonly kind: "added";
+  readonly tag: Tag;
+  readonly created: boolean;
+} | {
+  readonly kind: "removed";
+  readonly tag: Tag;
+};
+interface TagInputControllerOptions {
+  readonly client: Pick<Tags, "list" | "forSubject" | "tag" | "untag" | "create">;
+  readonly auth: AuthPort;
+  /** The organization; the input waits without one. */
+  readonly organizationId: string | null;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** The kind of tags the input offers and creates, such as `customer`. */
+  readonly kind: string;
+  /** Runs after a tag was added or removed. A throw is kept in `error`. */
+  readonly onChanged?: (change: TagChange) => void | Promise<void>;
+}
+interface TagInputSnapshot {
+  /** The subject's tags, in rank order; `undefined` until the first load. */
+  readonly tags: readonly Tag[] | undefined;
+  /** Every tag of the kind, for suggestions; `undefined` until the first load. */
+  readonly available: readonly Tag[] | undefined;
+  /** The tag ids, or the names of tags being created, with a write in flight. */
+  readonly pending: readonly string[];
+  readonly error: DbError | undefined;
+}
+interface TagInputActions {
+  /** Adds an existing tag, shown at once and taken back when it fails. */
+  readonly add: (tagId: string) => Promise<Result<Tag>>;
+  /** Removes a tag, hidden at once and put back when it fails. */
+  readonly remove: (tagId: string) => Promise<Result<boolean>>;
+  /**
+   * Adds the tag called `name`: an existing one of the kind with the same name
+   * (ignoring case), or a new one, which needs `tags.manage`.
+   */
+  readonly create: (name: string) => Promise<Result<Tag>>;
+  readonly refresh: () => Promise<void>;
+}
+type TagInputController = Controller<TagInputSnapshot, TagInputActions>;
+/**
+ * One subject's tags for a tag input: the tags on it, every tag of the kind for
+ * suggestions, and `add`, `remove` and `create`, which show the change at
+ * once.
+ */
+declare function createTagInputController(options: TagInputControllerOptions): TagInputController;
+//#endregion
+export { TagInputSnapshot as a, Tags as c, TagInputControllerOptions as i, TagsOptions as l, TagInputActions as n, createTagInputController as o, TagInputController as r, Tag as s, TagChange as t, createTags as u };

package/dist/client-D2y_CfhU.d.ts

@@ -0,0 +1,137 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, f as Result } from "./result-mijqfoJN.js";
+import { n as Controller, t as AuthPort } from "./controller-lWRcKqCl.js";
+import { t as AuthReply } from "./auth-reply-Dj124sbX.js";
+//#region src/blocks/sessions/client.d.ts
+/** An OAuth client as the Auth OAuth server describes it. */
+interface RawOAuthClient {
+  readonly id: string;
+  readonly name: string;
+  readonly uri?: string;
+  readonly logo_uri?: string;
+}
+/** The part of `supabase.auth.oauth` the consent controllers call. */
+interface OAuthApi {
+  getAuthorizationDetails(authorizationId: string): PromiseLike<AuthReply<{
+    readonly authorization_id: string;
+    readonly redirect_uri: string;
+    readonly client: RawOAuthClient;
+    readonly user: {
+      readonly id: string;
+      readonly email: string;
+    };
+    readonly scope: string;
+  } | {
+    readonly redirect_url: string;
+  }>>;
+  approveAuthorization(authorizationId: string, options?: {
+    skipBrowserRedirect?: boolean;
+  }): PromiseLike<AuthReply<{
+    readonly redirect_url: string;
+  }>>;
+  denyAuthorization(authorizationId: string, options?: {
+    skipBrowserRedirect?: boolean;
+  }): PromiseLike<AuthReply<{
+    readonly redirect_url: string;
+  }>>;
+  listGrants(): PromiseLike<AuthReply<readonly {
+    readonly client: RawOAuthClient;
+    readonly scopes: readonly string[];
+    readonly granted_at: string;
+  }[]>>;
+  revokeGrant(options: {
+    clientId: string;
+  }): PromiseLike<AuthReply<unknown>>;
+}
+interface OAuthClientInfo {
+  readonly id: string;
+  readonly name: string;
+  readonly uri: string | undefined;
+  readonly logoUri: string | undefined;
+}
+/** An authorization request waiting for the user's decision. */
+interface OAuthConsentRequest {
+  readonly authorizationId: string;
+  readonly client: OAuthClientInfo;
+  readonly user: {
+    readonly id: string;
+    readonly email: string;
+  };
+  readonly scopes: readonly string[];
+  /** The redirect URI the client registered. */
+  readonly redirectUri: string;
+  /** Its host, to show where approving sends the user. */
+  readonly redirectHost: string;
+}
+interface OAuthConsentControllerOptions {
+  /** `supabase.auth.oauth` of the browser client. */
+  readonly oauth: OAuthApi;
+  readonly auth: AuthPort;
+  /** `authorization_id` from the consent page's URL; `undefined` loads nothing. */
+  readonly authorizationId: string | undefined;
+  /**
+   * Leaves for a `redirect_url` that Auth returned: after a decision, or at
+   * once for a client the user approved before. Default:
+   * `window.location.assign`.
+   */
+  readonly redirect?: (url: string) => void;
+}
+interface OAuthConsentSnapshot {
+  /**
+   * The request to approve or deny; `undefined` while it loads or after a
+   * redirect.
+   */
+  readonly request: OAuthConsentRequest | undefined;
+  /** The URL the controller sent the browser to. */
+  readonly redirectUrl: string | undefined;
+  /** The decision in flight; it stays set while the browser leaves. */
+  readonly deciding: "approve" | "deny" | undefined;
+  readonly error: DbError | undefined;
+}
+interface OAuthConsentActions {
+  /** Approves the request and goes to the client with a code. */
+  readonly approve: () => Promise<Result<string>>;
+  /** Denies the request and goes to the client with `access_denied`. */
+  readonly deny: () => Promise<Result<string>>;
+}
+type OAuthConsentController = Controller<OAuthConsentSnapshot, OAuthConsentActions>;
+/**
+ * The consent page of the Supabase Auth OAuth server: it reads the request for
+ * `authorizationId`, and `approve` or `deny` send the browser to the
+ * `redirect_url` that Auth returns, never to a URL from the page.
+ */
+declare function createOAuthConsentController(options: OAuthConsentControllerOptions): OAuthConsentController;
+/** A client the user approved. */
+interface OAuthGrant {
+  readonly client: OAuthClientInfo;
+  readonly scopes: readonly string[];
+  readonly grantedAt: Temporal.Instant;
+}
+interface OAuthGrantsControllerOptions {
+  /** `supabase.auth.oauth` of the browser client. */
+  readonly oauth: OAuthApi;
+  readonly auth: AuthPort;
+}
+interface OAuthGrantsSnapshot {
+  /** Newest first; `undefined` until the first load. */
+  readonly grants: readonly OAuthGrant[] | undefined;
+  /** The client ids with a revoke in flight. */
+  readonly revoking: readonly string[];
+  readonly error: DbError | undefined;
+}
+interface OAuthGrantsActions {
+  /**
+   * Disconnects a client: its sessions end and its refresh tokens stop working.
+   * An access token it holds stays valid until it expires.
+   */
+  readonly revoke: (clientId: string) => Promise<Result<boolean>>;
+  readonly refresh: () => Promise<void>;
+}
+type OAuthGrantsController = Controller<OAuthGrantsSnapshot, OAuthGrantsActions>;
+/**
+ * The OAuth clients (such as MCP clients) the user approved, for a connected
+ * agents list.
+ */
+declare function createOAuthGrantsController(options: OAuthGrantsControllerOptions): OAuthGrantsController;
+//#endregion
+export { OAuthConsentControllerOptions as a, OAuthGrant as c, OAuthGrantsControllerOptions as d, OAuthGrantsSnapshot as f, createOAuthGrantsController as h, OAuthConsentController as i, OAuthGrantsActions as l, createOAuthConsentController as m, OAuthClientInfo as n, OAuthConsentRequest as o, RawOAuthClient as p, OAuthConsentActions as r, OAuthConsentSnapshot as s, OAuthApi as t, OAuthGrantsController as u };