better-supabase 0.8.0 → 0.10.0

package/dist/blocks/reminders/index.js

@@ -0,0 +1,171 @@
+import { n as dbError, o as isDbError } from "../../errors-8i6tSICm.js";
+import { t as temporal } from "../../temporal-required-DqRzr7i0.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-COkvI9t5.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as remindersSqlOptions } from "../../options-DARkpk2P.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-BfVCR5Fc.js";
+import { t as subjectReaders } from "../../subject-readers-DDyPTIOr.js";
+import { r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { l as writeFields, n as blockFields, o as readFields, s as rowFields } from "../../block-fields-BANwJ9Y_.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as allowedSubscribers } from "../../subscribers-Cq--DL1E.js";
+import { n as weekdayName, t as expandRule } from "../../rrule-zBh3CA1r.js";
+//#region src/blocks/reminders/schedule.ts
+/**
+* Expands each rule between `from` and `until` and returns one delivery per
+* occurrence, shifted earlier by `offsetMinutes`. The caller enqueues each
+* row as a delayed `reminders.deliver` job with `dedupeKey`.
+*/
+function planReminderDeliveries(items, window) {
+	const time = temporal();
+	const planned = [];
+	for (const item of items) {
+		const occurrences = expandRule({
+			dtstart: item.dtstart,
+			...item.rrule === void 0 ? {} : { rrule: item.rrule },
+			...item.columns === void 0 ? {} : { columns: item.columns },
+			limit: 366
+		});
+		for (const occurrence of occurrences) {
+			const runAt = occurrence.subtract({ minutes: item.offsetMinutes });
+			if (time.ZonedDateTime.compare(runAt, window.from) < 0) continue;
+			if (time.ZonedDateTime.compare(runAt, window.until) > 0) continue;
+			const occurrenceAt = occurrence.toInstant().toString();
+			planned.push({
+				reminderId: item.id,
+				occurrenceAt,
+				runAt: runAt.toInstant(),
+				dedupeKey: `${item.id}:${occurrenceAt}`
+			});
+		}
+	}
+	return planned;
+}
+/** Records the delivery, then notifies. A second run of the same occurrence is a no-op in SQL. */
+async function deliverReminder(payload, effects) {
+	await effects.markSent(payload.reminderId, payload.occurrenceAt);
+	await effects.notify(payload);
+}
+//#endregion
+//#region src/blocks/reminders/reminders.ts
+/** Sends `notification` through `notifier` for a delivered reminder. */
+function notifyThrough(options) {
+	const { notifier, notification } = options;
+	if (notifier === void 0 || notification === void 0) return;
+	return (delivery) => notifier.send(notification, {
+		recipients: delivery.userId === void 0 ? [] : [delivery.userId],
+		tenant: delivery.organizationId,
+		key: `reminder:${delivery.reminderId}:${delivery.occurrenceAt}`,
+		...delivery.subjectType === void 0 || delivery.subjectId === void 0 ? {} : { subject: {
+			type: delivery.subjectType,
+			id: delivery.subjectId
+		} },
+		data: {
+			reminderId: delivery.reminderId,
+			occurrenceAt: delivery.occurrenceAt
+		}
+	});
+}
+/** The queue `reminders.job` handles. */
+const REMINDER_DELIVERY_QUEUE = "reminders.deliver";
+function deliveryOf(value) {
+	if (!isRecord(value)) throw new TypeError(`${REMINDER_DELIVERY_QUEUE} needs an object payload`);
+	const userId = optionalText(value["userId"]);
+	const subjectType = optionalText(value["subjectType"]);
+	const subjectId = optionalText(value["subjectId"]);
+	return {
+		reminderId: textOf(value["reminderId"]),
+		occurrenceAt: textOf(value["occurrenceAt"]),
+		organizationId: textOf(value["organizationId"]),
+		...userId === void 0 ? {} : { userId },
+		...subjectType === void 0 ? {} : { subjectType },
+		...subjectId === void 0 ? {} : { subjectId }
+	};
+}
+function createReminders(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "reminder fields");
+	const notifyDelivery = options.notifyDelivery ?? notifyThrough(options);
+	const audience = options.audience ?? options.authorization?.delivery?.audience ?? (options.authorization === void 0 ? void 0 : subjectReaders(options.transport, options.schema === void 0 ? {} : { schema: options.schema }));
+	/** Whether `audience` lets the reminder's user have it, or the policy's failure. */
+	const permitted = (delivery) => AsyncResult.from(async () => {
+		if (audience === void 0 || delivery.userId === void 0) return ok(true);
+		const subscriber = {
+			principal: delivery.userId,
+			kind: "user"
+		};
+		const checked = await allowedSubscribers(audience, {
+			type: "reminder.due",
+			tenant: delivery.organizationId,
+			actorId: null,
+			payload: delivery,
+			subject: delivery.subjectType === void 0 || delivery.subjectId === void 0 ? null : `subjects/${delivery.subjectType}/${delivery.subjectId}`
+		}, [subscriber]);
+		return checked.ok ? ok(checked.allowed.length > 0) : err(dbError("unexpected", `The reminder audience check failed: ${checked.cause instanceof Error ? checked.cause.message : String(checked.cause)}`, { hint: "REMINDER_AUDIENCE_FAILED" }));
+	});
+	const markSent = (reminderId, occurrenceAt) => call("mark_reminder_sent", {
+		reminder: reminderId,
+		occurrence_at: occurrenceAt
+	}, (value) => value === true);
+	const deliver = (delivery) => (notifyDelivery === void 0 ? AsyncResult.ok(false) : permitted(delivery)).andThen((allowed) => hooked.markSent(delivery.reminderId, delivery.occurrenceAt).andThen(async (sent) => {
+		if (sent && allowed && notifyDelivery !== void 0) {
+			const outcome = await notifyDelivery(delivery);
+			if (isRecord(outcome) && outcome["ok"] === false && isDbError(outcome["error"])) return err(outcome["error"]);
+		}
+		return ok(sent);
+	}));
+	const hooked = withBlockHooks({
+		save: (organizationId, subjectType, subjectId, offsetMinutes, values) => writeFields(fields, values, (checked) => call("save_reminder", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			offset_minutes: offsetMinutes ?? 0,
+			fields: checked
+		}, (value) => {
+			const row = recordOf(value, "save_reminder");
+			return {
+				id: textOf(row["id"]),
+				fields: rowFields(row["fields"])
+			};
+		})).andThen((saved) => readFields(fields, saved)),
+		list: (organizationId, subjectType, subjectId) => call("list_my_reminders", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId
+		}, (value) => recordsOf(value, "list_my_reminders").map((row) => ({
+			id: textOf(row["id"]),
+			method: textOf(row["method"]),
+			offsetMinutes: Number(row["offsetMinutes"])
+		}))),
+		remove: (reminderId) => call("delete_reminder", { reminder: reminderId }, (value) => value === true),
+		markSent,
+		deliver,
+		job: async (payload) => {
+			await hooked.deliver(deliveryOf(payload)).orThrow();
+		}
+	}, options.hooks, {
+		block: "reminders",
+		...options.logger ? { logger: options.logger } : {}
+	});
+	return hooked;
+}
+//#endregion
+//#region src/blocks/reminders/events.ts
+/** The `reminders` block's event types, for its manifest and `onBlockEvent`. */
+const remindersEvents = defineEvents({ "reminder.sent": event() });
+//#endregion
+//#region src/blocks/reminders/manifest.ts
+/** The `reminders` block's manifest (ADR 0029). */
+const remindersBlock = defineBlock({
+	name: "reminders",
+	sql: ["reminders"],
+	options: { reminders: remindersSqlOptions },
+	events: remindersEvents,
+	consumes: { notifier: "optional" },
+	create: createReminders,
+	category: "scheduling",
+	recipes: ["reminders-list"]
+});
+//#endregion
+export { REMINDER_DELIVERY_QUEUE, createReminders, deliverReminder, expandRule, planReminderDeliveries, remindersBlock, remindersEvents, weekdayName };

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

@@ -0,0 +1,148 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CtAHxPal.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-NbUJygA7.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-7pMBVsE6.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-C_WaodoA.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+//#region src/blocks/reviews/reviews.d.ts
+interface ReviewsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the review's extra columns
+   * (`blocks.reviews.options.extraColumns`), keyed by database name. It
+   * types and parses them on reads, and validates them on `submit`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Reviews<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+type ReviewStatus = "pending" | "published" | "rejected";
+/** A review. `F` types the extra columns the `fields` schema describes. */
+interface Review<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Missing on `list`, which hides who wrote each review; `mine` marks the caller's. */
+  readonly authorId?: string;
+  readonly authorName?: string;
+  /** Whether the caller wrote it. */
+  readonly mine: boolean;
+  /** From 1 to `blocks.reviews.options.scale` (default 5). */
+  readonly rating: number;
+  readonly title?: string;
+  readonly body?: string;
+  readonly status: ReviewStatus;
+  /** Whether the orders module shows a paid order for the product. */
+  readonly verified: boolean;
+  /** Why a moderator rejected it; the author sees it. */
+  readonly rejectionReason?: string;
+  /** The organization's public reply. */
+  readonly reply?: string;
+  readonly repliedAt?: Temporal.Instant;
+  readonly publishedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface ReviewInput<F extends object = Record<never, never>> {
+  readonly rating: number;
+  readonly body?: string;
+  readonly title?: string;
+  /** The name shown with the review. */
+  readonly authorName?: string;
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+interface ReviewListOptions {
+  readonly pageSize?: number;
+  /** Reviews published before this instant, for the next page. */
+  readonly before?: Temporal.Instant;
+  /** Only this rating. */
+  readonly rating?: number;
+  /** Only verified (`true`) or unverified (`false`) reviews. */
+  readonly verified?: boolean;
+}
+interface ReviewQueueOptions {
+  /** Default `pending`; `null` lists every status. */
+  readonly status?: ReviewStatus | null;
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly pageSize?: number;
+  /** Reviews written before this instant, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+/** One subject's published reviews, counted. */
+interface ReviewSummary {
+  readonly count: number;
+  /** The mean rating, rounded to two decimals. */
+  readonly average: number;
+  /** How many reviews gave each rating, keyed by rating. */
+  readonly histogram: Readonly<Record<number, number>>;
+}
+interface Reviews<F extends object = Record<never, never>> {
+  /**
+   * Writes the caller's review of a subject, or replaces it (one per user
+   * and subject). It waits for `publish` under pre-moderation.
+   */
+  submit(organizationId: string, subjectType: string, subjectId: string, input: ReviewInput<F>): AsyncResult<Review<F>>;
+  /** The caller's review of the subject in any status. */
+  mine(organizationId: string, subjectType: string, subjectId: string): AsyncResult<Review<F> | undefined>;
+  /** The subject's published reviews, newest first. Anonymous visitors can call it for a public storefront's products. */
+  list(organizationId: string, subjectType: string, subjectId: string, options?: ReviewListOptions): AsyncResult<readonly Review<F>[]>;
+  /** The rating aggregate of up to 200 subjects of one type, by subject id. Subjects without published reviews are left out. */
+  summary(organizationId: string, subjectType: string, subjectIds: readonly string[]): AsyncResult<Readonly<Record<string, ReviewSummary>>>;
+  /** Reviews for moderators, newest first; needs `reviews.manage`. */
+  queue(organizationId: string, options?: ReviewQueueOptions): AsyncResult<readonly Review<F>[]>;
+  /** Needs `reviews.manage`. */
+  publish(reviewId: string): AsyncResult<Review<F>>;
+  /** Needs `reviews.manage`. */
+  reject(reviewId: string, reason?: string): AsyncResult<Review<F>>;
+  /** Sets the organization's public reply; `null` removes it. Needs `reviews.manage`. */
+  reply(reviewId: string, reply: string | null): AsyncResult<Review<F>>;
+  /** The author or a moderator; `false` when the review is gone. */
+  remove(reviewId: string): AsyncResult<boolean>;
+}
+/** The `reviews` SQL module as typed calls. */
+export declare function createReviews<S extends StandardSchemaV1 | undefined = undefined>(options: ReviewsOptions<S>): Reviews<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/reviews/events.d.ts
+/** `review.*`: which review changed, its subject and its state after the change. */
+interface ReviewEventData {
+  readonly organizationId: string;
+  /** The review. */
+  readonly id: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly authorId: string | null;
+  readonly rating: number;
+  readonly status: "pending" | "published" | "rejected";
+  /** Whether the orders module shows a paid order for the product. */
+  readonly verified: boolean;
+}
+/** The events of the `reviews` block: type to data. */
+type ReviewsEvents = {
+  readonly "review.submitted": ReviewEventData;
+  readonly "review.published": ReviewEventData;
+  readonly "review.rejected": ReviewEventData;
+  readonly "review.replied": ReviewEventData;
+  readonly "review.deleted": ReviewEventData;
+};
+/** The `reviews` block's event types, for its manifest and `onBlockEvent`. */
+export declare const reviewsEvents: Events<ReviewsEvents>;
+//#endregion
+//#region src/blocks/reviews/manifest.d.ts
+/** The `reviews` block's manifest (ADR 0029). */
+export declare const reviewsBlock: BlockOf<"reviews", typeof createReviews, ReviewsEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Review, type ReviewEventData, type ReviewInput, type ReviewListOptions, type ReviewQueueOptions, type ReviewStatus, type ReviewSummary, type Reviews, type ReviewsEvents, type ReviewsOptions, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/reviews/index.js

@@ -0,0 +1,139 @@
+import { t as AsyncResult } from "../../result-COkvI9t5.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as reviewsSqlOptions } from "../../options-CGjGE8xS.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 { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-BfVCR5Fc.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { n as blockFields } from "../../block-fields-BANwJ9Y_.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+//#region src/blocks/reviews/reviews.ts
+const STATUSES = [
+	"pending",
+	"published",
+	"rejected"
+];
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+function reviewOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		mine: row["mine"] === true,
+		rating: typeof row["rating"] === "number" ? row["rating"] : 0,
+		status: enumOrThrow(row["status"], STATUSES, "review status"),
+		verified: row["verified"] === true,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("authorId", optionalText(row["authorId"])),
+		...optional("authorName", optionalText(row["authorName"])),
+		...optional("title", optionalText(row["title"])),
+		...optional("body", optionalText(row["body"])),
+		...optional("rejectionReason", optionalText(row["rejectionReason"])),
+		...optional("reply", optionalText(row["reply"])),
+		...optional("repliedAt", optionalInstant(row["repliedAt"])),
+		...optional("publishedAt", optionalInstant(row["publishedAt"])),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function summaryOf(value) {
+	const out = {};
+	for (const [id, entry] of Object.entries(recordOf(value, "review_summary"))) {
+		const row = isRecord(entry) ? entry : {};
+		const histogram = {};
+		for (const [rating, count] of Object.entries(isRecord(row["histogram"]) ? row["histogram"] : {})) if (typeof count === "number") histogram[Number(rating)] = count;
+		out[id] = {
+			count: typeof row["count"] === "number" ? row["count"] : 0,
+			average: Number(row["average"] ?? 0),
+			histogram
+		};
+	}
+	return out;
+}
+/** The `reviews` SQL module as typed calls. */
+function createReviews(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "review fields");
+	const one = (fn) => (value) => reviewOf(value, fn);
+	const many = (fn) => (value) => recordsOf(value, fn).map((row) => reviewOf(row, fn));
+	return withBlockHooks({
+		submit: (organizationId, subjectType, subjectId, input) => fields.args(input.fields).andThen((checked) => call("submit_review", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			rating: input.rating,
+			body: input.body ?? null,
+			title: input.title ?? null,
+			author_name: input.authorName ?? null,
+			...checked === void 0 ? {} : { fields: checked }
+		}, one("submit_review")).andThen(fields.row)),
+		mine: (organizationId, subjectType, subjectId) => call("my_review", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId
+		}, (value) => value === null || value === void 0 ? void 0 : reviewOf(value, "my_review")).andThen((review) => review === void 0 ? AsyncResult.ok(void 0) : fields.row(review)),
+		list: (organizationId, subjectType, subjectId, list = {}) => call("list_reviews", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			page_size: list.pageSize ?? null,
+			before: instantArg(list.before) ?? null,
+			rating: list.rating ?? null,
+			verified: list.verified ?? null
+		}, many("list_reviews")).andThen(fields.rows),
+		summary: (organizationId, subjectType, subjectIds) => call("review_summary", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_ids: subjectIds
+		}, summaryOf),
+		queue: (organizationId, queue = {}) => call("review_queue", {
+			tenant: organizationId,
+			status: queue.status === void 0 ? "pending" : queue.status,
+			page_size: queue.pageSize ?? null,
+			before: instantArg(queue.before) ?? null,
+			subject_type: queue.subjectType ?? null,
+			subject_id: queue.subjectId ?? null
+		}, many("review_queue")).andThen(fields.rows),
+		publish: (reviewId) => call("publish_review", { review_id: reviewId }, one("publish_review")).andThen(fields.row),
+		reject: (reviewId, reason) => call("reject_review", {
+			review_id: reviewId,
+			reason: reason ?? null
+		}, one("reject_review")).andThen(fields.row),
+		reply: (reviewId, reply) => call("reply_to_review", {
+			review_id: reviewId,
+			reply
+		}, one("reply_to_review")).andThen(fields.row),
+		remove: (reviewId) => call("delete_review", { review_id: reviewId }, (value) => value === true)
+	}, options.hooks, {
+		block: "reviews",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/reviews/events.ts
+/** The `reviews` block's event types, for its manifest and `onBlockEvent`. */
+const reviewsEvents = defineEvents({
+	"review.submitted": event(),
+	"review.published": event(),
+	"review.rejected": event(),
+	"review.replied": event(),
+	"review.deleted": event()
+});
+//#endregion
+//#region src/blocks/reviews/manifest.ts
+/** The `reviews` block's manifest (ADR 0029). */
+const reviewsBlock = defineBlock({
+	name: "reviews",
+	sql: ["reviews"],
+	options: { reviews: reviewsSqlOptions },
+	events: reviewsEvents,
+	create: createReviews,
+	category: "commerce"
+});
+//#endregion
+export { createReviews, dbTransport, extendBlock, reviewsBlock, reviewsEvents, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -0,0 +1,169 @@
+import { f as Result, t as AsyncResult } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CtAHxPal.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-C_WaodoA.js";
+import { _ as FilterRule, f as FilterNode, h as FilterQuery, i as FilterCombinator, m as FilterOperatorSpec } from "../../filter-query-D3wOD1P_.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+import { r as NotifierInput } from "../../ports-B53rB7zg.js";
+import { o as ApprovalRequestInput } from "../../approvals-DqlPHBHI.js";
+import { A as evaluateRule, B as ruleFilterFields, C as RulesAdmin, D as createRuleSink, E as createRuleDispatcher, F as RuleFieldCatalog, I as RuleFieldDefinition, L as checkRuleConditions, M as ruleRecordFields, N as RULE_LIMITS, O as createRules, P as RuleField, R as defineRuleFields, S as Rules, T as RulesOptions, _ as RuleSinkEvent, a as createRuleBuilderController, b as RuleSubject, c as RuleActionCall, d as RuleDispatcher, f as RuleDispatcherOptions, g as RuleMatch, h as RuleListOptions, i as RuleBuilderSnapshot, j as ruleOf, k as createRulesAdmin, l as RuleActionHandler, m as RuleInput, n as RuleBuilderController, o as Rule, p as RuleEvaluationEntry, r as RuleBuilderControllerOptions, s as RuleAction, t as RuleBuilderActions, u as RuleActionOutcome, v as RuleSinkOptions, w as RulesAdminOptions, x as RuleVersion, y as RuleSinkTarget, z as ruleFilterFieldInfo } from "../../client-BaynD5V-.js";
+//#region src/blocks/rules/tree.d.ts
+/** The operators a field allows, in the order the editor lists them. */
+export declare function ruleOperators(field: RuleField): readonly FilterOperatorSpec[];
+/** An empty `and` group, the tree a new rule starts with. */
+export declare const emptyConditions: (id?: string) => FilterQuery;
+/** The node with `id`, or `undefined`. */
+export declare function findNode(tree: FilterNode, id: string): FilterNode | undefined;
+/** The group that holds `id`, or `undefined` for the root and unknown ids. */
+export declare function parentOf(tree: FilterQuery, id: string): FilterQuery | undefined;
+/** Whether `id` is `ancestor` or sits anywhere under it. */
+export declare function contains(ancestor: FilterNode, id: string): boolean;
+/** Replaces the node with `id` by what `change` returns. */
+export declare function updateNode(tree: FilterQuery, id: string, change: (node: FilterNode) => FilterNode): FilterQuery;
+/** Drops the node with `id` and everything under it; the root stays. */
+export declare function removeNode(tree: FilterQuery, id: string): FilterQuery;
+/**
+ * Adds `node` to the group `parent` at `index` (the end by default).
+ * Unchanged when `parent` isn't a group in the tree.
+ */
+export declare function insertNode(tree: FilterQuery, parent: string, node: FilterNode, index?: number): FilterQuery;
+/**
+ * Moves the node with `id` into the group `parent`, where it ends up at
+ * `index` (as `arrayMove` counts it). Unchanged for the root, an unknown
+ * node or group, or a move into the node itself.
+ */
+export declare function moveNode(tree: FilterQuery, id: string, parent: string, index: number): FilterQuery;
+/** Changes a group's `and` or `or`. */
+export declare function setCombinator(tree: FilterQuery, id: string, combinator: FilterCombinator): FilterQuery;
+/**
+ * Points a rule at another field. A field of the same type keeps the
+ * operator it allows, and its value; another type starts at the field's
+ * first operator without a value.
+ */
+export declare function setRuleField(rule: FilterRule, field: RuleField, previous: RuleField | undefined): FilterRule;
+/**
+ * Changes a rule's operator. The value stays when the new operator takes
+ * the same kind of value (one, many or a range), and is dropped otherwise.
+ */
+export declare function setRuleOperator(rule: FilterRule, operator: string, field: RuleField | undefined): FilterRule;
+//#endregion
+//#region src/blocks/rules/actions.d.ts
+/** The context `dispatch` passes when rules start approvals or other subject work. */
+interface RuleSubjectContext {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Passed on to the approval request, such as the expense amount. */
+  readonly payload?: Readonly<Record<string, unknown>>;
+  /** The outbox event the rules ran for; it keys retries of the same action. */
+  readonly eventId?: string;
+}
+/** The part of the approvals client the handler calls. */
+interface RuleApprovals {
+  request(input: ApprovalRequestInput): AsyncResult<unknown>;
+}
+/**
+ * The `approvals.request` handler: starts an approval of the subject for the
+ * action in the rule's `config.action`, such as `{ kind: "approvals.request",
+ * config: { action: "manager_review" } }`.
+ */
+export declare function approvalsAction(approvals: RuleApprovals): RuleActionHandler<RuleSubjectContext>;
+/** The part of a `notifier` port (the notifications block) the handler calls. */
+interface RuleNotifier {
+  send(type: string, input: NotifierInput): unknown;
+}
+/**
+ * The `notify` handler: sends the notification type in `config.type` to the
+ * user ids in `config.recipients` and in the payload column that
+ * `config.recipientField` names, with `config.data` and the payload as its
+ * data: `{ kind: "notify", config: { type: "task.assigned", recipientField:
+ * "assignee_id" } }`.
+ */
+export declare function notifyAction(notifier: RuleNotifier): RuleActionHandler<RuleSubjectContext>;
+/** What `setFieldAction` asks the app to write: one column of the subject's row. */
+interface RuleFieldWrite {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly field: string;
+  readonly value: unknown;
+}
+/** Writes one field, such as through an app table repository's `update`. */
+type RuleFieldSetter = (write: RuleFieldWrite) => Result<unknown> | PromiseLike<Result<unknown>>;
+/**
+ * The `set_field` handler: writes `config.value` to the subject's
+ * `config.field`: `{ kind: "set_field", config: { field: "status", value:
+ * "review" } }`. The setter decides which fields it accepts.
+ */
+export declare function setFieldAction(setField: RuleFieldSetter): RuleActionHandler<RuleSubjectContext>;
+/** The part of the outgoing webhooks client the handler calls. */
+interface RuleWebhooks {
+  dispatch(input: {
+    readonly endpointId: string;
+    readonly type: string;
+    readonly data: unknown;
+    readonly eventId?: string;
+  }): AsyncResult<string>;
+}
+/**
+ * The `webhook` handler: queues a delivery to the endpoint in
+ * `config.endpointId`, typed `config.type` or the rule's trigger, with the
+ * payload as its data: `{ kind: "webhook", config: { endpointId: "..." } }`.
+ */
+export declare function webhookAction(webhooks: RuleWebhooks): RuleActionHandler<RuleSubjectContext>;
+/** The part of the workflow builder client the handler calls. */
+interface RuleWorkflows {
+  run(input: {
+    readonly definition: string;
+    readonly input?: unknown;
+    readonly idempotencyKey?: string;
+    readonly subject?: {
+      readonly type: string;
+      readonly id: string;
+    };
+    readonly tenant?: string;
+  }): AsyncResult<string>;
+}
+/**
+ * The `workflow` handler: starts the workflow definition in
+ * `config.definition` on the subject, with the payload as its input:
+ * `{ kind: "workflow", config: { definition: "..." } }`. A retried event
+ * starts no second run.
+ */
+export declare function workflowAction(workflows: RuleWorkflows): RuleActionHandler<RuleSubjectContext>;
+//#endregion
+//#region src/blocks/rules/events.d.ts
+/** `rule.saved`, `rule.enabled`, `rule.disabled` and `rule.removed`. */
+interface RuleEventData {
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly name: string;
+  readonly subjectType: string;
+  readonly trigger: string;
+  readonly version: number;
+}
+/** `rule.matched`: a live evaluation matched a subject. */
+interface RuleMatchedEventData {
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly version: number;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly trigger: string;
+}
+/** The events of the `rules` block: type to data. */
+type RulesEvents = {
+  readonly "rule.saved": RuleEventData;
+  readonly "rule.enabled": RuleEventData;
+  readonly "rule.disabled": RuleEventData;
+  readonly "rule.removed": RuleEventData;
+  readonly "rule.matched": RuleMatchedEventData;
+};
+/** The `rules` block's event types, for its manifest and `onBlockEvent`. */
+export declare const rulesEvents: Events<RulesEvents>;
+//#endregion
+//#region src/blocks/rules/manifest.d.ts
+/** The `rules` block's manifest (ADR 0029). */
+export declare const rulesBlock: BlockOf<"rules", typeof createRules, RulesEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, RULE_LIMITS, type RpcClient, type Rule, type RuleAction, type RuleActionCall, type RuleActionHandler, type RuleActionOutcome, type RuleApprovals, type RuleBuilderActions, type RuleBuilderController, type RuleBuilderControllerOptions, type RuleBuilderSnapshot, type RuleDispatcher, type RuleDispatcherOptions, type RuleEvaluationEntry, type RuleEventData, type RuleField, type RuleFieldCatalog, type RuleFieldDefinition, type RuleFieldSetter, type RuleFieldWrite, type RuleInput, type RuleListOptions, type RuleMatch, type RuleMatchedEventData, type RuleNotifier, type RuleSinkEvent, type RuleSinkOptions, type RuleSinkTarget, type RuleSubject, type RuleSubjectContext, type RuleVersion, type RuleWebhooks, type RuleWorkflows, type Rules, type RulesAdmin, type RulesAdminOptions, type RulesEvents, type RulesOptions, checkRuleConditions, createRuleBuilderController, createRuleDispatcher, createRuleSink, createRules, createRulesAdmin, dbTransport, defineRuleFields, evaluateRule, extendBlock, rpcTransport, ruleFilterFieldInfo, ruleFilterFields, ruleOf, ruleRecordFields, sqlTransport, withBlockHooks, wrapTransport };