better-supabase 0.8.0 → 0.9.0

package/dist/blocks/flags/index.js

@@ -1,248 +1,14 @@
-import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { t as DEFAULT_CLAIMS } from "../../claims-PqzCxaTD.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-bAKh-dGc.js";
-import { A as stringsOf, i as blockCall, j as textOf, l as errorText, n as applyTemporal, v as optionalText, w as recordsOf } from "../../block-helpers-Cy3pB96I.js";
-//#region src/blocks/flags/flags.ts
-const BUCKETS = 1e4;
-/**
-* The rollout bucket of `target` for `flag`, 0 to 9999: the first 32 bits
-* of SHA-256(`flag.target`) modulo 10000. `better_supabase.flag_bucket()`
-* computes the same number, so SQL and TypeScript agree on who is in.
-*/
-async function flagBucket(flag, target) {
-	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${flag}.${target}`));
-	return new DataView(digest).getUint32(0) % BUCKETS;
-}
-const contains = (list, value) => list === void 0 || value !== void 0 && list.includes(value);
-const anyIn = (list, values) => list === void 0 || values.some((value) => list.includes(value));
-function ruleMatches(rule, context) {
-	return contains(rule.tenants, context.tenant) && contains(rule.users, context.targetingKey) && anyIn(rule.roles, [...context.role === void 0 ? [] : [context.role], ...context.roles ?? []]) && (rule.plans === void 0 || rule.plans.some((plan) => context.plans?.includes(plan) === true));
-}
-async function chooseVariant(flag, context) {
-	if (!flag.enabled) return {
-		variant: flag.defaultVariant,
-		reason: "DISABLED"
-	};
-	let chosen = (flag.overrides.find((entry) => entry.userId !== void 0 && entry.userId === context.targetingKey) ?? flag.overrides.find((entry) => entry.organizationId !== void 0 && entry.organizationId === context.tenant))?.variant;
-	let reason = chosen === void 0 ? "DEFAULT" : "TARGETING_MATCH";
-	if (chosen === void 0) {
-		const rule = flag.rules.find((entry) => ruleMatches(entry, context));
-		if (rule) {
-			chosen = rule.variant;
-			reason = "TARGETING_MATCH";
-		}
-	}
-	const target = context.targetingKey ?? context.tenant;
-	if (chosen === void 0 && flag.rolloutVariant !== void 0 && target !== void 0 && await flagBucket(flag.key, target) < flag.rolloutPercentage * 100) {
-		chosen = flag.rolloutVariant;
-		reason = "SPLIT";
-	}
-	if (chosen === void 0 || !Object.hasOwn(flag.variants, chosen)) return {
-		variant: flag.defaultVariant,
-		reason: "DEFAULT"
-	};
-	return {
-		variant: chosen,
-		reason
-	};
-}
-/** Evaluates one flag as `better_supabase.flag_evaluation()` does. */
-async function evaluateFlag(flag, context = {}) {
-	const { variant, reason } = await chooseVariant(flag, context);
-	return {
-		value: flag.variants[variant] ?? null,
-		variant,
-		reason
-	};
-}
-const FLAG_TYPES = /* @__PURE__ */ new Set([
-	"boolean",
-	"string",
-	"number",
-	"object"
-]);
-const flagTypeOf = (value) => {
-	const text = textOf(value);
-	return FLAG_TYPES.has(text) ? text : "boolean";
-};
-function ruleOf(value) {
-	if (!isRecord(value) || typeof value["variant"] !== "string") return void 0;
-	const list = (key) => Array.isArray(value[key]) ? stringsOf(value[key]) : void 0;
-	const tenants = list("tenants");
-	const users = list("users");
-	const plans = list("plans");
-	const roles = list("roles");
-	return {
-		variant: value["variant"],
-		...tenants && { tenants },
-		...users && { users },
-		...plans && { plans },
-		...roles && { roles }
-	};
-}
-/** Parses the rows of `flag_definitions()`. */
-function flagDefinitionsOf(value) {
-	return recordsOf(value, "flag_definitions").map((row) => ({
-		key: textOf(row["key"]),
-		type: flagTypeOf(row["type"]),
-		variants: isRecord(row["variants"]) ? row["variants"] : {},
-		defaultVariant: optionalText(row["default_variant"]) ?? "",
-		enabled: row["enabled"] !== false,
-		rules: (Array.isArray(row["rules"]) ? row["rules"] : []).flatMap((rule) => {
-			const parsed = ruleOf(rule);
-			return parsed ? [parsed] : [];
-		}),
-		rolloutPercentage: Number(row["rollout_percentage"] ?? 0),
-		rolloutVariant: optionalText(row["rollout_variant"]),
-		overrides: recordsOf(row["overrides"] ?? [], "flag_definitions").map((entry) => ({
-			organizationId: optionalText(entry["organization_id"]),
-			userId: optionalText(entry["user_id"]),
-			variant: textOf(entry["variant"])
-		}))
-	}));
-}
-const DEFAULT_CODES = {
-	FLAG_NOT_FOUND: "FLAG_NOT_FOUND",
-	TYPE_MISMATCH: "TYPE_MISMATCH",
-	PROVIDER_NOT_READY: "PROVIDER_NOT_READY",
-	GENERAL: "GENERAL"
-};
-const isBoolean = (value) => typeof value === "boolean";
-const isString = (value) => typeof value === "string";
-const isNumber = (value) => typeof value === "number";
-/** Feature flags from the `flags` module, as an OpenFeature provider. */
-function createFlagsProvider(options) {
-	applyTemporal(options);
-	const { transport, definitions } = options;
-	const schema = options.schema ?? "better_supabase";
-	const fetchFlags = definitions ? () => Promise.resolve(definitions) : transport ? async () => flagDefinitionsOf(await transport.call(schema, "flag_definitions", {})) : void 0;
-	if (!fetchFlags) throw new TypeError("createFlagsProvider needs a transport or definitions");
-	const ttl = options.ttl ?? 3e4;
-	const now = options.now ?? Date.now;
-	const codes = options.errorCodes ?? DEFAULT_CODES;
-	let cache;
-	const load = () => {
-		if (cache && now() - cache.at < ttl) return cache.flags;
-		const flags = fetchFlags().then((list) => new Map(list.map((flag) => [flag.key, flag])));
-		const entry = {
-			at: now(),
-			flags
-		};
-		cache = entry;
-		flags.catch(() => {
-			if (cache === entry) cache = void 0;
-		});
-		return flags;
-	};
-	async function resolve(flagKey, defaultValue, context, check) {
-		let flags;
-		try {
-			flags = await load();
-		} catch (error) {
-			return {
-				value: defaultValue,
-				reason: "ERROR",
-				errorCode: codes.GENERAL,
-				errorMessage: errorText(error)
-			};
-		}
-		const flag = flags.get(flagKey);
-		if (!flag) return {
-			value: defaultValue,
-			reason: "ERROR",
-			errorCode: codes.FLAG_NOT_FOUND,
-			errorMessage: `Flag "${flagKey}" is not defined`
-		};
-		const result = await evaluateFlag(flag, context);
-		if (!check(result.value)) return {
-			value: defaultValue,
-			reason: "ERROR",
-			errorCode: codes.TYPE_MISMATCH,
-			errorMessage: `Flag "${flagKey}" is a ${flag.type} flag`
-		};
-		return {
-			value: result.value,
-			variant: result.variant,
-			reason: result.reason
-		};
-	}
-	return {
-		metadata: { name: "better-supabase" },
-		runsOn: "server",
-		async initialize() {
-			await load();
-		},
-		resolveBooleanEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, isBoolean),
-		resolveStringEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, isString),
-		resolveNumberEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, isNumber),
-		resolveObjectEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, (value) => typeof value === "object" && value !== null),
-		refresh() {
-			cache = void 0;
-		}
-	};
-}
-const details = async (flagKey, resolution) => ({
-	flagKey,
-	flagMetadata: {},
-	...await resolution
-});
-/**
-* A flag client without the OpenFeature SDK: `withOpenFeature({ client })`
-* from `@supabase-labs/middleware-openfeature` accepts it.
-*/
-function createFlagClient(source) {
-	const provider = "resolveBooleanEvaluation" in source ? source : createFlagsProvider(source);
-	return {
-		getBooleanDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveBooleanEvaluation(flagKey, defaultValue, context)),
-		getStringDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveStringEvaluation(flagKey, defaultValue, context)),
-		getNumberDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveNumberEvaluation(flagKey, defaultValue, context)),
-		getObjectDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveObjectEvaluation(flagKey, defaultValue, context))
-	};
-}
-/**
-* The caller's roles in `tenant` from the memberships claim: an object of
-* tenant id to role (the `tenant` module's hook), or a list of
-* `{ scope, id, role | roles }` entries (an authorization provider's hook).
-*/
-function membershipRoles(memberships, tenant, scope) {
-	if (isRecord(memberships)) {
-		const role = optionalText(memberships[tenant]);
-		return role === void 0 ? [] : [role];
-	}
-	if (!Array.isArray(memberships)) return [];
-	const entry = memberships.find((item) => isRecord(item) && optionalText(item["id"]) === tenant && (scope === void 0 ? item["within"] === void 0 : optionalText(item["scope"]) === scope));
-	if (!entry) return [];
-	const role = optionalText(entry["role"]);
-	return [...role === void 0 ? [] : [role], ...stringsOf(entry["roles"])];
-}
-/**
-* The evaluation context of a request: the user id as `targetingKey`, the
-* tenant, its plan features (`features` claim) and the caller's roles in it
-* (`memberships` claim, in the `tenant` module's or the list shape, or
-* `options.roles`). Pass it as `context` to `withOpenFeature`.
-*/
-function flagContext(source, options = {}) {
-	const claims = source.jwtClaims ?? {};
-	const appMetadata = isRecord(claims["app_metadata"]) ? claims["app_metadata"] : {};
-	const tenantClaim = options.tenantClaim ?? DEFAULT_CLAIMS.tenant;
-	const tenant = source.tenant ?? optionalText(claims[tenantClaim]) ?? optionalText(appMetadata[tenantClaim]);
-	const sub = optionalText(claims["sub"]);
-	const features = claims[options.featuresClaim ?? DEFAULT_CLAIMS.features];
-	const memberships = claims[options.membershipsClaim ?? DEFAULT_CLAIMS.memberships];
-	const plans = tenant !== void 0 && isRecord(features) && Array.isArray(features[tenant]) ? [...stringsOf(features[tenant])] : void 0;
-	const resolved = tenant === void 0 ? void 0 : options.roles ? options.roles(claims, tenant) : membershipRoles(memberships, tenant, options.membershipScope);
-	const roles = resolved === void 0 ? [] : typeof resolved === "string" ? [resolved] : [...resolved];
-	return {
-		...sub !== void 0 && { targetingKey: sub },
-		...tenant !== void 0 && { tenant },
-		...plans !== void 0 && { plans },
-		...roles.length > 0 && { role: roles[0] },
-		...roles.length > 1 && { roles }
-	};
-}
-//#endregion
+import { a as ok, t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { a as flagContext, i as flagBucket, n as createFlagsProvider, o as flagDefinitionsOf, r as evaluateFlag, t as createFlagClient } from "../../flags-XAOsdNAc.js";
+import { t as flagsSqlOptions } from "../../options-DDzggjN7.js";
 //#region src/blocks/flags/admin.ts
-const rowOf = (input) => {
+const rowOf = (input, fields) => {
 	const row = {};
 	const set = (name, value) => {
 		if (value !== void 0) row[name] = value;
@@ -252,32 +18,78 @@ const rowOf = (input) => {
 	set("variants", input.variants);
 	set("default_variant", input.defaultVariant);
 	set("enabled", input.enabled);
+	set("archived", input.archived);
 	set("rules", input.rules);
 	set("rollout_percentage", input.rolloutPercentage);
 	set("rollout_variant", input.rolloutVariant);
+	set("fields", fields);
 	return row;
 };
+const recordOf = async (fields, flag) => {
+	const parsed = await fields.read({ ...flag.fields });
+	return parsed.ok ? ok({
+		...flag,
+		fields: parsed.data
+	}) : parsed;
+};
 /**
 * Manages feature flags for platform staff (`flags.manage`) or the service
 * role, through the `flags` module's `list_flags`, `save_flag`,
 * `delete_flag` and `set_flag_override`.
 */
-function createFlagAdmin(options) {
+function createFlags(options) {
 	const call = blockCall(options.transport, options.schema, options.mappers);
-	return {
-		list: () => call("list_flags", {}, flagDefinitionsOf),
-		save: (key, input) => call("save_flag", {
+	const fields = blockFields(options.fields, "flag fields");
+	const records = (flags) => AsyncResult.from(async () => {
+		const out = [];
+		for (const flag of flags) {
+			const parsed = await recordOf(fields, flag);
+			if (!parsed.ok) return parsed;
+			out.push(parsed.data);
+		}
+		return ok(out);
+	});
+	return withBlockHooks({
+		list: () => call("list_flags", {}, flagDefinitionsOf).andThen(records),
+		save: (key, input) => AsyncResult.from(() => input.fields === void 0 ? Promise.resolve(ok(void 0)) : fields.write({ ...input.fields })).andThen((valid) => call("save_flag", {
 			key,
-			definition: rowOf(input)
-		}, (value) => flagDefinitionsOf(value === null ? [] : [value])[0]),
+			definition: rowOf(input, valid)
+		}, (value) => flagDefinitionsOf(value === null ? [] : [value]))).andThen(records).map((saved) => saved[0]),
 		remove: (key) => call("delete_flag", { key }, (value) => value === true),
 		override: (key, target, variant) => call("set_flag_override", {
 			key,
 			variant,
 			tenant: target.organizationId,
-			member: target.userId
+			member: target.userId,
+			...target.context !== void 0 && {
+				context: target.context,
+				context_key: target.contextKey
+			}
 		}, (value) => value === true)
-	};
+	}, options.hooks, {
+		block: "flags",
+		...options.logger ? { logger: options.logger } : {}
+	});
 }
 //#endregion
-export { createFlagAdmin, createFlagClient, createFlagsProvider, dbTransport, evaluateFlag, flagBucket, flagContext, flagDefinitionsOf, rpcTransport, sqlTransport };
+//#region src/blocks/flags/events.ts
+/** The `flags` block's event types, for its manifest and `onBlockEvent`. */
+const flagsEvents = defineEvents({
+	"flag.saved": event(),
+	"flag.deleted": event(),
+	"flag.override_set": event()
+});
+//#endregion
+//#region src/blocks/flags/manifest.ts
+/** The `flags` block's manifest (ADR 0029). */
+const flagsBlock = defineBlock({
+	name: "flags",
+	sql: ["flags"],
+	options: { flags: flagsSqlOptions },
+	events: flagsEvents,
+	create: createFlags,
+	category: "growth",
+	recipes: ["feature-flag-toggles"]
+});
+//#endregion
+export { createFlagClient, createFlags, createFlagsProvider, dbTransport, evaluateFlag, flagBucket, flagContext, flagDefinitionsOf, flagsBlock, flagsEvents, rpcTransport, sqlTransport };

package/dist/blocks/forms/index.d.ts

@@ -0,0 +1,302 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { B as FormEventData, V as FormSubmissionEventData, it as SignatureEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { n as BlockOptions, r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { a as FormDefinition, c as FormJson, d as FormStep, f as formDefinitionProblems, i as FormCondition, l as FormJsonSchema, m as isFormDefinition, n as FORM_FIELD_TYPES, o as FormField, p as formSchema, r as FORM_SCHEMA_DIALECT, s as FormFieldType, t as FORM_DEFINITION_SCHEMA, u as FormOption } from "../../form-definition-sagoefQr.js";
+import { _ as visibleFields, a as createQuestionnaireController, b as answersSchema, c as QuestionnaireState, d as finishQuestionnaire, f as initialQuestionnaire, g as stepIssues, h as questionnaireSteps, i as QuestionnaireSnapshot, l as QuestionnaireStepView, m as questionnaireReducer, n as QuestionnaireController, o as QuestionnaireAction, p as pruneAnswers, r as QuestionnaireOptions, s as QuestionnaireForm, t as QuestionnaireActions, u as conditionHolds, v as visibleSteps, x as validateAnswers, y as FormAnswers } from "../../client-WHeWTNVL.js";
+//#region src/blocks/forms/forms.d.ts
+interface FormsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the forms' extra columns
+   * (`blocks.forms.options.extraColumns`), keyed by column name. It types
+   * and parses `fields` on reads and validates them on `create` and `update`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Forms<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+type FormStatus = "draft" | "open" | "closed" | "archived";
+type FormSubmissionStatus = "draft" | "submitted" | "accepted" | "rejected";
+type FormSubmissionSource = "member" | "public" | "service";
+/** A form. `F` types the extra columns the `fields` schema describes. */
+interface Form<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly key: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly status: FormStatus;
+  readonly currentVersionId?: string;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>> & F;
+}
+/** One published definition and the JSON Schema generated from it. */
+interface FormVersion {
+  readonly id: string;
+  readonly formId: string;
+  readonly number: number;
+  /** The definition with its custom fields copied in. */
+  readonly definition: FormDefinition;
+  readonly schema: FormJsonSchema;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+}
+/** A form with its current version, from `get`. */
+interface FormDetail<F extends object = Record<never, never>> extends Form<F> {
+  readonly version?: FormVersion;
+}
+/** What `getPublic` shows a respondent who holds the link. */
+interface PublicForm {
+  readonly id: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly version: Omit<FormVersion, "createdBy">;
+}
+interface FormSubmission {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly formId: string;
+  readonly versionId: string;
+  /** The record the submission belongs to, or the one its handler created. */
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly respondentId?: string;
+  readonly answers: FormAnswers;
+  readonly status: FormSubmissionStatus;
+  readonly source: FormSubmissionSource;
+  readonly reviewedBy?: string;
+  readonly reviewedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+  readonly submittedAt?: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface PublicSubmission {
+  readonly id: string;
+  readonly status: FormSubmissionStatus;
+  readonly submittedAt?: Temporal.Instant;
+}
+interface FormInput<F extends object = Record<never, never>> {
+  readonly organizationId: string;
+  /** Unique in the organization; lowercase letters, digits, `_` and `-`. */
+  readonly key: string;
+  readonly title: string;
+  readonly description?: string;
+  /** Values for the extra columns, by column name. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+interface FormUpdate<F extends object = Record<never, never>> {
+  readonly title?: string;
+  readonly description?: string;
+  readonly status?: FormStatus;
+  /** Values for the extra columns, by column name; the ones left out keep their value. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+interface SubmitOptions {
+  /** Links the submission to a record, such as the deal it is about. */
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  /** Continues the caller's draft. */
+  readonly submissionId?: string;
+  /** Saves without validating; submit again without `draft` to finish. */
+  readonly draft?: boolean;
+}
+interface PublicSubmitOptions {
+  /** Passed to the `before_public_form_submission` hook, such as a Turnstile token. */
+  readonly botToken?: string;
+}
+interface SubmissionListOptions {
+  /** Default: every status. */
+  readonly status?: FormSubmissionStatus;
+  readonly pageSize?: number;
+  /** Submissions created before this time, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+/** `F` types the forms' extra columns, from the `fields` schema. */
+interface Forms<F extends object = Record<never, never>> {
+  create(input: FormInput<F>): AsyncResult<Form<F>>;
+  update(id: string, update: FormUpdate<F>): AsyncResult<Form<F>>;
+  /** Publishes a definition as the form's next version and makes it current. */
+  publish(formId: string, definition: FormDefinition): AsyncResult<FormVersion>;
+  get(id: string): AsyncResult<FormDetail<F>>;
+  getVersion(versionId: string): AsyncResult<FormVersion>;
+  list(organizationId: string, options?: {
+    readonly status?: FormStatus;
+  }): AsyncResult<readonly Form<F>[]>;
+  /** Submits answers to the form's current version; Postgres validates them. */
+  submit(formId: string, answers: FormAnswers, options?: SubmitOptions): AsyncResult<FormSubmission>;
+  /** The open form behind a share link, for a respondent without an account. */
+  getPublic(token: string): AsyncResult<PublicForm>;
+  submitPublic(token: string, answers: FormAnswers, options?: PublicSubmitOptions): AsyncResult<PublicSubmission>;
+  getSubmission(id: string): AsyncResult<FormSubmission>;
+  /** Newest first. */
+  listSubmissions(formId: string, options?: SubmissionListOptions): AsyncResult<readonly FormSubmission[]>;
+  review(id: string, status: "accepted" | "rejected" | "submitted"): AsyncResult<FormSubmission>;
+  deleteSubmission(id: string): AsyncResult<boolean>;
+}
+/** The `forms` SQL module as typed calls. */
+export declare function createForms<S extends StandardSchemaV1 | undefined = undefined>(options: FormsOptions<S>): Forms<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/forms/signatures.d.ts
+interface SignaturesOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the request's extra columns
+   * (`blocks.signatures.options.extraColumns`), keyed by database name. It
+   * types and parses them on the request reads, and validates them on
+   * `request`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Signatures<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+type SignatureMethod = "drawn" | "typed" | "click";
+type SignatureOrder = "parallel" | "sequential";
+type SignatureRequestStatus = "pending" | "completed" | "declined" | "cancelled";
+/** A request. `F` types the extra columns the `fields` schema describes. */
+interface SignatureRequest<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** The frozen version the signers sign. */
+  readonly versionId: string;
+  /** The version's content hash when the request was made. */
+  readonly contentHash: string;
+  readonly signers: readonly string[];
+  readonly order: SignatureOrder;
+  readonly status: SignatureRequestStatus;
+  readonly approvalRequestId?: string;
+  readonly message?: string;
+  readonly requestedBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly completedAt?: Temporal.Instant;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface Signature {
+  readonly id: string;
+  readonly requestId: string;
+  readonly signer: string;
+  readonly method: SignatureMethod;
+  readonly typedName?: string;
+  /** The attachment that holds a drawn signature's image. */
+  readonly imageAttachmentId?: string;
+  /** SHA-256 over the request, the content hash, the signer, the method and the time. */
+  readonly signedHash: string;
+  readonly ip?: string;
+  readonly userAgent?: string;
+  readonly signedAt: Temporal.Instant;
+}
+interface SignatureVerification {
+  /** The signed version is unchanged and every signature hash matches. */
+  readonly valid: boolean;
+  /** The signed version's content still hashes to the requested hash. */
+  readonly contentMatches: boolean;
+  /** The record has a newer version than the one signed. */
+  readonly changedSince: boolean;
+  readonly latestVersionId?: string;
+  readonly signatures: readonly {
+    readonly id: string;
+    readonly signer: string;
+    readonly valid: boolean;
+  }[];
+}
+/** A request with its signatures and their verification, from `get`. */
+interface SignatureRequestDetail<F extends object = Record<never, never>> extends SignatureRequest<F> {
+  readonly signatures: readonly Signature[];
+  readonly verification: SignatureVerification;
+}
+interface SignatureRequestInput<F extends object = Record<never, never>> {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Members of the organization, in signing order for `sequential`. */
+  readonly signers: readonly string[];
+  /** Default: a new snapshot of the record's versioned columns. */
+  readonly versionId?: string;
+  /** Default: `parallel`. */
+  readonly order?: SignatureOrder;
+  /** An approval request on the same record that a signer's signature decides. */
+  readonly approvalRequestId?: string;
+  readonly message?: string;
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+type SignInput = {
+  readonly method: "click";
+} | {
+  readonly method: "typed";
+  readonly typedName: string;
+} | {
+  readonly method: "drawn";
+  readonly imageAttachmentId: string;
+};
+interface SignatureRequestListOptions {
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly status?: SignatureRequestStatus;
+  /** Only the requests the caller is asked to sign. */
+  readonly mine?: boolean;
+  readonly pageSize?: number;
+  /** Requests created before this time, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+interface Signatures<F extends object = Record<never, never>> {
+  request(input: SignatureRequestInput<F>): AsyncResult<SignatureRequest<F>>;
+  sign(requestId: string, input: SignInput): AsyncResult<Signature & {
+    readonly requestStatus: SignatureRequestStatus;
+  }>;
+  decline(requestId: string, reason?: string): AsyncResult<SignatureRequest<F>>;
+  cancel(requestId: string): AsyncResult<SignatureRequest<F>>;
+  get(requestId: string): AsyncResult<SignatureRequestDetail<F>>;
+  /** Newest first. */
+  list(organizationId: string, options?: SignatureRequestListOptions): AsyncResult<readonly SignatureRequest<F>[]>;
+}
+/** The `signatures` SQL module as typed calls. */
+export declare function createSignatures<S extends StandardSchemaV1 | undefined = undefined>(options: SignaturesOptions<S>): Signatures<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/forms/events.d.ts
+/** The events of the `forms` block: type to data. */
+type FormsEvents = {
+  readonly "form.created": FormEventData;
+  readonly "form_version.published": FormEventData;
+  readonly "form_submission.submitted": FormSubmissionEventData;
+  readonly "form_submission.reviewed": FormSubmissionEventData;
+  readonly "form_submission.deleted": FormSubmissionEventData;
+};
+/** The `forms` block's event types, for its manifest and `onBlockEvent`. */
+export declare const formsEvents: Events<FormsEvents>;
+/** The events of the `signatures` block: type to data. */
+type SignaturesEvents = {
+  readonly "signature.requested": SignatureEventData;
+  readonly "signature.signed": SignatureEventData;
+  readonly "signature.completed": SignatureEventData;
+  readonly "signature.declined": SignatureEventData;
+  readonly "signature.cancelled": SignatureEventData;
+};
+/** The `signatures` block's event types, for its manifest and `onBlockEvent`. */
+export declare const signaturesEvents: Events<SignaturesEvents>;
+//#endregion
+//#region src/blocks/forms/manifest.d.ts
+/** The `forms` block's manifest (ADR 0029). */
+export declare const formsBlock: BlockOf<"forms", typeof createForms, FormsEvents>;
+/** The `signatures` block's manifest (ADR 0029). */
+export declare const signaturesBlock: BlockOf<"signatures", typeof createSignatures, SignaturesEvents>;
+//#endregion
+export { type BlockTransport, FORM_DEFINITION_SCHEMA, FORM_FIELD_TYPES, FORM_SCHEMA_DIALECT, type Form, type FormAnswers, type FormCondition, type FormDefinition, type FormDetail, type FormField, type FormFieldType, type FormInput, type FormJson, type FormJsonSchema, type FormOption, type FormStatus, type FormStep, type FormSubmission, type FormSubmissionSource, type FormSubmissionStatus, type FormUpdate, type FormVersion, type Forms, type FormsEvents, type FormsOptions, type PublicForm, type PublicSubmission, type PublicSubmitOptions, type QuestionnaireAction, type QuestionnaireActions, type QuestionnaireController, type QuestionnaireForm, type QuestionnaireOptions, type QuestionnaireSnapshot, type QuestionnaireState, type QuestionnaireStepView, type SignInput, type Signature, type SignatureMethod, type SignatureOrder, type SignatureRequest, type SignatureRequestDetail, type SignatureRequestInput, type SignatureRequestListOptions, type SignatureRequestStatus, type SignatureVerification, type Signatures, type SignaturesEvents, type SignaturesOptions, type SubmissionListOptions, type SubmitOptions, answersSchema, conditionHolds, createQuestionnaireController, dbTransport, finishQuestionnaire, formDefinitionProblems, formSchema, initialQuestionnaire, isFormDefinition, pruneAnswers, questionnaireReducer, questionnaireSteps, rpcTransport, sqlTransport, stepIssues, validateAnswers, visibleFields, visibleSteps };