better-supabase 0.13.0 → 0.14.0

package/dist/blocks/donations/index.js

@@ -0,0 +1,602 @@
+import { n as dbError } from "../../errors-03ysrOt4.js";
+import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-B3m7xtRY.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as donationsSqlOptions } from "../../options-t_O5ldT6.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, 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";
+import { n as paymentProviderOf } from "../../payments-BtScsgPS.js";
+//#region src/blocks/donations/donations.ts
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const failure = (hint, message) => dbError("invalid_request", message, { hint });
+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 optionalMoney(value, currency, field) {
+	return value === null || value === void 0 ? void 0 : moneyOf(value, currency, field);
+}
+function fundOf(value, fn) {
+	const row = recordOf(value, fn);
+	const currency = row["currency"];
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		key: textOf(row["key"]),
+		name: textOf(row["name"]),
+		kind: textOf(row["kind"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("goal", optionalMoney(row["goal"], currency, "goal")),
+		...optional("raised", optionalMoney(row["raised"], currency, "raised")),
+		...optional("startsOn", optionalDate(row["startsOn"])),
+		...optional("endsOn", optionalDate(row["endsOn"])),
+		...optional("archivedAt", optionalInstant(row["archivedAt"], "archivedAt"))
+	};
+}
+function giftOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		donor: {
+			type: textOf(row["donorType"]),
+			id: textOf(row["donorId"])
+		},
+		amount: moneyOf(row["amount"], row["currency"], "amount"),
+		receivedOn: dateOf(row["receivedOn"]),
+		status: textOf(row["status"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("fundId", optionalText(row["fundId"])),
+		...optional("pledgeId", optionalText(row["pledgeId"])),
+		...optional("periodStart", optionalDate(row["periodStart"])),
+		...optional("method", optionalText(row["method"])),
+		...optional("provider", optionalText(row["provider"])),
+		...optional("paymentReference", optionalText(row["paymentReference"])),
+		...optional("transactionId", optionalText(row["transactionId"])),
+		...optional("refundTransactionId", optionalText(row["refundTransactionId"])),
+		...optional("receiptId", optionalText(row["receiptId"])),
+		...optional("note", optionalText(row["note"])),
+		...optional("createdBy", optionalText(row["createdBy"])),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function pledgeOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		donor: {
+			type: textOf(row["donorType"]),
+			id: textOf(row["donorId"])
+		},
+		amount: moneyOf(row["amount"], row["currency"], "amount"),
+		frequency: textOf(row["frequency"]),
+		startsOn: dateOf(row["startsOn"]),
+		status: textOf(row["status"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("fundId", optionalText(row["fundId"])),
+		...optional("endsOn", optionalDate(row["endsOn"])),
+		...optional("provider", optionalText(row["provider"])),
+		...optional("providerCustomer", optionalText(row["providerCustomer"])),
+		...optional("note", optionalText(row["note"])),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function installmentOf(value) {
+	const row = recordOf(value, "due_pledge_installments");
+	return {
+		pledgeId: textOf(row["pledgeId"]),
+		periodStart: dateOf(row["periodStart"]),
+		donor: {
+			type: textOf(row["donorType"]),
+			id: textOf(row["donorId"])
+		},
+		amount: moneyOf(row["amount"], row["currency"], "amount"),
+		...optional("fundId", optionalText(row["fundId"])),
+		...optional("provider", optionalText(row["provider"])),
+		...optional("providerCustomer", optionalText(row["providerCustomer"]))
+	};
+}
+function receiptOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		donor: {
+			type: textOf(row["donorType"]),
+			id: textOf(row["donorId"])
+		},
+		sequence: BigInt(textOf(row["sequence"])),
+		number: textOf(row["number"]),
+		kind: textOf(row["kind"]),
+		year: Number(row["year"]),
+		amount: moneyOf(row["amount"], row["currency"], "amount"),
+		issuedAt: requiredInstant(row["issuedAt"], "issuedAt"),
+		...optional("voidedAt", optionalInstant(row["voidedAt"], "voidedAt")),
+		...optional("voidReason", optionalText(row["voidReason"]))
+	};
+}
+function summaryOf(value) {
+	const fn = "yearly_giving_summary";
+	const row = recordOf(value, fn);
+	return {
+		year: Number(row["year"]),
+		donor: {
+			type: textOf(row["donorType"]),
+			id: textOf(row["donorId"])
+		},
+		totals: recordsOf(row["totals"] ?? [], fn).map((total) => ({
+			amount: moneyOf(total["amount"], total["currency"], "amount"),
+			gifts: Number(total["gifts"])
+		})),
+		funds: recordsOf(row["funds"] ?? [], fn).map((fund) => ({
+			name: textOf(fund["name"]),
+			amount: moneyOf(fund["amount"], fund["currency"], "amount"),
+			...optional("fundId", optionalText(fund["fundId"]))
+		})),
+		receipts: recordsOf(row["receipts"] ?? [], fn).map((receipt) => receiptOf(receipt, fn))
+	};
+}
+/** How a provider payment status moves a gift. */
+function giftPaymentStatus(status) {
+	switch (status) {
+		case "succeeded": return "succeeded";
+		case "failed":
+		case "canceled": return "failed";
+		case "requires_action":
+		case "processing":
+		case "authorized": return "pending";
+		default: throw new TypeError(`unknown payment status ${String(status)}`);
+	}
+}
+/** The `donations` SQL module as typed calls. */
+function createDonations(options) {
+	applyTemporal(options);
+	const payments = options.payments ? paymentProviderOf(options.payments) : void 0;
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const tenant = () => requireTenant(options.tenant);
+	const fields = blockFields(options.fields, "gift fields");
+	const gift = (fn) => (value) => giftOf(value, fn);
+	const fund = (fn) => (value) => fundOf(value, fn);
+	const pledge = (fn) => (value) => pledgeOf(value, fn);
+	const receipt = (fn) => (value) => receiptOf(value, fn);
+	const recordGiftPayment = (giftId, provider, paymentId, status) => service("record_gift_payment", {
+		gift_id: giftId,
+		provider,
+		payment_id: paymentId,
+		status
+	}, gift("record_gift_payment")).andThen(fields.row);
+	const dueInstallments = (organizationId, due) => service("due_pledge_installments", {
+		tenant: organizationId,
+		through: due.through?.toString() ?? null,
+		max_rows: due.maxRows ?? null
+	}, (value) => recordsOf(value, "due_pledge_installments").map(installmentOf));
+	const chargeInstallment = async (provider, organizationId, installment) => {
+		const opened = await service("open_gift", {
+			tenant: organizationId,
+			donor_type: installment.donor.type,
+			donor_id: installment.donor.id,
+			amount: amountText(installment.amount),
+			currency: installment.amount.currency,
+			fund_id: installment.fundId ?? null,
+			pledge_id: installment.pledgeId,
+			period_start: installment.periodStart.toString(),
+			provider: provider.name,
+			note: null
+		}, gift("open_gift"));
+		if (!opened.ok) return {
+			kind: "failed",
+			installment,
+			error: opened.error
+		};
+		const charged = await provider.createPayment({
+			amount: installment.amount,
+			reference: opened.data.id,
+			...installment.providerCustomer === void 0 ? {} : { customer: installment.providerCustomer },
+			description: `Pledge installment from ${installment.periodStart.toString()}`,
+			metadata: {
+				giftId: opened.data.id,
+				pledgeId: installment.pledgeId,
+				periodStart: installment.periodStart.toString()
+			}
+		}, { idempotencyKey: `pledge:${installment.pledgeId}:${installment.periodStart.toString()}` });
+		if (!charged.ok) {
+			if (charged.error.hint !== "PAYMENT_DECLINED") return {
+				kind: "failed",
+				installment,
+				error: charged.error
+			};
+			const declined = await recordGiftPayment(opened.data.id, provider.name, null, "failed");
+			return {
+				kind: "failed",
+				installment,
+				error: declined.ok ? charged.error : declined.error
+			};
+		}
+		const stored = await recordGiftPayment(opened.data.id, provider.name, charged.data.id, giftPaymentStatus(charged.data.status));
+		return stored.ok ? {
+			kind: "charged",
+			installment,
+			gift: stored.data
+		} : {
+			kind: "failed",
+			installment,
+			error: stored.error
+		};
+	};
+	const handlePaymentEvent = (event) => AsyncResult.from(async () => {
+		if (event.type === "refund.failed") return ok({
+			event: event.id,
+			kind: "ignored",
+			reason: "refund failed"
+		});
+		const status = event.type === "refund.succeeded" ? "refunded" : event.type === "payment.succeeded" ? "succeeded" : event.type === "payment.failed" || event.type === "payment.canceled" ? "failed" : "pending";
+		const giftId = status !== "refunded" && event.reference !== void 0 && UUID.test(event.reference) ? event.reference : null;
+		const stored = await recordGiftPayment(giftId, payments?.name ?? "unknown", event.paymentId, status);
+		if (!stored.ok) return stored.error.hint === "DONATION_NOT_FOUND" ? ok({
+			event: event.id,
+			kind: "ignored",
+			reason: "unknown gift"
+		}) : stored;
+		return ok({
+			event: event.id,
+			kind: "gift",
+			gift: stored.data
+		});
+	});
+	return withBlockHooks({
+		saveFund: (input) => tenant().andThen((organizationId) => call("save_donation_fund", {
+			tenant: organizationId,
+			key: input.key,
+			name: input.name,
+			kind: input.kind ?? "fund",
+			goal: input.goal ? amountText(input.goal) : null,
+			currency: input.goal?.currency ?? null,
+			starts_on: input.startsOn?.toString() ?? null,
+			ends_on: input.endsOn?.toString() ?? null
+		}, fund("save_donation_fund"))),
+		archiveFund: (fundId) => call("archive_donation_fund", { fund_id: fundId }, fund("archive_donation_fund")),
+		funds: (list = {}) => tenant().andThen((organizationId) => call("list_donation_funds", {
+			tenant: organizationId,
+			include_archived: list.includeArchived ?? false
+		}, (value) => recordsOf(value, "list_donation_funds").map(fund("list_donation_funds")))),
+		recordGift: (input) => fields.args(input.fields).andThen((checked) => tenant().andThen((organizationId) => call("record_gift", {
+			tenant: organizationId,
+			donor_type: input.donor.type,
+			donor_id: input.donor.id,
+			amount: amountText(input.amount),
+			currency: input.amount.currency,
+			fund_id: input.fundId ?? null,
+			received_on: input.receivedOn?.toString() ?? null,
+			method: input.method ?? null,
+			note: input.note ?? null,
+			pledge_id: input.pledgeId ?? null,
+			period_start: input.periodStart?.toString() ?? null,
+			...checked === void 0 ? {} : { fields: checked }
+		}, gift("record_gift")).andThen(fields.row))),
+		give: (input) => AsyncResult.from(async () => {
+			if (!payments) return err(failure("DONATIONS_NO_PAYMENTS", "give needs a payments provider"));
+			const checked = await fields.args(input.fields);
+			if (!checked.ok) return checked;
+			const organizationId = await tenant();
+			if (!organizationId.ok) return organizationId;
+			const opened = await call("open_gift", {
+				tenant: organizationId.data,
+				donor_type: input.donor.type,
+				donor_id: input.donor.id,
+				amount: amountText(input.amount),
+				currency: input.amount.currency,
+				fund_id: input.fundId ?? null,
+				pledge_id: null,
+				period_start: null,
+				provider: payments.name,
+				note: input.note ?? null,
+				...checked.data === void 0 ? {} : { fields: checked.data }
+			}, gift("open_gift"));
+			if (!opened.ok) return opened;
+			const created = await payments.createPayment({
+				amount: input.amount,
+				reference: opened.data.id,
+				...input.customer === void 0 ? {} : { customer: input.customer },
+				description: input.description ?? "Donation",
+				...input.returnUrl === void 0 ? {} : { returnUrl: input.returnUrl },
+				metadata: { giftId: opened.data.id }
+			}, { idempotencyKey: `gift:${opened.data.id}:payment` });
+			if (!created.ok) return created;
+			const stored = await recordGiftPayment(opened.data.id, payments.name, created.data.id, giftPaymentStatus(created.data.status));
+			return stored.ok ? ok({
+				gift: stored.data,
+				payment: created.data
+			}) : stored;
+		}),
+		getGift: (giftId) => call("get_gift", { gift_id: giftId }, gift("get_gift")).andThen(fields.row),
+		gifts: (list = {}) => tenant().andThen((organizationId) => call("list_gifts", {
+			tenant: organizationId,
+			donor_type: list.donor?.type ?? null,
+			donor_id: list.donor?.id ?? null,
+			fund_id: list.fundId ?? null,
+			pledge_id: list.pledgeId ?? null,
+			status: list.status ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_gifts").map(gift("list_gifts"))).andThen(fields.rows)),
+		createPledge: (input) => tenant().andThen((organizationId) => call("create_pledge", {
+			tenant: organizationId,
+			donor_type: input.donor.type,
+			donor_id: input.donor.id,
+			amount: amountText(input.amount),
+			currency: input.amount.currency,
+			frequency: input.frequency ?? "monthly",
+			fund_id: input.fundId ?? null,
+			starts_on: input.startsOn?.toString() ?? null,
+			ends_on: input.endsOn?.toString() ?? null,
+			provider: input.provider ?? null,
+			provider_customer: input.providerCustomer ?? null,
+			note: input.note ?? null
+		}, pledge("create_pledge"))),
+		updatePledge: (pledgeId, update) => call("update_pledge", {
+			pledge_id: pledgeId,
+			status: update.status ?? null,
+			ends_on: update.endsOn?.toString() ?? null,
+			amount: update.amount ? amountText(update.amount) : null
+		}, pledge("update_pledge")),
+		pledges: (list = {}) => tenant().andThen((organizationId) => call("list_pledges", {
+			tenant: organizationId,
+			donor_type: list.donor?.type ?? null,
+			donor_id: list.donor?.id ?? null,
+			status: list.status ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_pledges").map(pledge("list_pledges")))),
+		dueInstallments: (due = {}) => tenant().andThen((organizationId) => dueInstallments(organizationId, due)),
+		chargeDuePledges: (due = {}) => AsyncResult.from(async () => {
+			if (!payments) return err(failure("DONATIONS_NO_PAYMENTS", "charging pledges needs a payments provider"));
+			const organizationId = await tenant();
+			if (!organizationId.ok) return organizationId;
+			const installments = await dueInstallments(organizationId.data, due);
+			if (!installments.ok) return installments;
+			const outcomes = [];
+			for (const installment of installments.data) {
+				if (installment.provider !== payments.name) {
+					outcomes.push({
+						kind: "skipped",
+						installment,
+						reason: installment.provider === void 0 ? "the pledge is recorded by hand" : `the pledge is charged by ${installment.provider}`
+					});
+					continue;
+				}
+				outcomes.push(await chargeInstallment(payments, organizationId.data, installment));
+			}
+			return ok(outcomes);
+		}),
+		handlePaymentEvent,
+		webhook: (input) => AsyncResult.from(async () => {
+			if (!payments) return err(failure("DONATIONS_NO_PAYMENTS", "webhooks need a payments provider"));
+			const parsed = await payments.parseWebhook(input);
+			if (!parsed.ok) return parsed;
+			const outcomes = [];
+			for (const event of parsed.data) {
+				const outcome = await handlePaymentEvent(event);
+				if (!outcome.ok) return outcome;
+				outcomes.push(outcome.data);
+			}
+			return ok(outcomes);
+		}),
+		issueGiftReceipt: (giftId) => call("issue_gift_receipt", { gift_id: giftId }, receipt("issue_gift_receipt")),
+		issueYearlyReceipt: (donor, year, currency) => tenant().andThen((organizationId) => call("issue_yearly_receipt", {
+			tenant: organizationId,
+			donor_type: donor.type,
+			donor_id: donor.id,
+			year,
+			currency
+		}, receipt("issue_yearly_receipt"))),
+		voidReceipt: (receiptId, reason) => call("void_donation_receipt", {
+			receipt_id: receiptId,
+			reason: reason ?? null
+		}, receipt("void_donation_receipt")),
+		receipts: (list = {}) => tenant().andThen((organizationId) => call("list_donation_receipts", {
+			tenant: organizationId,
+			donor_type: list.donor?.type ?? null,
+			donor_id: list.donor?.id ?? null,
+			year: list.year ?? null,
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_donation_receipts").map(receipt("list_donation_receipts")))),
+		givingSummary: (donor, year) => tenant().andThen((organizationId) => call("yearly_giving_summary", {
+			tenant: organizationId,
+			donor_type: donor.type,
+			donor_id: donor.id,
+			year: year ?? null
+		}, summaryOf))
+	}, options.hooks, {
+		block: "donations",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/donations/events.ts
+/** The `donations` block's event types, for its manifest and `onBlockEvent`. */
+const donationsEvents = defineEvents({
+	"donation.received": event(),
+	"donation.failed": event(),
+	"donation.refunded": event(),
+	"pledge.created": event(),
+	"pledge.updated": event(),
+	"donation_receipt.issued": event(),
+	"donation_receipt.voided": event()
+});
+//#endregion
+//#region src/blocks/donations/schemas.ts
+const FREQUENCIES = [
+	"weekly",
+	"monthly",
+	"quarterly",
+	"yearly"
+];
+/** What `recordGift` takes, with the bounds the SQL checks. */
+const giftInputSchema = entitySchema({
+	title: "GiftInput",
+	fields: {
+		donor: {
+			kind: "json",
+			description: "The donor, a registered subject: `{ type, id }`."
+		},
+		amount: moneyField,
+		fundId: {
+			kind: "uuid",
+			optional: true
+		},
+		receivedOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		method: {
+			kind: "string",
+			optional: true,
+			maxLength: 40
+		},
+		note: {
+			kind: "string",
+			optional: true,
+			maxLength: 2e3
+		},
+		pledgeId: {
+			kind: "uuid",
+			optional: true
+		},
+		periodStart: {
+			kind: "plainDate",
+			optional: true
+		},
+		fields: {
+			kind: "json",
+			optional: true,
+			description: "The extra columns to set."
+		}
+	}
+});
+/** What `createPledge` takes. */
+const pledgeInputSchema = entitySchema({
+	title: "PledgeInput",
+	fields: {
+		donor: {
+			kind: "json",
+			description: "The donor, a registered subject: `{ type, id }`."
+		},
+		amount: moneyField,
+		frequency: {
+			kind: "enum",
+			values: FREQUENCIES,
+			optional: true
+		},
+		fundId: {
+			kind: "uuid",
+			optional: true
+		},
+		startsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		endsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		provider: {
+			kind: "string",
+			optional: true,
+			maxLength: 100
+		},
+		providerCustomer: {
+			kind: "string",
+			optional: true,
+			maxLength: 200
+		},
+		note: {
+			kind: "string",
+			optional: true,
+			maxLength: 2e3
+		}
+	}
+});
+/** What `saveFund` takes. */
+const donationFundInputSchema = entitySchema({
+	title: "DonationFundInput",
+	fields: {
+		key: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 63,
+			description: "Lowercase letters, digits and underscores."
+		},
+		name: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		kind: {
+			kind: "enum",
+			values: ["fund", "campaign"],
+			optional: true
+		},
+		goal: {
+			...moneyField,
+			optional: true
+		},
+		startsOn: {
+			kind: "plainDate",
+			optional: true
+		},
+		endsOn: {
+			kind: "plainDate",
+			optional: true
+		}
+	}
+});
+//#endregion
+//#region src/blocks/donations/section.ts
+/** A donor's giving this year, such as a contact's: totals, funds and receipts. */
+const givingSection = defineSection({
+	permissions: {
+		read: "read",
+		write: "manage"
+	},
+	module: "donations",
+	load: (client, subject) => client.givingSummary(subject),
+	events: ["donation.*", "donation_receipt.*"]
+});
+//#endregion
+//#region src/blocks/donations/manifest.ts
+/** The `donations` block's manifest (ADR 0029). */
+const donationsBlock = defineBlock({
+	name: "donations",
+	sql: ["donations"],
+	options: { donations: donationsSqlOptions },
+	events: donationsEvents,
+	schemas: {
+		donation: { input: giftInputSchema },
+		pledge: { input: pledgeInputSchema },
+		donation_fund: { input: donationFundInputSchema }
+	},
+	create: createDonations,
+	sections: { giving: givingSection },
+	category: "commerce"
+});
+//#endregion
+export { createDonations, dbTransport, donationFundInputSchema, donationsBlock, donationsEvents, extendBlock, giftInputSchema, givingSection, pledgeInputSchema, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -1,15 +1,15 @@
 /// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "../../result-mijqfoJN.js";
-import { t as StandardSchemaV1 } from "../../standard-16AIDny5.js";
-import { r as FieldsOf } from "../../block-fields-DnXkMney.js";
-import { R as DriveEventData, 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 { r as FieldsOf } from "../../block-fields-3w4MZr8U.js";
+import { Ct as Events, R as DriveEventData } from "../../events-DbLjvxDX.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-DyA5BAW4.js";
-import { n as BlockHooks } from "../../block-hooks-BadAniNI.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { a as Attachment, f as AttachmentStorage, m as Attachments, s as AttachmentDownload } from "../../ports-BltcWsHf.js";
-import { t as SubjectConfig } from "../../subjects-DQ2SU4cA.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-BaugZlJV.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 { Q as AttachmentDownload, X as Attachment, c as BlockOf, lt as Attachments, ot as AttachmentStorage } from "../../define-block-COpcS6aT.js";
+import { s as ApprovalStatus } from "../../approvals-bMb7dsBY.js";
+import { t as SubjectConfig } from "../../subjects-B6p4oAZJ.js";
 //#region src/blocks/drive/drive.d.ts
 interface DriveOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
   /** The caller's transport (`rpcTransport(supabase)`), so grants apply. */
@@ -81,6 +81,37 @@ interface DriveNode<F extends object = Record<never, never>> {
   readonly role: string | undefined;
   readonly starredAt: Temporal.Instant | undefined;
   readonly openedAt: Temporal.Instant | undefined;
+  /** The tags on the node, with the tags block installed. */
+  readonly labels: readonly DriveLabel[] | undefined;
+  /**
+   * The latest approval request for the file's current version, with the
+   * approvals block installed; `undefined` when there is none.
+   */
+  readonly approval: DriveApprovalState | undefined;
+}
+/** A tag on a node. */
+interface DriveLabel {
+  readonly id: string;
+  readonly name: string;
+  readonly color: string | undefined;
+}
+interface DriveApprovalState {
+  readonly id: string;
+  readonly status: ApprovalStatus;
+  readonly createdAt: Temporal.Instant;
+  readonly decidedAt: Temporal.Instant | undefined;
+}
+/** An approval request for one stored version of a file. */
+interface DriveApproval extends DriveApprovalState {
+  /** The attachment the request is for. */
+  readonly attachmentId: string;
+  /** Its revision number, with the versions block installed. */
+  readonly revision: number | undefined;
+  /** Whether that version is the file's content now. */
+  readonly current: boolean;
+  readonly step: number;
+  readonly reason: string | undefined;
+  readonly requestedBy: string | undefined;
 }
 /** A folder above a node, root first. */
 interface DriveCrumb {
@@ -247,6 +278,20 @@ interface Drive<F extends object = Record<never, never>> {
   link(token: string, options?: {
     readonly nodeId?: string;
   }): AsyncResult<DriveLinkView<F>>;
+  /** Puts a tag on the node as a label, or takes it off (`applied: false`). */
+  label(id: string, tagId: string, applied?: boolean): AsyncResult<DriveNode<F>>;
+  /** The nodes that carry a label and the caller can read, folders first. */
+  labeled(organizationId: string, tagId: string, options?: DrivePage): AsyncResult<readonly DriveNode<F>[]>;
+  /**
+   * Asks for approval of one version of a file: `attachmentId`, or the current
+   * one. The request stays with those bytes.
+   */
+  requestApproval(id: string, options?: {
+    readonly attachmentId?: string;
+    readonly reason?: string;
+  }): AsyncResult<DriveApproval>;
+  /** The file's approval requests, newest first. */
+  approvals(id: string): AsyncResult<readonly DriveApproval[]>;
   /**
    * Service role: deletes revisions' files no revision or node uses any more,
    * and removes their objects through `storage`.
@@ -310,4 +355,4 @@ export declare const driveBlock: BlockOf<"drive", typeof createDrive, DriveEvent
   readonly attachments: "optional";
 }>;
 //#endregion
-export { type BlockTransport, type Drive, type DriveBatch, type DriveBinEntry, type DriveConflict, type DriveCrumb, type DriveEvents, type DriveFile, type DriveFileType, type DriveGrant, type DriveLinkView, type DriveNode, type DriveNodeKind, type DriveOptions, type DrivePage, type DrivePrincipal, type DrivePrincipalType, type DriveRevision, type DriveStoredObject, type DriveTreeData, type DriveUpload, type NewDriveFile, type NewDriveFolder, dbTransport, rpcTransport, sqlTransport };
+export { type BlockTransport, type Drive, type DriveApproval, type DriveApprovalState, type DriveBatch, type DriveBinEntry, type DriveConflict, type DriveCrumb, type DriveEvents, type DriveFile, type DriveFileType, type DriveGrant, type DriveLabel, type DriveLinkView, type DriveNode, type DriveNodeKind, type DriveOptions, type DrivePage, type DrivePrincipal, type DrivePrincipalType, type DriveRevision, type DriveStoredObject, type DriveTreeData, type DriveUpload, type NewDriveFile, type NewDriveFolder, dbTransport, rpcTransport, sqlTransport };