better-supabase 0.13.0 → 0.14.0

package/dist/blocks/leases/index.js

@@ -0,0 +1,319 @@
+import { n as dbError } from "../../errors-03ysrOt4.js";
+import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
+import { t as AsyncResult } from "../../result-B3m7xtRY.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as leasesSqlOptions } from "../../options-DWML05Cp.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 blockFields } from "../../block-fields-DBSJSeaO.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/leases/leases.ts
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+function dateOf(value) {
+	return temporal().PlainDate.from(textOf(value));
+}
+function optionalDate(value) {
+	const text = optionalText(value);
+	return text === void 0 ? void 0 : temporal().PlainDate.from(text);
+}
+function optionalInstant(value, field) {
+	return value === null || value === void 0 ? void 0 : requiredInstant(value, field);
+}
+function metadataOf(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+function leaseOf(value, fn) {
+	const row = recordOf(value, fn);
+	const currency = row["currency"];
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		unitId: textOf(row["unitId"]),
+		party: {
+			type: textOf(row["partyType"]),
+			id: textOf(row["partyId"])
+		},
+		title: textOf(row["title"]),
+		status: textOf(row["status"]),
+		startsOn: dateOf(row["startsOn"]),
+		rent: moneyOf(row["rent"], currency, "rent"),
+		frequency: textOf(row["frequency"]),
+		deposit: moneyOf(row["deposit"], currency, "deposit"),
+		depositHeld: moneyOf(row["depositHeld"], currency, "depositHeld"),
+		balanceDue: moneyOf(row["balanceDue"], currency, "balanceDue"),
+		metadata: metadataOf(row["metadata"]),
+		fields: isRecord(row["fields"]) ? row["fields"] : {},
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("endsOn", optionalDate(row["endsOn"])),
+		...optional("depositHoldId", optionalText(row["depositHoldId"])),
+		...optional("renewedAt", optionalInstant(row["renewedAt"], "renewedAt")),
+		...optional("terminatedOn", optionalDate(row["terminatedOn"])),
+		...optional("terminationReason", optionalText(row["terminationReason"])),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function chargeOf(value) {
+	const row = recordOf(value, "list_lease_charges");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		leaseId: textOf(row["leaseId"]),
+		periodStart: dateOf(row["periodStart"]),
+		periodEnd: dateOf(row["periodEnd"]),
+		amount: moneyOf(row["amount"], row["currency"], "amount"),
+		transactionId: textOf(row["transactionId"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt")
+	};
+}
+function maintenanceOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		unitId: textOf(row["unitId"]),
+		title: textOf(row["title"]),
+		priority: textOf(row["priority"]),
+		status: textOf(row["status"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("leaseId", optionalText(row["leaseId"])),
+		...optional("description", optionalText(row["description"])),
+		...optional("reportedBy", optionalText(row["reportedBy"])),
+		...optional("assigneeId", optionalText(row["assigneeId"])),
+		...optional("resolvedAt", optionalInstant(row["resolvedAt"], "resolvedAt"))
+	};
+}
+/** The `leases` SQL module as typed calls. */
+function createLeases(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const tenant = () => requireTenant(options.tenant);
+	const lease = (fn) => (value) => leaseOf(value, fn);
+	const fields = blockFields(options.fields, "lease fields");
+	return withBlockHooks({
+		create: (input) => {
+			if (input.deposit !== void 0 && input.deposit.currency !== input.rent.currency) return AsyncResult.err(dbError("invalid_input", "the deposit is in the rent's currency", { hint: "LEASE_TERMS_INVALID" }));
+			return fields.args(input.fields).andThen((checked) => tenant().andThen((organizationId) => call("create_lease", {
+				tenant: organizationId,
+				unit_id: input.unitId,
+				party_type: input.party.type,
+				party_id: input.party.id,
+				starts_on: input.startsOn.toString(),
+				rent: amountText(input.rent),
+				currency: input.rent.currency,
+				frequency: input.frequency ?? "monthly",
+				ends_on: input.endsOn?.toString() ?? null,
+				deposit: input.deposit ? amountText(input.deposit) : "0",
+				title: input.title ?? null,
+				metadata: input.metadata ?? null,
+				...checked === void 0 ? {} : { fields: checked }
+			}, lease("create_lease")).andThen(fields.row)));
+		},
+		activate: (leaseId) => call("activate_lease", { lease_id: leaseId }, lease("activate_lease")).andThen(fields.row),
+		renew: (leaseId, renewal) => call("renew_lease", {
+			lease_id: leaseId,
+			ends_on: renewal.endsOn.toString(),
+			rent: renewal.rent ? amountText(renewal.rent) : null
+		}, lease("renew_lease")).andThen(fields.row),
+		terminate: (leaseId, termination = {}) => call("terminate_lease", {
+			lease_id: leaseId,
+			terminates_on: termination.on?.toString() ?? null,
+			reason: termination.reason ?? null,
+			deposit_deduction: termination.depositDeduction ? amountText(termination.depositDeduction) : "0"
+		}, lease("terminate_lease")).andThen(fields.row),
+		get: (leaseId) => call("get_lease", { lease_id: leaseId }, lease("get_lease")).andThen(fields.row),
+		list: (list = {}) => tenant().andThen((organizationId) => call("list_leases", {
+			tenant: organizationId,
+			status: list.status ?? null,
+			unit_id: list.unitId ?? null,
+			party_type: list.party?.type ?? null,
+			party_id: list.party?.id ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_leases").map(lease("list_leases"))).andThen(fields.rows)),
+		postDueRent: (post = {}) => tenant().andThen((organizationId) => call("post_due_rent", {
+			tenant: organizationId,
+			through: post.through?.toString() ?? null,
+			max_rows: post.maxRows ?? null
+		}, (value) => {
+			const count = Number(value);
+			if (!Number.isInteger(count)) throw new TypeError("post_due_rent did not return a count");
+			return count;
+		})),
+		recordPayment: (leaseId, payment) => call("record_rent_payment", {
+			lease_id: leaseId,
+			amount: amountText(payment.amount),
+			paid_at: instantArg(payment.paidAt) ?? null,
+			reference: payment.reference ?? null
+		}, (value) => {
+			const row = recordOf(value, "record_rent_payment");
+			return {
+				transactionId: textOf(row["transactionId"]),
+				leaseId: textOf(row["leaseId"]),
+				amount: moneyOf(row["amount"], row["currency"], "amount"),
+				balanceDue: moneyOf(row["balanceDue"], row["currency"], "balanceDue")
+			};
+		}),
+		charges: (leaseId, list = {}) => call("list_lease_charges", {
+			lease_id: leaseId,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_lease_charges").map(chargeOf)),
+		fileMaintenance: (input) => tenant().andThen((organizationId) => call("file_maintenance_request", {
+			tenant: organizationId,
+			unit_id: input.unitId,
+			title: input.title,
+			description: input.description ?? null,
+			priority: input.priority ?? "normal",
+			lease_id: input.leaseId ?? null
+		}, (value) => maintenanceOf(value, "file_maintenance_request"))),
+		updateMaintenance: (requestId, update) => call("update_maintenance_request", {
+			request_id: requestId,
+			status: update.status ?? null,
+			priority: update.priority ?? null,
+			assignee_id: update.assigneeId ?? null
+		}, (value) => maintenanceOf(value, "update_maintenance_request")),
+		listMaintenance: (list = {}) => tenant().andThen((organizationId) => call("list_maintenance_requests", {
+			tenant: organizationId,
+			unit_id: list.unitId ?? null,
+			lease_id: list.leaseId ?? null,
+			status: list.status ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_maintenance_requests").map((row) => maintenanceOf(row, "list_maintenance_requests"))))
+	}, options.hooks, {
+		block: "leases",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/leases/events.ts
+/** The `leases` block's event types, for its manifest and `onBlockEvent`. */
+const leasesEvents = defineEvents({
+	"lease.created": event(),
+	"lease.activated": event(),
+	"lease.renewed": event(),
+	"lease.terminated": event(),
+	"lease.charged": event(),
+	"lease.paid": event(),
+	"maintenance_request.filed": event(),
+	"maintenance_request.updated": event()
+});
+//#endregion
+//#region src/blocks/leases/schemas.ts
+/** What `create` takes, with the bounds the SQL checks. */
+const leaseInputSchema = entitySchema({
+	title: "LeaseInput",
+	fields: {
+		unitId: {
+			kind: "uuid",
+			description: "The asset let."
+		},
+		party: {
+			kind: "json",
+			description: "The party renting the unit: `{ type, id }`."
+		},
+		startsOn: { kind: "plainDate" },
+		endsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		rent: moneyField,
+		frequency: {
+			kind: "enum",
+			values: [
+				"weekly",
+				"monthly",
+				"quarterly",
+				"yearly"
+			],
+			optional: true
+		},
+		deposit: {
+			...moneyField,
+			optional: true
+		},
+		title: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 200
+		},
+		metadata: {
+			kind: "json",
+			optional: true
+		},
+		fields: {
+			kind: "json",
+			optional: true,
+			description: "The extra columns to set."
+		}
+	}
+});
+/** What `fileMaintenance` takes. */
+const maintenanceRequestInputSchema = entitySchema({
+	title: "MaintenanceRequestInput",
+	fields: {
+		unitId: { kind: "uuid" },
+		title: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 5e3
+		},
+		priority: {
+			kind: "enum",
+			values: [
+				"low",
+				"normal",
+				"high",
+				"urgent"
+			],
+			optional: true
+		},
+		leaseId: {
+			kind: "uuid",
+			optional: true
+		}
+	}
+});
+//#endregion
+//#region src/blocks/leases/section.ts
+/** A party's leases, such as a contact's, with rent due and deposits held. */
+const leasesSection = defineSection({
+	permissions: {
+		read: "read",
+		write: "manage"
+	},
+	module: "leases",
+	load: (client, subject) => client.list({ party: subject }),
+	events: ["lease.*"]
+});
+//#endregion
+//#region src/blocks/leases/manifest.ts
+/** The `leases` block's manifest (ADR 0029). */
+const leasesBlock = defineBlock({
+	name: "leases",
+	sql: ["leases"],
+	options: { leases: leasesSqlOptions },
+	events: leasesEvents,
+	schemas: {
+		lease: { input: leaseInputSchema },
+		maintenance_request: { input: maintenanceRequestInputSchema }
+	},
+	create: createLeases,
+	sections: { leases: leasesSection },
+	category: "commerce"
+});
+//#endregion
+export { createLeases, dbTransport, extendBlock, leaseInputSchema, leasesBlock, leasesEvents, leasesSection, maintenanceRequestInputSchema, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -1,13 +1,13 @@
 /// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "../../result-mijqfoJN.js";
-import { t as StandardSchemaV1 } from "../../standard-16AIDny5.js";
-import { n as ExtraFields, r as FieldsOf } from "../../block-fields-DnXkMney.js";
-import { wt as Events } from "../../events-DhGgwqQA.js";
+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 { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-DyA5BAW4.js";
-import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BadAniNI.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.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 } from "../../define-block-COpcS6aT.js";
 //#region src/blocks/leave/leave.d.ts
 interface LeaveOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
   readonly transport: BlockTransport;

package/dist/blocks/leave/index.js

@@ -1,12 +1,11 @@
-import { t as temporal } from "../../temporal-required-Dt4mcPsi.js";
+import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
 import { t as leaveSqlOptions } from "../../options-BesyRBnM.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, 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 event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-Ds0C2mUf.js";
-import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-DwE32_gT.js";
-import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-C1r-R2r0.js";
-import { n as blockFields } from "../../block-fields-Cwd4c8m-.js";
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { n as blockFields } from "../../block-fields-DBSJSeaO.js";
+import { n as defineBlock } from "../../define-block-Dze77QTw.js";
 //#region src/blocks/leave/leave.ts
 const UNITS = ["days", "hours"];
 const PARTIALS = [

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

@@ -0,0 +1,281 @@
+/// <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 { Lt as Section, c as BlockOf } from "../../define-block-COpcS6aT.js";
+import { n as Money } from "../../money-BNRdJQzA.js";
+//#region src/blocks/ledger/ledger.d.ts
+interface LedgerOptions 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<Ledger>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * An account. Amounts are integers in the account's unit: minor units for an
+ * ISO 4217 currency, or a custom unit (`item`, `days`, `points`) at `scale`
+ * decimal places.
+ */
+interface LedgerAccount {
+  readonly id: string;
+  readonly organizationId: string;
+  /** What the account is for: `credit`, `stock`, `receivable`, `points`. */
+  readonly kind: string;
+  /** Unique in the organization. */
+  readonly code: string;
+  readonly name: string;
+  readonly unit: string;
+  readonly scale: number;
+  /** The record the account belongs to, such as a party or a variant. */
+  readonly holderType?: string;
+  readonly holderId?: string;
+  /** The member who can read the account without a permission. */
+  readonly ownerId?: string;
+  readonly allowNegative: boolean;
+  /** A permission key that also grants reading the account. */
+  readonly readPermission?: string;
+  /** The module that posts to the account; apps can't post to it directly. */
+  readonly managedBy?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly balance: bigint;
+  /** Held by active holds. */
+  readonly held: bigint;
+  /** The balance less what is held. */
+  readonly available: bigint;
+  readonly closedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+interface LedgerAccountInput {
+  readonly kind: string;
+  readonly code: string;
+  readonly name: string;
+  /** An ISO 4217 code, or a lowercase custom unit. */
+  readonly unit: string;
+  /** Decimal places of a custom unit. Default 0. */
+  readonly scale?: number;
+  readonly holder?: {
+    readonly type: string;
+    readonly id: string;
+  };
+  readonly ownerId?: string;
+  /** Default `false`: postings can't take the available balance below zero. */
+  readonly allowNegative?: boolean;
+  readonly readPermission?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** One side of a transaction. A `Money` must be in the account's currency. */
+interface LedgerLine {
+  readonly accountId: string;
+  /** Signed: positive adds to the account, negative takes from it. */
+  readonly amount: bigint | Money;
+}
+interface LedgerEntry {
+  readonly id: string;
+  readonly accountId: string;
+  readonly amount: bigint;
+  readonly unit: string;
+}
+interface LedgerTransaction {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly kind: string;
+  readonly referenceType?: string;
+  readonly referenceId?: string;
+  readonly memo?: string;
+  readonly idempotencyKey?: string;
+  /** The transaction this one reverses. */
+  readonly reverses?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly effectiveAt: Temporal.Instant;
+  readonly actorId?: string;
+  readonly createdAt: Temporal.Instant;
+  /** Balanced per unit. */
+  readonly entries: readonly LedgerEntry[];
+}
+interface LedgerTransactionInput {
+  /** Lowercase with dots, such as `credit.grant`. */
+  readonly kind: string;
+  /** At least two lines that sum to zero per unit. */
+  readonly lines: readonly LedgerLine[];
+  readonly reference?: {
+    readonly type: string;
+    readonly id: string;
+  };
+  readonly memo?: string;
+  /** A second post with the same key returns the first transaction. */
+  readonly idempotencyKey?: string;
+  /** Default: now. */
+  readonly effectiveAt?: Temporal.Instant;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** An entry on one account, with its transaction. */
+interface LedgerAccountEntry extends LedgerEntry {
+  readonly transactionId: string;
+  readonly kind: string;
+  readonly referenceType?: string;
+  readonly referenceId?: string;
+  readonly memo?: string;
+  readonly reverses?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly effectiveAt: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+type LedgerHoldStatus = "active" | "captured" | "released" | "expired";
+interface LedgerHold {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly accountId: string;
+  readonly amount: bigint;
+  readonly status: LedgerHoldStatus;
+  readonly referenceType?: string;
+  readonly referenceId?: string;
+  readonly expiresAt?: Temporal.Instant;
+  /** The capture's transaction. */
+  readonly transactionId?: string;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface LedgerHoldInput {
+  readonly amount: bigint | Money;
+  readonly reference?: {
+    readonly type: string;
+    readonly id: string;
+  };
+  readonly expiresAt?: Temporal.Instant;
+}
+interface LedgerCaptureInput {
+  /** The account that receives the captured amount. */
+  readonly toAccountId: string;
+  /** Default: the whole hold. A partial capture releases the rest. */
+  readonly amount?: bigint | Money;
+  /** Default `ledger.capture`. */
+  readonly kind?: string;
+  readonly memo?: string;
+}
+interface LedgerAccountListOptions {
+  readonly kind?: string;
+  readonly holder?: {
+    readonly type: string;
+    readonly id: string;
+  };
+  readonly pageSize?: number;
+}
+interface Ledger {
+  /** Opens an account in the block's tenant. Needs `ledger.manage`. */
+  openAccount(input: LedgerAccountInput): AsyncResult<LedgerAccount>;
+  /** Needs `ledger.manage`; the balance must be zero with no active holds. */
+  closeAccount(accountId: string): AsyncResult<LedgerAccount>;
+  /** The tenant's accounts the caller can read, by kind or holder. */
+  accounts(options?: LedgerAccountListOptions): AsyncResult<readonly LedgerAccount[]>;
+  /**
+   * A record's accounts the caller can read, such as a party's credits. The
+   * record decides the tenant.
+   */
+  holderAccounts(holder: SubjectRef, options?: {
+    readonly kind?: string;
+  }): AsyncResult<readonly LedgerAccount[]>;
+  /** Newest first; `before` pages back. */
+  entries(accountId: string, options?: {
+    readonly before?: Temporal.Instant;
+    readonly pageSize?: number;
+  }): AsyncResult<readonly LedgerAccountEntry[]>;
+  transaction(transactionId: string): AsyncResult<LedgerTransaction>;
+  /**
+   * Posts a balanced transaction in the block's tenant. Needs `ledger.post`;
+   * accounts another module manages refuse it.
+   */
+  post(input: LedgerTransactionInput): AsyncResult<LedgerTransaction>;
+  /** Posts the opposite entries. A transaction reverses once. */
+  reverse(transactionId: string, options?: {
+    readonly memo?: string;
+  }): AsyncResult<LedgerTransaction>;
+  /** Reserves part of the available balance. Needs `ledger.post`. */
+  hold(accountId: string, input: LedgerHoldInput): AsyncResult<LedgerHold>;
+  /** Moves held funds to another account. */
+  capture(holdId: string, input: LedgerCaptureInput): AsyncResult<LedgerHold>;
+  release(holdId: string): AsyncResult<LedgerHold>;
+}
+/** An account's balance as `Money`, or `undefined` for a custom unit. */
+export declare function ledgerMoney(account: Pick<LedgerAccount, "unit" | "balance">, amount?: bigint): Money | undefined;
+/** The `ledger` SQL module as typed calls. */
+export declare function createLedger(options: LedgerOptions): Ledger;
+//#endregion
+//#region src/blocks/ledger/events.d.ts
+/** `ledger_account.opened` and `ledger_account.closed`. */
+interface LedgerAccountEventData {
+  readonly organizationId: string;
+  /** The account. */
+  readonly id: string;
+  /** What the account is for, such as `credit`, `stock` or `leave`. */
+  readonly kind: string;
+  /** Unique per organization, such as `credit:<party id>`. */
+  readonly code: string;
+  /** An ISO 4217 code, or a custom unit such as `item`, `days` or `points`. */
+  readonly unit: string;
+  /** Who or what the account belongs to, when it says. */
+  readonly holderType: string | null;
+  readonly holderId: string | null;
+}
+/** `ledger_transaction.posted` and `ledger_transaction.reversed`. */
+interface LedgerTransactionEventData {
+  readonly organizationId: string;
+  /** The transaction. */
+  readonly id: string;
+  /** What the transaction records, such as `stock.sale` or `credit.grant`. */
+  readonly kind: string;
+  readonly referenceType: string | null;
+  readonly referenceId: string | null;
+  /** The transaction this one reverses, when it does. */
+  readonly reverses: string | null;
+  /** How many entries the transaction has (two or more). */
+  readonly entries: number;
+}
+/** `ledger_hold.placed`, `ledger_hold.captured` and `ledger_hold.released`. */
+interface LedgerHoldEventData {
+  readonly organizationId: string;
+  /** The hold. */
+  readonly id: string;
+  readonly accountId: string;
+  /** In the account's unit, as text. */
+  readonly amount: string;
+  /** `active`, `captured`, `released` or `expired`. */
+  readonly status: string;
+  /** The transaction a capture posted. */
+  readonly transactionId: string | null;
+}
+/** The events of the `ledger` block: type to data. */
+type LedgerEvents = {
+  readonly "ledger_account.opened": LedgerAccountEventData;
+  readonly "ledger_account.closed": LedgerAccountEventData;
+  readonly "ledger_transaction.posted": LedgerTransactionEventData;
+  readonly "ledger_transaction.reversed": LedgerTransactionEventData;
+  readonly "ledger_hold.placed": LedgerHoldEventData;
+  readonly "ledger_hold.captured": LedgerHoldEventData;
+  readonly "ledger_hold.released": LedgerHoldEventData;
+};
+/** The `ledger` block's event types, for its manifest and `onBlockEvent`. */
+export declare const ledgerEvents: Events<LedgerEvents>;
+//#endregion
+//#region src/blocks/ledger/section.d.ts
+/** A record's ledger accounts with their balances: credits, points, stock. */
+export declare const ledgerSection: Section<Ledger, readonly LedgerAccount[]>;
+//#endregion
+//#region src/blocks/ledger/manifest.d.ts
+/** The `ledger` block's manifest (ADR 0029). */
+export declare const ledgerBlock: BlockOf<"ledger", typeof createLedger, LedgerEvents, Record<never, never>, never, {
+  readonly ledger: typeof ledgerSection;
+}>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Ledger, type LedgerAccount, type LedgerAccountEntry, type LedgerAccountEventData, type LedgerAccountInput, type LedgerAccountListOptions, type LedgerCaptureInput, type LedgerEntry, type LedgerEvents, type LedgerHold, type LedgerHoldEventData, type LedgerHoldInput, type LedgerHoldStatus, type LedgerLine, type LedgerOptions, type LedgerTransaction, type LedgerTransactionEventData, type LedgerTransactionInput, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };