better-supabase 0.13.0 → 0.14.0

package/dist/blocks/billable-time/index.d.ts

@@ -0,0 +1,203 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-C6jDfedy.js";
+import { dt as SubjectRef } from "../../executor-CPyrQdjh.js";
+import { Ct as Events } from "../../events-DbLjvxDX.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, 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 { Gt as SectionWrite, Lt as Section, c as BlockOf, rn as EntitySchema } from "../../define-block-COpcS6aT.js";
+import { n as Money } from "../../money-BNRdJQzA.js";
+//#region src/blocks/billable-time/billable-time.d.ts
+/** How `unbilled` and `invoice` turn entries into lines. */
+type BillableTimeGrouping = "subject" | "member" | "entry";
+interface BillableTimeOptions extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
+  readonly schema?: string;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<BillableTime>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * An hourly rate on the rate card. Without `userId` and `subject` it is the
+ * organization's rate.
+ */
+interface TimeRate {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId?: string;
+  readonly subject?: SubjectRef;
+  /** Per hour. */
+  readonly rate: Money;
+  readonly effectiveFrom: Temporal.PlainDate;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+}
+interface TimeRateInput {
+  /** Per hour, in minor units. */
+  readonly rate: Money;
+  /** The member the rate is for. */
+  readonly userId?: string;
+  /** The record the rate is for, such as a project. */
+  readonly subject?: SubjectRef;
+  /** Default: today. The same key and day replaces the rate. */
+  readonly effectiveFrom?: Temporal.PlainDate;
+}
+interface TimeRateListOptions {
+  readonly userId?: string;
+  readonly subject?: SubjectRef;
+  readonly pageSize?: number;
+}
+interface TimeRateLookup {
+  readonly userId?: string;
+  readonly subject?: SubjectRef;
+  /** Default: today. */
+  readonly on?: Temporal.PlainDate;
+}
+/** Which unbilled entries to bill. Every field narrows the selection. */
+interface BillableTimeScope {
+  readonly subject?: SubjectRef;
+  readonly userId?: string;
+  /** Entries that started at or after this. */
+  readonly starts?: Temporal.Instant;
+  /** Entries that started before this. */
+  readonly ends?: Temporal.Instant;
+  readonly entryIds?: readonly string[];
+}
+interface BillableTimeQuery extends BillableTimeScope {
+  /** Default `subject`: one line per record and rate. */
+  readonly groupBy?: BillableTimeGrouping;
+}
+/** One invoice line the unbilled time would become. */
+interface BillableTimeLine {
+  readonly description: string;
+  /** Hours, to four decimals, as text so no precision is lost. */
+  readonly quantity: string;
+  /** The hourly rate. */
+  readonly unitAmount: Money;
+  /** `quantity` times `unitAmount`, rounded to a minor unit. */
+  readonly amount: Money;
+  readonly entryIds: readonly string[];
+  readonly subject?: SubjectRef;
+  /** Set when lines are grouped by member or entry. */
+  readonly userId?: string;
+}
+/** What `unbilled` returns. */
+interface UnbilledTime {
+  readonly lines: readonly BillableTimeLine[];
+  /** One total per currency. */
+  readonly totals: readonly Money[];
+  /** Billable entries no rate covers; `invoice` fails while there are any. */
+  readonly unrated: readonly string[];
+}
+interface InvoiceFromTimeInput extends BillableTimeQuery {
+  /** Picks the entries billed in this currency; required when they differ. */
+  readonly currency?: string;
+  /** Default `Time`. */
+  readonly title?: string;
+  /** The company billed, such as `{ type: "companies", id }`. */
+  readonly company?: SubjectRef;
+  readonly contact?: SubjectRef;
+  readonly termsDays?: number;
+  readonly note?: string;
+}
+/** The draft invoice `invoice` created. */
+interface TimeInvoice {
+  readonly invoiceId: string;
+  /** The lines' sum, before discounts and tax. */
+  readonly total: Money;
+  readonly entryIds: readonly string[];
+}
+/** A time entry on an invoice, with what it was billed at. */
+interface InvoicedTimeEntry {
+  readonly entryId: string;
+  readonly invoiceId: string;
+  readonly userId: string;
+  readonly subject?: SubjectRef;
+  readonly startedAt: Temporal.Instant;
+  readonly seconds: number;
+  /** The hourly rate it was billed at. */
+  readonly rate: Money;
+  readonly createdAt: Temporal.Instant;
+}
+interface BillableTime {
+  /** Sets an hourly rate. Needs `billable_time.manage`. */
+  setRate(input: TimeRateInput): AsyncResult<TimeRate>;
+  /** Needs `billable_time.manage`. */
+  deleteRate(rateId: string): AsyncResult<TimeRate>;
+  /** The rate card. Needs `billable_time.read`. */
+  listRates(options?: TimeRateListOptions): AsyncResult<readonly TimeRate[]>;
+  /**
+   * The rate that applies to a member's time on a record: member and record
+   * first, then the record, the member, the organization. `null` when none
+   * does.
+   */
+  rateFor(lookup?: TimeRateLookup): AsyncResult<TimeRate | null>;
+  /** What `invoice` would bill, without billing it. */
+  unbilled(query?: BillableTimeQuery): AsyncResult<UnbilledTime>;
+  /**
+   * Bills the unbilled time the scope selects on a new draft invoice. Needs
+   * `billable_time.invoice` and `invoices.write`. Fails with
+   * `TIME_RATE_MISSING`, `BILLABLE_TIME_CURRENCIES` or `BILLABLE_TIME_EMPTY`.
+   */
+  invoice(input?: InvoiceFromTimeInput): AsyncResult<TimeInvoice>;
+  /** The entries an invoice billed. */
+  invoicedEntries(invoiceId: string, options?: {
+    readonly pageSize?: number;
+  }): AsyncResult<readonly InvoicedTimeEntry[]>;
+}
+/** The `billable-time` SQL module as typed calls. */
+export declare function createBillableTime(options: BillableTimeOptions): BillableTime;
+//#endregion
+//#region src/blocks/billable-time/events.d.ts
+/** `time.invoiced`: unbilled time became a draft invoice. */
+interface TimeInvoicedEventData {
+  readonly organizationId: string;
+  readonly invoiceId: string;
+  /** The time entries the invoice billed. */
+  readonly entryIds: readonly string[];
+  readonly currency: string;
+  /** The invoice's lines before discounts and tax, in minor units as text. */
+  readonly total: string;
+}
+/** The events of the `billable-time` block: type to data. */
+type BillableTimeEvents = {
+  readonly "time.invoiced": TimeInvoicedEventData;
+};
+/** The `billable-time` block's event types, for its manifest and `onBlockEvent`. */
+export declare const billableTimeEvents: Events<BillableTimeEvents>;
+//#endregion
+//#region src/blocks/billable-time/schemas.d.ts
+/** What `setRate` takes, with the bounds the SQL checks. */
+export declare const timeRateInputSchema: EntitySchema<TimeRateInput>;
+/** What the section's `invoice` write takes: the record is the scope. */
+type TimeInvoiceSectionInput = Pick<InvoiceFromTimeInput, "title" | "currency" | "groupBy" | "note">;
+export declare const timeInvoiceSectionInputSchema: EntitySchema<TimeInvoiceSectionInput>;
+/** What the section's `setRate` write takes: the record is the rate's subject. */
+type TimeRateSectionInput = Omit<TimeRateInput, "subject">;
+export declare const timeRateSectionInputSchema: EntitySchema<TimeRateSectionInput>;
+//#endregion
+//#region src/blocks/billable-time/section.d.ts
+/** The writes of the billable time section. */
+type BillableTimeWrites = {
+  /** Sets the record's hourly rate, or a member's rate on it. */
+  readonly setRate: SectionWrite<BillableTime, TimeRateSectionInput, TimeRate>;
+  /** Bills the record's unbilled time on a new draft invoice. */
+  readonly invoice: SectionWrite<BillableTime, TimeInvoiceSectionInput, TimeInvoice>;
+};
+/** A record's unbilled time, such as a project's, ready to invoice. */
+export declare const billableTimeSection: Section<BillableTime, UnbilledTime, undefined, never, BillableTimeWrites>;
+//#endregion
+//#region src/blocks/billable-time/manifest.d.ts
+/** The `billable-time` block's manifest (ADR 0029). */
+export declare const billableTimeBlock: BlockOf<"billable-time", typeof createBillableTime, BillableTimeEvents, Record<never, never>, never, {
+  readonly billableTime: typeof billableTimeSection;
+}>;
+//#endregion
+export { type BillableTime, type BillableTimeEvents, type BillableTimeGrouping, type BillableTimeLine, type BillableTimeOptions, type BillableTimeQuery, type BillableTimeScope, type BillableTimeWrites, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type InvoiceFromTimeInput, type InvoicedTimeEntry, type RpcClient, type TimeInvoice, type TimeInvoiceSectionInput, type TimeInvoicedEventData, type TimeRate, type TimeRateInput, type TimeRateListOptions, type TimeRateLookup, type TimeRateSectionInput, type UnbilledTime, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/billable-time/index.js

@@ -0,0 +1,260 @@
+import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, U as sqlTransport, 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 defineBlock } from "../../define-block-Dze77QTw.js";
+import { t as requireTenant } from "../../block-tenant-C1sNV8_4.js";
+import { i as moneyOf, t as amountText } from "../../money-codec-jMP0PQLZ.js";
+//#region src/blocks/billable-time/billable-time.ts
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+function subjectOf(row) {
+	const type = optionalText(row["subjectType"]);
+	const id = optionalText(row["subjectId"]);
+	return type === void 0 || id === void 0 ? void 0 : {
+		type,
+		id
+	};
+}
+function idsOf(value, field) {
+	if (!Array.isArray(value)) throw new TypeError(`${field} is not a list`);
+	return value.map((item) => textOf(item));
+}
+function rateOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		rate: moneyOf(row["rate"], row["currency"], "time rate"),
+		effectiveFrom: temporal().PlainDate.from(textOf(row["effectiveFrom"])),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...optional("userId", optionalText(row["userId"])),
+		...optional("subject", subjectOf(row)),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function lineOf(value) {
+	const row = recordOf(value, "unbilled_time");
+	return {
+		description: textOf(row["description"]),
+		quantity: String(row["quantity"]),
+		unitAmount: moneyOf(row["unitAmount"], row["currency"], "unitAmount"),
+		amount: moneyOf(row["amount"], row["currency"], "amount"),
+		entryIds: idsOf(row["entryIds"], "entryIds"),
+		...optional("subject", subjectOf(row)),
+		...optional("userId", optionalText(row["userId"]))
+	};
+}
+function invoicedOf(value) {
+	const row = recordOf(value, "list_invoiced_time");
+	const seconds = Number(row["seconds"]);
+	if (!Number.isInteger(seconds)) throw new TypeError("seconds is not an integer");
+	return {
+		entryId: textOf(row["entryId"]),
+		invoiceId: textOf(row["invoiceId"]),
+		userId: textOf(row["userId"]),
+		startedAt: requiredInstant(row["startedAt"], "startedAt"),
+		seconds,
+		rate: moneyOf(row["rate"], row["currency"], "rate"),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...optional("subject", subjectOf(row))
+	};
+}
+/** A scope as the `jsonb` the SQL reads; absent fields stay absent. */
+function scopeArg(scope) {
+	return {
+		...optional("subject", scope.subject),
+		...optional("userId", scope.userId),
+		...optional("starts", instantArg(scope.starts) ?? void 0),
+		...optional("ends", instantArg(scope.ends) ?? void 0),
+		...optional("entryIds", scope.entryIds)
+	};
+}
+/** The `billable-time` SQL module as typed calls. */
+function createBillableTime(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const tenant = () => requireTenant(options.tenant);
+	return withBlockHooks({
+		setRate: (input) => tenant().andThen((organizationId) => call("set_time_rate", {
+			tenant: organizationId,
+			rate: amountText(input.rate),
+			currency: input.rate.currency,
+			user_id: input.userId ?? null,
+			subject_type: input.subject?.type ?? null,
+			subject_id: input.subject?.id ?? null,
+			effective_from: input.effectiveFrom?.toString() ?? null
+		}, (value) => rateOf(value, "set_time_rate"))),
+		deleteRate: (rateId) => call("delete_time_rate", { rate_id: rateId }, (value) => rateOf(value, "delete_time_rate")),
+		listRates: (list = {}) => tenant().andThen((organizationId) => call("list_time_rates", {
+			tenant: organizationId,
+			user_id: list.userId ?? null,
+			subject_type: list.subject?.type ?? null,
+			subject_id: list.subject?.id ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_time_rates").map((row) => rateOf(row, "list_time_rates")))),
+		rateFor: (lookup = {}) => tenant().andThen((organizationId) => call("time_rate", {
+			tenant: organizationId,
+			user_id: lookup.userId ?? null,
+			subject_type: lookup.subject?.type ?? null,
+			subject_id: lookup.subject?.id ?? null,
+			on_day: lookup.on?.toString() ?? null
+		}, (value) => value === null ? null : rateOf(value, "time_rate"))),
+		unbilled: (query = {}) => tenant().andThen((organizationId) => call("unbilled_time", {
+			tenant: organizationId,
+			scope: scopeArg(query),
+			group_by: query.groupBy ?? "subject"
+		}, (value) => {
+			const row = recordOf(value, "unbilled_time");
+			return {
+				lines: recordsOf(row["lines"], "unbilled_time").map(lineOf),
+				totals: recordsOf(row["totals"], "unbilled_time").map((total) => moneyOf(total["amount"], total["currency"], "total")),
+				unrated: idsOf(row["unrated"], "unrated")
+			};
+		})),
+		invoice: (input = {}) => tenant().andThen((organizationId) => call("invoice_from_time", {
+			tenant: organizationId,
+			attrs: {
+				...optional("currency", input.currency),
+				...optional("title", input.title),
+				...optional("company", input.company),
+				...optional("contact", input.contact),
+				...optional("termsDays", input.termsDays),
+				...optional("note", input.note)
+			},
+			scope: scopeArg(input),
+			group_by: input.groupBy ?? "subject"
+		}, (value) => {
+			const row = recordOf(value, "invoice_from_time");
+			return {
+				invoiceId: textOf(row["invoiceId"]),
+				total: moneyOf(row["total"], row["currency"], "total"),
+				entryIds: idsOf(row["entryIds"], "entryIds")
+			};
+		})),
+		invoicedEntries: (invoiceId, list = {}) => call("list_invoiced_time", {
+			invoice: invoiceId,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_invoiced_time").map(invoicedOf))
+	}, options.hooks, {
+		block: "billable-time",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/billable-time/events.ts
+/** The `billable-time` block's event types, for its manifest and `onBlockEvent`. */
+const billableTimeEvents = defineEvents({ "time.invoiced": event() });
+//#endregion
+//#region src/blocks/billable-time/schemas.ts
+/** What `setRate` takes, with the bounds the SQL checks. */
+const timeRateInputSchema = entitySchema({
+	title: "TimeRateInput",
+	fields: {
+		rate: moneyField,
+		userId: {
+			kind: "uuid",
+			optional: true
+		},
+		subject: {
+			kind: "json",
+			optional: true,
+			description: "The record the rate applies to: `{ type, id }`."
+		},
+		effectiveFrom: {
+			kind: "plainDate",
+			optional: true
+		}
+	}
+});
+const timeInvoiceSectionInputSchema = entitySchema({
+	title: "TimeInvoiceSectionInput",
+	fields: {
+		title: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 200
+		},
+		currency: {
+			kind: "string",
+			optional: true,
+			minLength: 3,
+			maxLength: 3
+		},
+		groupBy: {
+			kind: "enum",
+			values: [
+				"subject",
+				"member",
+				"entry"
+			],
+			optional: true
+		},
+		note: {
+			kind: "string",
+			optional: true,
+			maxLength: 2e3
+		}
+	}
+});
+const timeRateSectionInputSchema = entitySchema({
+	title: "TimeRateSectionInput",
+	fields: {
+		rate: moneyField,
+		userId: {
+			kind: "uuid",
+			optional: true
+		},
+		effectiveFrom: {
+			kind: "plainDate",
+			optional: true
+		}
+	}
+});
+//#endregion
+//#region src/blocks/billable-time/section.ts
+/** A record's unbilled time, such as a project's, ready to invoice. */
+const billableTimeSection = defineSection({
+	permissions: {
+		read: "read",
+		write: "manage"
+	},
+	module: "billable-time",
+	load: (client, subject) => client.unbilled({ subject }),
+	events: ["time.*"],
+	writes: {
+		setRate: {
+			input: timeRateSectionInputSchema,
+			run: (client, subject, input) => client.setRate({
+				...input,
+				subject
+			})
+		},
+		invoice: {
+			input: timeInvoiceSectionInputSchema,
+			run: (client, subject, input) => client.invoice({
+				...input,
+				subject
+			})
+		}
+	}
+});
+//#endregion
+//#region src/blocks/billable-time/manifest.ts
+/** The `billable-time` block's manifest (ADR 0029). */
+const billableTimeBlock = defineBlock({
+	name: "billable-time",
+	sql: ["billable-time"],
+	options: {},
+	events: billableTimeEvents,
+	schemas: { time_rate: { input: timeRateInputSchema } },
+	create: createBillableTime,
+	sections: { billableTime: billableTimeSection },
+	category: "commerce"
+});
+//#endregion
+export { billableTimeBlock, billableTimeEvents, billableTimeSection, createBillableTime, dbTransport, extendBlock, rpcTransport, sqlTransport, timeInvoiceSectionInputSchema, timeRateInputSchema, timeRateSectionInputSchema, withBlockHooks, wrapTransport };

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

@@ -1,20 +1,21 @@
 /// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "../../result-mijqfoJN.js";
-import { C as BillingEventData, O as BlockEventType, o as EventHub, wt as Events } from "../../events-DhGgwqQA.js";
+import { T as ErrorMapper, t as AsyncResult } from "../../result-C6jDfedy.js";
+import { C as BillingEventData, Ct as Events, O as BlockEventType, o as EventHub } from "../../events-DbLjvxDX.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { n as SqlClient } from "../../executor-DXfgDsKd.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-DyA5BAW4.js";
-import { n as BlockHooks } from "../../block-hooks-BadAniNI.js";
-import { n as StripeSource, r as StripeTaxId, t as StripeClient } from "../../stripe-BSEwKCni.js";
-import { i as EventSink } from "../../cloud-event-CidL9jiw.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { d as stripeInboxVerify, f as verifyStripeWebhook, u as signStripeWebhook } from "../../verify-BTAEsJbF.js";
-import { a as PlanPickerController, c as createPlanPickerController, i as PlanPickerActions, n as PlanCatalog, o as PlanPickerControllerOptions, r as PlanOption, s as PlanPickerSnapshot, t as CheckoutStarted } from "../../client-5IVhjmtl.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-BaugZlJV.js";
+import { n as SqlClient } from "../../executor-CsTaO3AT.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
+import { n as BlockHooks } from "../../block-hooks-CmjPKqQ_.js";
+import { n as StripeSource, r as StripeTaxId, t as StripeClient } from "../../stripe-X22LjuH-.js";
+import { i as EventSink } from "../../cloud-event-SPyXMdcd.js";
+import { c as BlockOf } from "../../define-block-COpcS6aT.js";
+import { d as stripeInboxVerify, f as verifyStripeWebhook, u as signStripeWebhook } from "../../verify-BmuCB4PW.js";
+import { a as PlanPickerController, c as createPlanPickerController, i as PlanPickerActions, n as PlanCatalog, o as PlanPickerControllerOptions, r as PlanOption, s as PlanPickerSnapshot, t as CheckoutStarted } from "../../client-BrtwaIBh.js";
 //#region src/blocks/billing/events.d.ts
 /** The events of the `billing` block: type to data. */
 type BillingEvents = {
   readonly "billing.customer_linked": BillingEventData;
+  readonly "billing.account_linked": BillingEventData;
   readonly "billing.checkout_completed": BillingEventData;
   readonly "billing.subscription_created": BillingEventData;
   readonly "billing.subscription_updated": BillingEventData;
@@ -75,6 +76,39 @@ interface BillingOptions extends BlockTemporalOptions {
     readonly sql: SqlClient;
     readonly invalidate: (userId: string) => void;
   };
+  /**
+   * Bills tenants as Stripe Accounts v2 accounts with the `customer`
+   * configuration instead of v1 customers. `checkout` creates or reuses the
+   * tenant's account and passes it as `customer_account` to Checkout, as does
+   * `portal`. Stripe creates the account's linked customer at the first
+   * checkout, and `handleStripeEvent` records it. A tenant that already has a
+   * v1 customer keeps it. Needs `v2.core.accounts` on the Stripe client.
+   * Default `false`.
+   */
+  readonly customerAccounts?: boolean | CustomerAccountOptions;
+  /**
+   * `ignore` skips Connect events (those with `event.account`, sent for a
+   * connected account) in `handleStripeEvent`, for an endpoint or event
+   * destination that receives both platform and connected account events while
+   * the block bills on the platform. Default `handle`.
+   */
+  readonly connectEvents?: "handle" | "ignore";
+}
+/** `customerAccounts` in `createBilling`. */
+interface CustomerAccountOptions {
+  /**
+   * The tenant's existing Accounts v2 account, such as the connected account it
+   * already sells through, or `undefined` to create one. The account needs the
+   * `customer` configuration before Stripe bills it.
+   */
+  readonly resolve?: (tenant: string) => string | undefined | Promise<string | undefined>;
+  /**
+   * More `v2.core.accounts.create` parameters, merged deeply over the block's
+   * (`contact_email`, `display_name`, `configuration.customer` and the tenant
+   * in `metadata.organization_id`), or a function of the tenant and the details
+   * that returns them.
+   */
+  readonly params?: Readonly<Record<string, unknown>> | ((tenant: string, details: CustomerDetails) => Readonly<Record<string, unknown>>);
 }
 interface CustomerDetails {
   readonly email?: string;
@@ -129,6 +163,8 @@ interface SubscriptionItem {
 }
 interface BillingStatus {
   readonly customerId: string | undefined;
+  /** The tenant's Accounts v2 account, when it is billed as one. */
+  readonly accountId: string | undefined;
   readonly seats: number;
   readonly subscription: SubscriptionItem | undefined;
 }
@@ -142,6 +178,8 @@ interface SeatSync {
 interface StripeEvent {
   readonly id: string;
   readonly type: string;
+  /** The connected account a Connect event happened on. */
+  readonly account?: string | null;
   /** Unix seconds; orders subscription events in webhook mode. */
   readonly created?: number;
   readonly data: {
@@ -153,6 +191,8 @@ interface StripeEventOutcome {
   readonly event: BlockEventType<BillingEvents> | undefined;
   readonly organizationId: string | undefined;
   readonly customerId: string | undefined;
+  /** The event object's `customer_account`, for a tenant billed as an account. */
+  readonly accountId: string | undefined;
   /** Members whose sessions were invalidated. */
   readonly invalidated: readonly string[];
 }
@@ -211,16 +251,34 @@ interface BillingCustomerUpdate {
 interface Billing {
   /** The tenant's Stripe customer, or `undefined` before the first checkout. */
   customer(organizationId: string): AsyncResult<string | undefined>;
+  /**
+   * The tenant's Stripe Accounts v2 account (`acct_`), or `undefined` when it
+   * is not billed as one.
+   */
+  account(organizationId: string): AsyncResult<string | undefined>;
   /**
    * The tenant's customer, created in Stripe (with the tenant in `metadata`)
-   * when there is none.
+   * when there is none. With `customerAccounts`, a tenant without a customer
+   * gets its account instead, and this fails with `not_found`
+   * (`BILLING_CUSTOMER_PENDING`) until Stripe creates the account's customer at
+   * the first checkout.
    */
   ensureCustomer(organizationId: string, details?: CustomerDetails): AsyncResult<string>;
+  /**
+   * The tenant's Accounts v2 account: the linked one, the one
+   * `customerAccounts.resolve` returns, or a new one with the `customer`
+   * configuration (and the tenant in `metadata`), which it links.
+   */
+  ensureAccount(organizationId: string, details?: CustomerDetails): AsyncResult<string>;
   checkout(organizationId: string, options: CheckoutOptions): AsyncResult<{
     readonly id: string;
     readonly url: string | undefined;
   }>;
-  /** A customer portal session; `not_found` before the tenant has a customer. */
+  /**
+   * A customer portal session, for the tenant's account with
+   * `customerAccounts`; `not_found` before the tenant has a customer or an
+   * account.
+   */
   portal(organizationId: string, options: {
     readonly returnUrl: string;
   }): AsyncResult<{
@@ -320,8 +378,9 @@ interface Billing {
   updateCustomer(organizationId: string, update: BillingCustomerUpdate): AsyncResult<string>;
   /**
    * Handles `checkout.session.completed` and `customer.subscription.*`: links
-   * the customer, emits `billing.*` events and invalidates sessions. Other
-   * events are ignored. Call it from `inbox.process`.
+   * the customer, emits `billing.*` events and invalidates sessions. Any other
+   * event with a `customer_account` of a linked tenant records the account's
+   * customer; other events are ignored. Call it from `inbox.process`.
    */
   handleStripeEvent(event: unknown): AsyncResult<StripeEventOutcome>;
 }
@@ -337,4 +396,4 @@ export declare function createBilling(options: BillingOptions): Billing;
 /** The `billing` block's manifest (ADR 0029). */
 export declare const billingBlock: BlockOf<"billing", typeof createBilling, BillingEvents>;
 //#endregion
-export { type Billing, type BillingCustomer, type BillingCustomerUpdate, type BillingEventData, type BillingEvents, type BillingOptions, type BillingStatus, type BlockTransport, type CheckoutItem, type CheckoutOptions, type CheckoutStarted, type CustomerDetails, type PlanCatalog, type PlanChange, type PlanOption, type PlanPickerActions, type PlanPickerController, type PlanPickerControllerOptions, type PlanPickerSnapshot, type PlatformListOptions, type SeatSync, type StripeClient, type StripeEvent, type StripeEventOutcome, type StripeRow, type StripeSource, type StripeTaxId, type SubscriptionItem, type TenantStripeRow, createPlanPickerController, dbTransport, rpcTransport, signStripeWebhook, sqlTransport, stripeInboxVerify, verifyStripeWebhook };
+export { type Billing, type BillingCustomer, type BillingCustomerUpdate, type BillingEventData, type BillingEvents, type BillingOptions, type BillingStatus, type BlockTransport, type CheckoutItem, type CheckoutOptions, type CheckoutStarted, type CustomerAccountOptions, type CustomerDetails, type PlanCatalog, type PlanChange, type PlanOption, type PlanPickerActions, type PlanPickerController, type PlanPickerControllerOptions, type PlanPickerSnapshot, type PlatformListOptions, type SeatSync, type StripeClient, type StripeEvent, type StripeEventOutcome, type StripeRow, type StripeSource, type StripeTaxId, type SubscriptionItem, type TenantStripeRow, createPlanPickerController, dbTransport, rpcTransport, signStripeWebhook, sqlTransport, stripeInboxVerify, verifyStripeWebhook };