better-supabase 0.8.0 → 0.9.0

package/dist/blocks/custom-fields/index.js

@@ -0,0 +1,85 @@
+import { t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as CUSTOM_FIELD_TYPES } from "../../field-formats-Cif5gr7c.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as rankBetweenResult } from "../../rank-result-DS8IoLup.js";
+import { t as customFieldsSqlOptions } from "../../options-vXMBEWSH.js";
+//#region src/blocks/custom-fields/custom-fields.ts
+function createCustomFields(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const idOf = (label) => (value) => ({ id: textOf(recordOf(value, label)["id"]) });
+	return withBlockHooks({
+		listDefinitions: (organizationId, entity) => call("list_field_definitions", {
+			tenant: organizationId,
+			entity
+		}, (value) => recordsOf(value, "list_field_definitions").map((row) => {
+			const rank = optionalText(row["rank"]);
+			return {
+				id: textOf(row["id"]),
+				entity: textOf(row["entity"]),
+				key: textOf(row["key"]),
+				label: textOf(row["label"]),
+				type: textOf(row["type"]),
+				required: row["required"] === true,
+				sensitive: row["sensitive"] === true,
+				...rank === void 0 ? {} : { rank }
+			};
+		})),
+		saveDefinition: (organizationId, entity, key, label, type, sensitive) => call("save_field_definition", {
+			tenant: organizationId,
+			entity,
+			key,
+			label,
+			type,
+			sensitive: sensitive ?? false
+		}, idOf("save_field_definition")),
+		reorderDefinition: (id, neighbors) => {
+			const key = rankBetweenResult(neighbors);
+			if (!key.ok) return AsyncResult.err(key.error);
+			return call("rank_field_definition", {
+				definition: id,
+				rank: key.data
+			}, () => key.data);
+		},
+		deleteDefinition: (id) => call("delete_field_definition", { definition: id }, (value) => value === true),
+		readValues: (organizationId, subjectType, subjectId) => call("read_field_values", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId
+		}, (value) => value),
+		setValue: (organizationId, subjectType, subjectId, definitionId, value) => call("set_field_value", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			definition: definitionId,
+			value
+		}, idOf("set_field_value"))
+	}, options.hooks, {
+		block: "custom-fields",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/custom-fields/events.ts
+/** The `custom-fields` block's event types, for its manifest and `onBlockEvent`. */
+const customFieldsEvents = defineEvents({
+	"custom_field.saved": event(),
+	"custom_field.deleted": event(),
+	"field_value.set": event()
+});
+//#endregion
+//#region src/blocks/custom-fields/manifest.ts
+/** The `custom-fields` block's manifest (ADR 0029). */
+const customFieldsBlock = defineBlock({
+	name: "custom-fields",
+	sql: ["custom-fields"],
+	options: { "custom-fields": customFieldsSqlOptions },
+	events: customFieldsEvents,
+	create: createCustomFields,
+	category: "work",
+	recipes: ["custom-fields-editor"]
+});
+//#endregion
+export { CUSTOM_FIELD_TYPES, createCustomFields, customFieldsBlock, customFieldsEvents };

package/dist/blocks/data-lifecycle/index.d.ts

@@ -1,10 +1,14 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "../../result-BchM1XZn.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-inD4fFq-.js";
-import { a as CredentialSubject, i as CredentialRef, r as CredentialProvider } from "../../provider-ib9wzUDz.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-C0Xj8War.js";
-import { m as JobHandler } from "../../types-D__3EN0q.js";
-import { i as EventSink } from "../../cloud-event-Dune0KI7.js";
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { I as DataExportEventData, K as LegalHoldEventData, Y as OrganizationDeletionEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as CredentialSubject, i as CredentialRef, r as CredentialProvider } from "../../provider-9gBq9W6k.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { g as JobHandler } from "../../types-CdP0z5tS.js";
+import { i as EventSink } from "../../cloud-event-5rCEzIgK.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
 //#region src/blocks/data-lifecycle/data-lifecycle.d.ts
 interface StorageReply<T> {
   readonly data: T | null;
@@ -74,11 +78,15 @@ interface DataLifecycleOptions extends BlockTemporalOptions {
   readonly transport: BlockTransport;
   /** The caller's `supabase.storage`, for `download`. */
   readonly storage?: LifecycleStorage;
-  /** The module schema (`sql.modules.data-lifecycle.schema`), default `better_supabase`. */
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
   readonly schema?: string;
   readonly mappers?: readonly ErrorMapper[];
   /** Lifetime of a signed download URL in seconds. Default 300. */
   readonly downloadTtl?: number;
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: NoInfer<BlockHooks<DataLifecycle>>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
 }
 interface DataLifecycle {
   /** Exports the caller's data, or a tenant's with `organizationId` (needs `organization.export`). */
@@ -175,7 +183,7 @@ interface OrganizationPurgerOptions extends BlockTemporalOptions {
    */
   readonly credentials?: CredentialProvider;
   /**
-   * Also run the `sql.modules.data-lifecycle.options.anonymize` rules in
+   * Also run the `blocks.data-lifecycle.options.anonymize` rules in
    * `job`, after the due purges. Default false.
    */
   readonly anonymize?: boolean;
@@ -247,6 +255,84 @@ interface OrganizationPurger {
 /** Purges organizations whose deletion grace period is over. */
 export declare function createOrganizationPurger(options: OrganizationPurgerOptions): OrganizationPurger;
 //#endregion
+//#region src/sql/modules/data-lifecycle-retention.d.ts
+/**
+ * The record kinds the modules' purges look up, so a policy or a hold names
+ * one; apps may add their own kinds for their own purges.
+ */
+declare const RETENTION_KINDS: readonly ["audit", "outbox", "webhook_deliveries", "webhooks", "inbound_events", "job_archive", "usage", "notifications", "workflow_runs", "ai_chats", "trash", "scim_sync_log"];
+//#endregion
+//#region src/blocks/data-lifecycle/retention.d.ts
+/** A kind the modules' purges look up; an app's own purges may use any other. */
+type RetentionKind = (typeof RETENTION_KINDS)[number] | (string & {});
+interface RetentionPolicy {
+  readonly id: string;
+  readonly kind: RetentionKind;
+  /** Postgres interval text, such as `7 years`. */
+  readonly keep: string;
+  /** Set for one tenant's policy. */
+  readonly organizationId: string | undefined;
+  /** Set for the policy of a plan's tenants. */
+  readonly plan: string | undefined;
+  readonly updatedAt: Temporal.Instant;
+}
+interface LegalHold {
+  readonly id: string;
+  /** Absent for a hold on every tenant. */
+  readonly organizationId: string | undefined;
+  /** Absent for a hold on every kind. */
+  readonly kind: RetentionKind | undefined;
+  readonly reason: string;
+  readonly placedBy: string | undefined;
+  readonly placedAt: Temporal.Instant;
+  readonly releasedBy: string | undefined;
+  readonly releasedAt: Temporal.Instant | undefined;
+}
+/** Who a policy applies to: one tenant, a plan's tenants, or every tenant (neither). */
+type RetentionScope = {
+  readonly organizationId: string;
+  readonly plan?: never;
+} | {
+  readonly plan: string;
+  readonly organizationId?: never;
+} | {
+  readonly organizationId?: never;
+  readonly plan?: never;
+};
+interface RetentionOptions extends BlockTemporalOptions {
+  /** A service-role transport: the functions are granted to `service_role` only. */
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface Retention {
+  /**
+   * Keeps `kind` for `keep` (an interval such as `7 years` or a
+   * `Temporal.Duration`), replacing the scope's earlier policy. A purge
+   * keeps rows for the policy whatever its own `older_than`.
+   */
+  setPolicy(kind: RetentionKind, keep: Temporal.Duration | string, scope?: RetentionScope): AsyncResult<RetentionPolicy>;
+  /** `false` when the scope had no policy for `kind`. */
+  removePolicy(kind: RetentionKind, scope?: RetentionScope): AsyncResult<boolean>;
+  policies(kind?: RetentionKind): AsyncResult<readonly RetentionPolicy[]>;
+  /**
+   * Stops every purge (and the organization purge) from deleting what the
+   * hold covers: one tenant or all, one kind or all.
+   */
+  placeHold(hold: {
+    readonly reason: string;
+    readonly organizationId?: string;
+    readonly kind?: RetentionKind;
+  }): AsyncResult<LegalHold>;
+  /** `undefined` when no active hold has this id. */
+  releaseHold(id: string): AsyncResult<LegalHold | undefined>;
+  holds(options?: {
+    readonly includeReleased?: boolean;
+  }): AsyncResult<readonly LegalHold[]>;
+}
+/** Retention policies and legal holds, as the service role. */
+export declare function createRetention(options: RetentionOptions): Retention;
+//#endregion
 //#region src/sql/modules/data-lifecycle-entries.d.ts
 /** An app table in `options.tables`: its user and tenant columns. */
 interface LifecycleTable {
@@ -260,4 +346,23 @@ interface LifecycleTable {
   readonly export?: boolean;
 }
 //#endregion
-export { type BlockTransport, type DataExport, type DataExportDownload, type DataExportJob, type DataExportStatus, type DataExporter, type DataExporterOptions, type DataLifecycle, type DataLifecycleOptions, type LifecycleBucket, type LifecycleStorage, type LifecycleTable, type OrganizationDeletion, type OrganizationPurge, type OrganizationPurger, type OrganizationPurgerOptions, type PurgeBucket, type StorageEntry, type UnrevokedCredential, dbTransport, rpcTransport, sqlTransport };
+//#region src/blocks/data-lifecycle/events.d.ts
+/** The events of the `data-lifecycle` block: type to data. */
+type DataLifecycleEvents = {
+  readonly "data_export.requested": DataExportEventData;
+  readonly "data_export.completed": DataExportEventData;
+  readonly "data_export.failed": DataExportEventData;
+  readonly "organization.deletion_requested": OrganizationDeletionEventData;
+  readonly "organization.deletion_cancelled": OrganizationDeletionEventData;
+  readonly "organization.purged": OrganizationDeletionEventData;
+  readonly "legal_hold.placed": LegalHoldEventData;
+  readonly "legal_hold.released": LegalHoldEventData;
+};
+/** The `data-lifecycle` block's event types, for its manifest and `onBlockEvent`. */
+export declare const dataLifecycleEvents: Events<DataLifecycleEvents>;
+//#endregion
+//#region src/blocks/data-lifecycle/manifest.d.ts
+/** The `data-lifecycle` block's manifest (ADR 0029). */
+export declare const dataLifecycleBlock: BlockOf<"data-lifecycle", typeof createDataLifecycle, DataLifecycleEvents>;
+//#endregion
+export { type BlockTransport, type DataExport, type DataExportDownload, type DataExportJob, type DataExportStatus, type DataExporter, type DataExporterOptions, type DataLifecycle, type DataLifecycleEvents, type DataLifecycleOptions, type LegalHold, type LifecycleBucket, type LifecycleStorage, type LifecycleTable, type OrganizationDeletion, type OrganizationPurge, type OrganizationPurger, type OrganizationPurgerOptions, type PurgeBucket, type Retention, type RetentionKind, type RetentionOptions, type RetentionPolicy, type RetentionScope, type StorageEntry, type UnrevokedCredential, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/data-lifecycle/index.js

@@ -1,11 +1,15 @@
-import { n as dbError } from "../../errors-2M6CKMP4.js";
-import { a as ok, r as err, t as AsyncResult } from "../../result-DEqHCMKP.js";
+import { n as dbError } from "../../errors-8i6tSICm.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-BlgnMB0H.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { n as toCsv } from "../../csv-BZnHA1Py.js";
-import { n as credentialRefInTenant } from "../../provider-DxRTex4x.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-bAKh-dGc.js";
-import { A as stringsOf, N as toInstant, S as recordOf, _ as optionalInstant, i as blockCall, j as textOf, l as errorText, n as applyTemporal, v as optionalText, w as recordsOf } from "../../block-helpers-Cy3pB96I.js";
-import { t as fromStorageError } from "../../errors-rZ7VIqp6.js";
+import { t as fromStorageError } from "../../errors-PIpcoe4z.js";
+import { r as toCsv } from "../../csv-CVfXqaAu.js";
+import { n as credentialRefInTenant } from "../../provider-DKh2xFZb.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 { C as optionalText, D as recordOf, F as stringsOf, I as textOf, R as toInstant, S as optionalInstant, f as errorText, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as dataLifecycleSqlOptions } from "../../options-C239TLRF.js";
 //#region src/blocks/data-lifecycle/data-lifecycle.ts
 const EXPORT_STATUSES = [
 	"pending",
@@ -63,7 +67,7 @@ function createDataLifecycle(options) {
 	applyTemporal(options);
 	const call = blockCall(options.transport, options.schema, options.mappers);
 	const ttl = options.downloadTtl ?? 300;
-	return {
+	return withBlockHooks({
 		requestExport: (request = {}) => call("request_data_export", request.organizationId === void 0 ? { subject: "user" } : {
 			subject: "organization",
 			tenant: request.organizationId
@@ -95,7 +99,10 @@ function createDataLifecycle(options) {
 		}, deletionOf),
 		cancelOrganizationDeletion: (organizationId) => call("cancel_organization_deletion", { tenant: organizationId }, optionalDeletion),
 		organizationDeletion: (organizationId) => call("organization_deletion", { tenant: organizationId }, optionalDeletion)
-	};
+	}, options.hooks, {
+		block: "data-lifecycle",
+		...options.logger ? { logger: options.logger } : {}
+	});
 }
 //#endregion
 //#region src/blocks/data-lifecycle/exporter.ts
@@ -246,9 +253,9 @@ async function removePrefix(bucket, prefix) {
 	return ok(files.length);
 }
 function purgeCredentialOf(value) {
-	if (!isRecord(value)) return void 0;
+	if (!isRecord(value)) return;
 	const ref = value["ref"];
-	if (!isRecord(ref) || typeof ref["provider"] !== "string") return void 0;
+	if (!isRecord(ref) || typeof ref["provider"] !== "string") return;
 	const userId = optionalText(value["user_id"]);
 	return {
 		table: textOf(value["table"]),
@@ -360,4 +367,83 @@ function createOrganizationPurger(options) {
 	};
 }
 //#endregion
-export { createDataExporter, createDataLifecycle, createOrganizationPurger, dbTransport, rpcTransport, sqlTransport };
+//#region src/blocks/data-lifecycle/retention.ts
+function policyOf(value) {
+	const row = recordOf(value, "retention_policies");
+	return {
+		id: textOf(row["id"]),
+		kind: textOf(row["kind"]),
+		keep: textOf(row["keep"]),
+		organizationId: optionalText(row["organization_id"]),
+		plan: optionalText(row["plan"]),
+		updatedAt: toInstant(textOf(row["updated_at"]))
+	};
+}
+function holdOf(value) {
+	const row = recordOf(value, "legal_holds");
+	return {
+		id: textOf(row["id"]),
+		organizationId: optionalText(row["organization_id"]),
+		kind: optionalText(row["kind"]),
+		reason: textOf(row["reason"]),
+		placedBy: optionalText(row["placed_by"]),
+		placedAt: toInstant(textOf(row["placed_at"])),
+		releasedBy: optionalText(row["released_by"]),
+		releasedAt: optionalInstant(row["released_at"])
+	};
+}
+/** Retention policies and legal holds, as the service role. */
+function createRetention(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const scoped = (scope = {}) => ({
+		tenant: scope.organizationId,
+		plan: scope.plan
+	});
+	return {
+		setPolicy: (kind, keep, scope) => call("set_retention_policy", {
+			kind,
+			keep: String(keep),
+			...scoped(scope)
+		}, policyOf),
+		removePolicy: (kind, scope) => call("remove_retention_policy", {
+			kind,
+			...scoped(scope)
+		}, (value) => value === true),
+		policies: (kind) => call("list_retention_policies", { kind }, (value) => recordsOf(value, "list_retention_policies").map(policyOf)),
+		placeHold: (hold) => call("place_legal_hold", {
+			reason: hold.reason,
+			tenant: hold.organizationId,
+			kind: hold.kind
+		}, holdOf),
+		releaseHold: (id) => call("release_legal_hold", { id }, (value) => isRecord(value) ? holdOf(value) : void 0),
+		holds: (request = {}) => call("list_legal_holds", { include_released: request.includeReleased ?? false }, (value) => recordsOf(value, "list_legal_holds").map(holdOf))
+	};
+}
+//#endregion
+//#region src/blocks/data-lifecycle/events.ts
+/** The `data-lifecycle` block's event types, for its manifest and `onBlockEvent`. */
+const dataLifecycleEvents = defineEvents({
+	"data_export.requested": event(),
+	"data_export.completed": event(),
+	"data_export.failed": event(),
+	"organization.deletion_requested": event(),
+	"organization.deletion_cancelled": event(),
+	"organization.purged": event(),
+	"legal_hold.placed": event(),
+	"legal_hold.released": event()
+});
+//#endregion
+//#region src/blocks/data-lifecycle/manifest.ts
+/** The `data-lifecycle` block's manifest (ADR 0029). */
+const dataLifecycleBlock = defineBlock({
+	name: "data-lifecycle",
+	sql: ["data-lifecycle"],
+	options: { "data-lifecycle": dataLifecycleSqlOptions },
+	events: dataLifecycleEvents,
+	create: createDataLifecycle,
+	category: "admin",
+	recipes: ["data-export-delete"]
+});
+//#endregion
+export { createDataExporter, createDataLifecycle, createOrganizationPurger, createRetention, dataLifecycleBlock, dataLifecycleEvents, dbTransport, rpcTransport, sqlTransport };

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

@@ -0,0 +1,262 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { h as DealEventData } from "../../index-BlqrGvb3.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { t as SubjectConfig } from "../../subjects-z8VWA_lF.js";
+import { n as Money } from "../../money-DFpWzQvk.js";
+//#region src/blocks/deals/deals.d.ts
+/** How a rep calls a deal for the period. `undefined` is "not called". */
+type ForecastCategory = "commit" | "best_case" | "pipeline" | "omit";
+type DealOutcome = "open" | "won" | "lost";
+/** A record a deal points at: its company or a contact. */
+interface DealParty {
+  readonly type: string;
+  readonly id: string;
+}
+interface DealContact extends DealParty {
+  readonly role?: string;
+  readonly primary: boolean;
+}
+/** A deal. `F` types the extra columns the `fields` schema describes. */
+interface Deal<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly number: bigint;
+  /** `DEAL-4821`, or the number-sequences format. */
+  readonly identifier: string;
+  readonly name: string;
+  readonly company?: DealParty;
+  readonly ownerId?: string;
+  /** `new_logo`, `expansion`, `renewal` or a configured motion. */
+  readonly motion?: string;
+  /** `hot`, `warm`, `cold` or a configured priority. */
+  readonly priority?: string;
+  readonly product?: string;
+  readonly seats?: number;
+  readonly amount: Money;
+  /** The revenue the account already brings, for an expansion. */
+  readonly existingAmount: Money;
+  /** The deal's currency, which every amount on it shares. */
+  readonly currency: string;
+  readonly valuePeriod: "one_time" | "monthly" | "annual";
+  /** `line_items` keeps the amount equal to the lines' subtotal. */
+  readonly amountSource: "manual" | "line_items";
+  readonly pipelineId?: string;
+  readonly stageId?: string;
+  readonly stageEnteredAt?: Temporal.Instant;
+  readonly outcome: DealOutcome;
+  /** The deal's own win probability; the stage's applies without it. */
+  readonly probability?: number;
+  readonly forecast?: ForecastCategory;
+  readonly openedOn: Temporal.PlainDate;
+  readonly closeOn: Temporal.PlainDate;
+  /** The first close date, set the first time the close date moved later. */
+  readonly slippedFrom?: Temporal.PlainDate;
+  /** How often the close date moved later. */
+  readonly pushCount: number;
+  readonly closedAt?: Temporal.Instant;
+  readonly nextStep?: string;
+  readonly nextAt?: Temporal.Instant;
+  readonly nextKind?: string;
+  readonly flags: readonly string[];
+  readonly source?: string;
+  readonly note?: string;
+  readonly lostReason?: string;
+  /** A locked deal takes only its note. */
+  readonly locked: boolean;
+  readonly rank: string;
+  readonly totals: DealTotals;
+  readonly contacts: readonly DealContact[];
+  readonly members: readonly {
+    readonly userId: string;
+    readonly role?: string;
+  }[];
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>> & F;
+  readonly archived: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** Line totals in the deal's currency: list, discount, subtotal, tax and total. */
+interface DealTotals {
+  readonly listTotal: Money;
+  readonly discountTotal: Money;
+  readonly subtotal: Money;
+  readonly taxTotal: Money;
+  readonly total: Money;
+}
+interface DealInput<F extends object = Record<never, never>> {
+  readonly name: string;
+  readonly closeOn: Temporal.PlainDate;
+  readonly amount?: Money;
+  /** Defaults to the amounts' currency, then `EUR`. */
+  readonly currency?: string;
+  readonly company?: DealParty;
+  readonly ownerId?: string;
+  readonly motion?: string;
+  readonly priority?: string;
+  readonly product?: string;
+  readonly seats?: number;
+  readonly existingAmount?: Money;
+  readonly valuePeriod?: Deal["valuePeriod"];
+  readonly pipelineId?: string;
+  readonly stageId?: string;
+  readonly probability?: number;
+  readonly forecast?: ForecastCategory;
+  readonly nextStep?: string;
+  readonly nextAt?: Temporal.Instant;
+  readonly nextKind?: string;
+  readonly flags?: readonly string[];
+  readonly source?: string;
+  readonly note?: string;
+  /** Values for the extra columns, by column name. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+/** The fields `update` writes, the shape of a grid cell edit. */
+type DealField = "name" | "motion" | "priority" | "ownerId" | "product" | "seats" | "amount" | "existingAmount" | "currency" | "valuePeriod" | "amountSource" | "stageId" | "probability" | "forecast" | "closeOn" | "nextStep" | "nextAt" | "nextKind" | "flags" | "source" | "note" | "lostReason" | "company";
+/** One cell edit: a field above, or an extra column by name. `null` clears it. */
+interface DealChange {
+  readonly dealId: string;
+  readonly field: DealField | (string & {});
+  readonly value: unknown;
+}
+interface DealChangeResult {
+  readonly accepted: readonly {
+    readonly dealId: string;
+    readonly field: string;
+  }[];
+  /** Each refused change, with the error hint and message. Others still applied. */
+  readonly rejected: readonly {
+    readonly dealId: string;
+    readonly field: string;
+    readonly hint?: string;
+    readonly reason: string;
+  }[];
+}
+/** A line of a deal, in the deal's currency. */
+interface DealLineInput {
+  readonly description: string;
+  readonly quantity?: number;
+  readonly unitAmount: Money;
+  readonly discountBps?: number;
+  readonly taxRateBps?: number;
+  readonly taxCode?: string;
+  readonly product?: DealParty;
+}
+/** The forecast call for one currency. */
+interface DealForecast {
+  readonly currency: string;
+  readonly won: Money;
+  readonly commit: Money;
+  readonly bestCase: Money;
+  readonly pipeline: Money;
+  readonly notCalled: Money;
+  readonly omit: Money;
+  /** Open deals that close after the period. */
+  readonly later: Money;
+  readonly target?: Money;
+  /** Won plus commit over the target. */
+  readonly attainment?: number;
+  readonly gap?: Money;
+  readonly owners: readonly (Omit<DealForecast, "owners" | "currency" | "target" | "attainment" | "gap"> & {
+    readonly ownerId?: string;
+  })[];
+}
+/** The checks a forecast review runs on an open deal. */
+interface DealHealth {
+  readonly dealId: string;
+  readonly identifier: string;
+  readonly name: string;
+  readonly daysInStage: number;
+  readonly rotting: boolean;
+  /** The close date moved later or passed. */
+  readonly slipped: boolean;
+  readonly noNextStep: boolean;
+  readonly overdue: boolean;
+}
+/** `F` types the deals' extra columns, from the `fields` schema. */
+interface Deals<F extends object = Record<never, never>> {
+  create(organizationId: string, input: DealInput<F>, contacts?: readonly DealContact[]): AsyncResult<Deal<F>>;
+  /** Applies cell edits; a refused change leaves the others applied. */
+  update(changes: readonly DealChange[]): AsyncResult<DealChangeResult>;
+  /** Moves the deal to its pipeline's won stage. `note` is the closing note. */
+  win(dealId: string, note?: string): AsyncResult<Deal<F>>;
+  /** Moves the deal to its pipeline's lost stage. */
+  lose(dealId: string, reason?: string): AsyncResult<Deal<F>>;
+  /** Opens a closed deal again, in `stageId` or the first open stage. */
+  reopen(dealId: string, stageId?: string): AsyncResult<Deal<F>>;
+  setContacts(dealId: string, contacts: readonly DealContact[]): AsyncResult<number>;
+  /** Replaces the deal team; each member watches the deal. */
+  setMembers(dealId: string, members: readonly {
+    readonly userId: string;
+    readonly role?: string;
+  }[]): AsyncResult<number>;
+  setLines(dealId: string, lines: readonly DealLineInput[]): AsyncResult<DealTotals>;
+  archive(dealId: string, archived?: boolean): AsyncResult<boolean>;
+  remove(dealId: string): AsyncResult<boolean>;
+  forecast(organizationId: string, period: {
+    readonly since: Temporal.PlainDate;
+    readonly until: Temporal.PlainDate;
+    readonly currency: string;
+    /** In `currency`. */
+    readonly target?: Money;
+    readonly pipelineId?: string;
+    readonly ownerId?: string;
+  }): AsyncResult<DealForecast>;
+  health(pipelineId: string): AsyncResult<DealHealth[]>;
+}
+interface DealsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the deals' extra columns
+   * (`blocks.deals.options.extraColumns`), keyed by column name. It types
+   * and parses `fields` on reads and validates them on writes.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Deals<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The deals block: deals on pipelines, with batched cell edits that reject
+ * per change, won and lost through the pipeline's stages, contacts, a team,
+ * line items, the forecast call and the review checks.
+ */
+export declare function createDeals<S extends StandardSchemaV1 | undefined = undefined>(options: DealsOptions<S>): Deals<FieldsOf<S>>;
+/**
+ * The `config.subjects` entry for deals, so comments, tags, files, rank and
+ * search attach to them. The board moves a deal by its stage id.
+ */
+export declare function dealsSubjects(options?: {
+  readonly schema?: string;
+  readonly url?: string;
+}): {
+  readonly deal: SubjectConfig;
+};
+//#endregion
+//#region src/blocks/deals/events.d.ts
+/** The events of the `deals` block: type to data. */
+type DealsEvents = {
+  readonly "deal.created": DealEventData;
+  readonly "deal.updated": DealEventData;
+  readonly "deal.closed": DealEventData;
+  readonly "deal.reopened": DealEventData;
+  readonly "deal.archived": DealEventData;
+  readonly "deal.deleted": DealEventData;
+};
+/** The `deals` block's event types, for its manifest and `onBlockEvent`. */
+export declare const dealsEvents: Events<DealsEvents>;
+//#endregion
+//#region src/blocks/deals/manifest.d.ts
+/** The `deals` block's manifest (ADR 0029). */
+export declare const dealsBlock: BlockOf<"deals", typeof createDeals, DealsEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Deal, type DealChange, type DealChangeResult, type DealContact, type DealField, type DealForecast, type DealHealth, type DealInput, type DealLineInput, type DealOutcome, type DealParty, type DealTotals, type Deals, type DealsEvents, type DealsOptions, type ForecastCategory, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };