better-supabase 0.13.0 → 0.14.0

package/dist/blocks/contracts/index.js

@@ -0,0 +1,361 @@
+import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as contractsSqlOptions } from "../../options-E7KcmHQv.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CiKtrb6g.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BymdcD0V.js";
+import { n as entitySchema, r as moneyField } from "../../entity-schema-BXXC1NnT.js";
+import { t as defineSection } from "../../sections-DjxYmpu-.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as blockFields } from "../../block-fields-DBSJSeaO.js";
+import { n as defineBlock } from "../../define-block-Dze77QTw.js";
+import { n as optionalSubjectRefOf } from "../../block-subjects-Dzq5Xn_0.js";
+import { o as optionalMoneyOf, t as amountText } from "../../money-codec-jMP0PQLZ.js";
+//#region src/blocks/contracts/contracts.ts
+const STATUSES = [
+	"draft",
+	"in_review",
+	"out_for_signature",
+	"active",
+	"expired",
+	"terminated"
+];
+const OBLIGATION_STATUSES = [
+	"open",
+	"done",
+	"waived"
+];
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+const optionalDate = (value) => typeof value === "string" && value !== "" ? temporal().PlainDate.from(value) : void 0;
+const numberOf = (value) => typeof value === "number" ? value : Number(value ?? 0);
+function contractOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		title: textOf(row["title"]),
+		status: enumOrThrow(row["status"], STATUSES, "contract status"),
+		autoRenew: row["autoRenew"] === true,
+		renewalMonths: numberOf(row["renewalMonths"]),
+		noticeDays: numberOf(row["noticeDays"]),
+		renewedCount: numberOf(row["renewedCount"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("description", optionalText(row["description"])),
+		...optional("counterparty", optionalSubjectRefOf(row["counterpartyType"], row["counterpartyId"])),
+		...optional("ownerId", optionalText(row["ownerId"])),
+		...optional("value", optionalMoneyOf(row["value"], row["currency"], "contract value")),
+		...optional("startsOn", optionalDate(row["startsOn"])),
+		...optional("endsOn", optionalDate(row["endsOn"])),
+		...optional("noticeDeadline", optionalDate(row["noticeDeadline"])),
+		...optional("signatureRequestId", optionalText(row["signatureRequestId"])),
+		...optional("signedAt", optionalInstant(row["signedAt"])),
+		...optional("terminatedAt", optionalInstant(row["terminatedAt"])),
+		...optional("terminationReason", optionalText(row["terminationReason"])),
+		...optional("createdBy", optionalText(row["createdBy"])),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function obligationOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		contractId: textOf(row["contractId"]),
+		title: textOf(row["title"]),
+		status: enumOrThrow(row["status"], OBLIGATION_STATUSES, "obligation status"),
+		overdue: row["overdue"] === true,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("description", optionalText(row["description"])),
+		...optional("dueOn", optionalDate(row["dueOn"])),
+		...optional("ownerId", optionalText(row["ownerId"])),
+		...optional("completedAt", optionalInstant(row["completedAt"])),
+		...optional("completedBy", optionalText(row["completedBy"]))
+	};
+}
+/** The attrs object create_contract and update_contract read. */
+function attrsOf(input) {
+	const attrs = {};
+	const set = (key, value) => {
+		if (value !== void 0) attrs[key] = value;
+	};
+	set("title", input.title);
+	set("description", input.description);
+	set("counterpartyType", input.counterparty?.type);
+	set("counterpartyId", input.counterparty?.id);
+	set("ownerId", input.ownerId);
+	set("value", input.value === void 0 ? void 0 : amountText(input.value));
+	set("currency", input.value?.currency);
+	set("startsOn", input.startsOn?.toString());
+	set("endsOn", input.endsOn?.toString());
+	set("autoRenew", input.autoRenew);
+	set("renewalMonths", input.renewalMonths);
+	set("noticeDays", input.noticeDays);
+	return attrs;
+}
+/** The `contracts` SQL module as typed calls. */
+function createContracts(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "contract fields");
+	const one = (fn) => (value) => contractOf(value, fn);
+	const obligation = (fn) => (value) => obligationOf(value, fn);
+	const listContracts = (tenant, list) => call("list_contracts", {
+		tenant,
+		status: list.status ?? null,
+		counterparty_type: list.counterparty?.type ?? null,
+		counterparty_id: list.counterparty?.id ?? null,
+		owner_id: list.ownerId ?? null,
+		renewing_before: list.renewingBefore?.toString() ?? null,
+		before: instantArg(list.before) ?? null,
+		page_size: list.pageSize ?? null
+	}, (value) => recordsOf(value, "list_contracts").map((row) => contractOf(row, "list_contracts"))).andThen(fields.rows);
+	return withBlockHooks({
+		create: (organizationId, input) => fields.args(input.fields).andThen((checked) => call("create_contract", {
+			tenant: organizationId,
+			attrs: attrsOf(input),
+			...checked === void 0 ? {} : { fields: checked }
+		}, one("create_contract")).andThen(fields.row)),
+		update: (contractId, changes) => fields.args(changes.fields).andThen((checked) => call("update_contract", {
+			contract_id: contractId,
+			attrs: attrsOf(changes),
+			...checked === void 0 ? {} : { fields: checked }
+		}, one("update_contract")).andThen(fields.row)),
+		transition: (contractId, action, reason) => call("transition_contract", {
+			contract_id: contractId,
+			action,
+			reason: reason ?? null
+		}, one("transition_contract")).andThen(fields.row),
+		sendForSignature: (contractId, input) => call("send_contract_for_signature", {
+			contract_id: contractId,
+			signers: input.signers,
+			sign_order: input.signOrder ?? "parallel",
+			message: input.message ?? null
+		}, one("send_contract_for_signature")).andThen(fields.row),
+		get: (contractId) => call("get_contract", { contract_id: contractId }, one("get_contract")).andThen(fields.row),
+		list: (organizationId, list = {}) => listContracts(organizationId, list),
+		forCounterparty: (counterparty, list = {}) => listContracts(null, {
+			...list,
+			counterparty
+		}),
+		runRenewals: (asOf) => call("run_contract_renewals", { as_of: asOf?.toString() ?? null }, (value) => {
+			const row = recordOf(value, "run_contract_renewals");
+			return {
+				renewed: numberOf(row["renewed"]),
+				expired: numberOf(row["expired"])
+			};
+		}),
+		saveObligation: (contractId, input) => call("save_obligation", {
+			contract_id: contractId,
+			title: input.title,
+			due_on: input.dueOn?.toString() ?? null,
+			owner_id: input.ownerId ?? null,
+			description: input.description ?? null,
+			obligation_id: input.obligationId ?? null
+		}, obligation("save_obligation")),
+		setObligationStatus: (obligationId, status) => call("set_obligation_status", {
+			obligation_id: obligationId,
+			status
+		}, obligation("set_obligation_status")),
+		deleteObligation: (obligationId) => call("delete_obligation", { obligation_id: obligationId }, obligation("delete_obligation")),
+		obligations: (organizationId, list = {}) => call("list_obligations", {
+			tenant: organizationId,
+			contract_id: list.contractId ?? null,
+			owner_id: list.ownerId ?? null,
+			open_only: list.openOnly ?? false,
+			due_before: list.dueBefore?.toString() ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_obligations").map((row) => obligationOf(row, "list_obligations")))
+	}, options.hooks, {
+		block: "contracts",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/contracts/events.ts
+/** The `contracts` block's event types, for its manifest and `onBlockEvent`. */
+const contractsEvents = defineEvents({
+	"contract.created": event(),
+	"contract.updated": event(),
+	"contract.status_changed": event(),
+	"contract.renewed": event(),
+	"obligation.saved": event(),
+	"obligation.status_changed": event()
+});
+//#endregion
+//#region src/blocks/contracts/schemas.ts
+const subject = {
+	kind: "json",
+	optional: true,
+	description: "The counterparty, a registered subject: `{ type, id }`."
+};
+const fields = {
+	kind: "json",
+	optional: true,
+	description: "The extra columns, keyed by database name."
+};
+/** What `create` takes. */
+const contractInputSchema = entitySchema({
+	title: "ContractInput",
+	fields: {
+		title: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		counterparty: subject,
+		ownerId: {
+			kind: "uuid",
+			optional: true
+		},
+		value: {
+			...moneyField,
+			optional: true
+		},
+		startsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		endsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		autoRenew: {
+			kind: "boolean",
+			optional: true
+		},
+		renewalMonths: {
+			kind: "integer",
+			optional: true,
+			minimum: 1,
+			maximum: 120
+		},
+		noticeDays: {
+			kind: "integer",
+			optional: true,
+			minimum: 0,
+			maximum: 3650
+		},
+		fields
+	}
+});
+/** What `update` takes: a key left out keeps its value. */
+const contractChangesSchema = entitySchema({
+	title: "ContractChanges",
+	fields: {
+		title: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		counterparty: subject,
+		ownerId: {
+			kind: "uuid",
+			optional: true
+		},
+		value: {
+			...moneyField,
+			optional: true
+		},
+		startsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		endsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		autoRenew: {
+			kind: "boolean",
+			optional: true
+		},
+		renewalMonths: {
+			kind: "integer",
+			optional: true,
+			minimum: 1,
+			maximum: 120
+		},
+		noticeDays: {
+			kind: "integer",
+			optional: true,
+			minimum: 0,
+			maximum: 3650
+		},
+		fields
+	}
+});
+/** What `saveObligation` takes. */
+const obligationInputSchema = entitySchema({
+	title: "ObligationInput",
+	fields: {
+		title: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 4e3
+		},
+		dueOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		ownerId: {
+			kind: "uuid",
+			optional: true
+		},
+		obligationId: {
+			kind: "uuid",
+			optional: true
+		}
+	}
+});
+//#endregion
+//#region src/blocks/contracts/section.ts
+/** The contracts with a record, such as a party's, on its record page. */
+const contractsSection = defineSection({
+	permissions: {
+		read: "read",
+		write: "write"
+	},
+	module: "contracts",
+	load: (client, subject) => client.forCounterparty(subject),
+	events: ["contract.*"]
+});
+//#endregion
+//#region src/blocks/contracts/manifest.ts
+/** The `contracts` block's manifest (ADR 0029). */
+const contractsBlock = defineBlock({
+	name: "contracts",
+	sql: ["contracts"],
+	options: { contracts: contractsSqlOptions },
+	events: contractsEvents,
+	schemas: {
+		contract: {
+			input: contractInputSchema,
+			change: contractChangesSchema
+		},
+		obligation: { input: obligationInputSchema }
+	},
+	create: createContracts,
+	sections: { contracts: contractsSection },
+	recipes: ["contract-renewals"],
+	category: "crm"
+});
+//#endregion
+export { contractChangesSchema, contractInputSchema, contractsBlock, contractsEvents, contractsSection, createContracts, dbTransport, extendBlock, obligationInputSchema, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -0,0 +1,325 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "../../standard-DbQsD2xZ.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-3w4MZr8U.js";
+import { Ct as Events } from "../../events-DbLjvxDX.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-BaugZlJV.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-CmjPKqQ_.js";
+import { c as BlockOf, rn as EntitySchema } from "../../define-block-COpcS6aT.js";
+//#region src/blocks/controls/controls.d.ts
+interface ControlsOptions<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 control's extra columns
+   * (`blocks.controls.options.extraColumns`), keyed by database name. It types
+   * and parses them on reads, and validates them on `saveControl`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Controls<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** A compliance framework, such as SOC 2 or ISO 27001. */
+interface ControlFramework {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly key: string;
+  readonly name: string;
+  readonly version?: string;
+  readonly description?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface ControlFrameworkInput {
+  /** Saving a key again updates that framework. */
+  readonly key: string;
+  readonly name: string;
+  readonly version?: string;
+  readonly description?: string;
+}
+/**
+ * `passing`: current evidence and no overdue task. `failing`: an overdue task,
+ * or only lapsed evidence. `not_started`: no evidence yet. `not_applicable`:
+ * out of scope.
+ */
+type ControlStatus = "passing" | "failing" | "not_started" | "not_applicable";
+/** A control. `F` types the extra columns the `fields` schema describes. */
+interface Control<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly frameworkId: string;
+  readonly code: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly ownerId?: string;
+  readonly applicable: boolean;
+  readonly status: ControlStatus;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+/** A control with its evidence (the newest 100) and evidence tasks. */
+interface ControlDetail<F extends object = Record<never, never>> extends Control<F> {
+  readonly evidence: readonly ControlEvidence[];
+  readonly tasks: readonly EvidenceTask[];
+}
+interface ControlInput<F extends object = Record<never, never>> {
+  readonly frameworkId: string;
+  /** Saving a code again in the framework updates that control. */
+  readonly code: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly ownerId?: string;
+  /** Default `true`. */
+  readonly applicable?: boolean;
+  /** Changes this control, code included. */
+  readonly controlId?: string;
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+interface ControlListOptions {
+  readonly frameworkId?: string;
+  readonly status?: ControlStatus;
+  readonly ownerId?: string;
+  readonly pageSize?: number;
+}
+/** Evidence for a control: an attachment, a note, or both. */
+interface ControlEvidence {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly controlId: string;
+  readonly evidenceTaskId?: string;
+  readonly attachmentId?: string;
+  readonly note?: string;
+  readonly collectedBy?: string;
+  readonly collectedAt: Temporal.Instant;
+  /** The last day it counts; missing counts until it is removed. */
+  readonly validUntil?: Temporal.PlainDate;
+  readonly valid: boolean;
+}
+interface ControlEvidenceInput {
+  /** An attachment on the control (attachments block). */
+  readonly attachmentId?: string;
+  readonly note?: string;
+  /** Default: the task's interval past today, or no end without a task. */
+  readonly validUntil?: Temporal.PlainDate;
+  /** The recurring task this evidence answers. */
+  readonly evidenceTaskId?: string;
+}
+/** A recurring request for evidence, with an assignee and a due date. */
+interface EvidenceTask {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly controlId: string;
+  readonly title: string;
+  readonly assigneeId?: string;
+  readonly intervalDays: number;
+  readonly dueOn: Temporal.PlainDate;
+  readonly lastCollectedAt?: Temporal.Instant;
+  readonly active: boolean;
+  /** Active and past its due date. */
+  readonly overdue: boolean;
+  /** On `evidenceTasks` rows. */
+  readonly controlCode?: string;
+  readonly controlTitle?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface EvidenceTaskInput {
+  readonly title: string;
+  /** Collecting evidence moves `dueOn` this many days past the collection. */
+  readonly intervalDays: number;
+  /** Default: today. */
+  readonly dueOn?: Temporal.PlainDate;
+  readonly assigneeId?: string;
+  /** Default `true`. */
+  readonly active?: boolean;
+  /** Changes this task instead of adding one. */
+  readonly evidenceTaskId?: string;
+}
+interface EvidenceTaskListOptions {
+  readonly controlId?: string;
+  readonly assigneeId?: string;
+  readonly overdueOnly?: boolean;
+}
+/** The status rollup of one framework. */
+interface ControlPosture {
+  readonly frameworkId: string;
+  readonly key: string;
+  readonly name: string;
+  readonly version?: string;
+  readonly total: number;
+  readonly passing: number;
+  readonly failing: number;
+  readonly notStarted: number;
+  readonly notApplicable: number;
+  readonly overdueTasks: number;
+}
+/** A policy members acknowledge, published as frozen versions. */
+interface Policy {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly key: string;
+  readonly title: string;
+  readonly ownerId?: string;
+  readonly requiresAcknowledgement: boolean;
+  /** The published version (versions block). */
+  readonly versionId?: string;
+  readonly versionNumber?: number;
+  readonly publishedAt?: Temporal.Instant;
+  readonly archivedAt?: Temporal.Instant;
+  /** When the caller acknowledged the published version. */
+  readonly acknowledgedAt?: Temporal.Instant;
+  /** Members who acknowledged the published version. */
+  readonly acknowledgedCount: number;
+  readonly memberCount: number;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface PolicyInput {
+  /** Saving a key again updates that policy. */
+  readonly key: string;
+  readonly title: string;
+  readonly ownerId?: string;
+  /** Default `true`. */
+  readonly requiresAcknowledgement?: boolean;
+  /** Changes this policy, key included. */
+  readonly policyId?: string;
+}
+interface PolicyListOptions {
+  readonly includeArchived?: boolean;
+  /** The published policies the caller still has to acknowledge. */
+  readonly pendingOnly?: boolean;
+}
+/** Who acknowledged a policy's published version. */
+interface PolicyAcknowledgements {
+  readonly policyId: string;
+  readonly versionId?: string;
+  readonly versionNumber?: number;
+  readonly members: readonly {
+    readonly userId: string;
+    /** Missing: not acknowledged yet. */
+    readonly acknowledgedAt?: Temporal.Instant;
+  }[];
+}
+interface Controls<F extends object = Record<never, never>> {
+  /** Needs `controls.manage`. */
+  saveFramework(organizationId: string, input: ControlFrameworkInput): AsyncResult<ControlFramework>;
+  frameworks(organizationId: string): AsyncResult<readonly ControlFramework[]>;
+  /** Needs `controls.manage`. */
+  saveControl(input: ControlInput<F>): AsyncResult<Control<F>>;
+  getControl(controlId: string): AsyncResult<ControlDetail<F>>;
+  /** By framework and code. */
+  controls(organizationId: string, options?: ControlListOptions): AsyncResult<readonly Control<F>[]>;
+  /** Needs `controls.collect`, or being the evidence task's assignee. */
+  addEvidence(controlId: string, input: ControlEvidenceInput): AsyncResult<ControlEvidence>;
+  /** Needs `controls.manage`. */
+  removeEvidence(evidenceId: string): AsyncResult<ControlEvidence>;
+  /** Needs `controls.manage`. */
+  saveEvidenceTask(controlId: string, input: EvidenceTaskInput): AsyncResult<EvidenceTask>;
+  /** The earliest due first. */
+  evidenceTasks(organizationId: string, options?: EvidenceTaskListOptions): AsyncResult<readonly EvidenceTask[]>;
+  /** The status rollup per framework. */
+  posture(organizationId: string, frameworkId?: string): AsyncResult<readonly ControlPosture[]>;
+  /**
+   * Reports each overdue evidence task once per lapse; returns how many.
+   * Service role only; run it daily.
+   */
+  notifyOverdue(): AsyncResult<number>;
+  /** Needs `controls.manage`. */
+  savePolicy(organizationId: string, input: PolicyInput): AsyncResult<Policy>;
+  /**
+   * Publishes the policy's text as a new frozen version. Members acknowledge
+   * each published version again. Needs `controls.manage`.
+   */
+  publishPolicy(policyId: string, content: Readonly<Record<string, unknown>>, label?: string): AsyncResult<Policy>;
+  archivePolicy(policyId: string): AsyncResult<Policy>;
+  /**
+   * The caller acknowledges the published version. Needs
+   * `controls.acknowledge`.
+   */
+  acknowledgePolicy(policyId: string): AsyncResult<Policy>;
+  policies(organizationId: string, options?: PolicyListOptions): AsyncResult<readonly Policy[]>;
+  /** Every member and when they acknowledged. Needs `controls.read`. */
+  acknowledgements(policyId: string): AsyncResult<PolicyAcknowledgements>;
+}
+/** The `controls` SQL module as typed calls. */
+export declare function createControls<S extends StandardSchemaV1 | undefined = undefined>(options: ControlsOptions<S>): Controls<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/controls/events.d.ts
+/** `control.saved`: a control was created or changed. */
+interface ControlSavedEventData {
+  readonly organizationId: string;
+  readonly controlId: string;
+  readonly frameworkId: string;
+  readonly code: string;
+}
+/** `control.evidence_added`: evidence was collected for a control. */
+interface ControlEvidenceAddedEventData {
+  readonly organizationId: string;
+  readonly controlId: string;
+  readonly evidenceId: string;
+  /** The recurring task the evidence answers, if any. */
+  readonly evidenceTaskId: string | null;
+}
+/** `evidence_task.missed`: a recurring evidence task passed its due date. */
+interface EvidenceTaskMissedEventData {
+  readonly organizationId: string;
+  readonly evidenceTaskId: string;
+  readonly controlId: string;
+  readonly assigneeId: string | null;
+  /** `YYYY-MM-DD`. */
+  readonly dueOn: string;
+}
+/** `policy.published`: a policy has a new current version. */
+interface PolicyPublishedEventData {
+  readonly organizationId: string;
+  readonly policyId: string;
+  readonly versionId: string;
+  readonly number: number;
+}
+/** `policy.acknowledged`: a member acknowledged a policy's current version. */
+interface PolicyAcknowledgedEventData {
+  readonly organizationId: string;
+  readonly policyId: string;
+  readonly versionId: string;
+  readonly userId: string;
+}
+/** The events of the `controls` block: type to data. */
+type ControlsEvents = {
+  readonly "control.saved": ControlSavedEventData;
+  readonly "control.evidence_added": ControlEvidenceAddedEventData;
+  readonly "evidence_task.missed": EvidenceTaskMissedEventData;
+  readonly "policy.published": PolicyPublishedEventData;
+  readonly "policy.acknowledged": PolicyAcknowledgedEventData;
+};
+/** The `controls` block's event types, for its manifest and `onBlockEvent`. */
+export declare const controlsEvents: Events<ControlsEvents>;
+//#endregion
+//#region src/blocks/controls/manifest.d.ts
+/** The `controls` block's manifest (ADR 0029). */
+export declare const controlsBlock: BlockOf<"controls", typeof createControls, ControlsEvents>;
+//#endregion
+//#region src/blocks/controls/schemas.d.ts
+/** What `saveFramework` takes. */
+export declare const controlFrameworkInputSchema: EntitySchema<ControlFrameworkInput>;
+/** What `saveControl` takes. */
+export declare const controlInputSchema: EntitySchema<ControlInput>;
+/** What `addEvidence` takes. */
+export declare const controlEvidenceInputSchema: EntitySchema<ControlEvidenceInput>;
+/** What `saveEvidenceTask` takes. */
+export declare const evidenceTaskInputSchema: EntitySchema<EvidenceTaskInput>;
+/** What `savePolicy` takes. */
+export declare const policyInputSchema: EntitySchema<PolicyInput>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Control, type ControlDetail, type ControlEvidence, type ControlEvidenceAddedEventData, type ControlEvidenceInput, type ControlFramework, type ControlFrameworkInput, type ControlInput, type ControlListOptions, type ControlPosture, type ControlSavedEventData, type ControlStatus, type Controls, type ControlsEvents, type ControlsOptions, type EvidenceTask, type EvidenceTaskInput, type EvidenceTaskListOptions, type EvidenceTaskMissedEventData, type Policy, type PolicyAcknowledgedEventData, type PolicyAcknowledgements, type PolicyInput, type PolicyListOptions, type PolicyPublishedEventData, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };