better-supabase 0.7.1 → 0.9.0

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

@@ -1,31 +1,44 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
-import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
-import { m as RequestContext } from "../../plugin-FGY8UhYm.js";
-import { a as EventHub } from "../../events-DWDhx77e.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
-import { r as EventSink, t as CloudEvent } from "../../cloud-event-C1JCc1bH.js";
-import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-plbZ0AbJ.js";
-import { a as NotificationSubject, i as NotificationItem, n as NotificationMessage, o as RenderedText, r as NotificationSendResult, t as NotificationChannel } from "../../channel-_2Mx1Oyu.js";
+import { f as Result, t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { J as NotificationEventData, o as EventHub, q as NotificationDeliveryEventData, st as SubjectEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { m as RequestContext } from "../../plugin-CDLJRFFg.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { i as RowFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { t as BlockProblemOptions } from "../../problem-CEjyhV5T.js";
+import { i as EventSink, t as CloudEvent } from "../../cloud-event-5rCEzIgK.js";
+import { g as SubscriberPolicy, i as AuthorizationHooks } from "../../authorization-hooks-DkmrnDX7.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { n as VerifyOptions } from "../../signatures-BMdJ7neI.js";
+import { a as NotificationSubject, i as NotificationItem, n as NotificationMessage, o as RenderedText, r as NotificationSendResult, t as NotificationChannel } from "../../channel-D-LHCY11.js";
+import { a as DeliveryTransport, c as UnsubscribeTarget, i as DeliverySendOptions, l as mailHeaders, n as DeliveryMessages, o as EmailMessage, r as DeliveryReceipt, s as MailCategory, t as DeliveryChannel } from "../../delivery-BeHgwS3k.js";
+import { n as EmailChannelOptions, r as emailChannel, t as ComposedEmail } from "../../email-BcmbIWOX.js";
+import { a as NotificationsControllerOptions, c as unreadCount, i as NotificationsController, n as NotificationSource, o as NotificationsSnapshot, r as NotificationsActions, s as createNotificationsController, t as NotificationFeedOptions } from "../../client-iDLLvGR4.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/blocks/notifications/notifications.d.ts
+//#region src/blocks/notifications/api-types.d.ts
 /** Notification type to the Standard Schema of its `data`. */
 type NotificationTypes = Readonly<Record<string, StandardSchemaV1>>;
 type TypeName<K extends NotificationTypes> = keyof K & string;
-interface SendInput<D = unknown> {
+interface SendInput<D = unknown, F extends object = Record<never, never>> {
   /** Who gets it. Watchers of `subject` and the `notification_audience` hook add more. */
   readonly recipients?: readonly string[];
+  /**
+   * Also notify the users who hold this permission in `tenant`. Needs
+   * `tenant`. Without a holders template the send is refused.
+   */
+  readonly permission?: string;
   /** The organization; required when an authenticated user sends. */
   readonly tenant?: string;
   readonly subject?: NotificationSubject;
   readonly summary?: string;
   readonly actionPath?: string;
-  /** One of `sql.modules.notifications.options.priorities`. Defaults to `normal`. */
+  /** One of `blocks.notifications.options.priorities`. Defaults to `normal`. */
   readonly priority?: string;
   readonly data: D;
   /** With a key, sending again (per tenant) returns the first notification. */
   readonly key?: string;
-  /** Defaults to `sql.modules.notifications.options.channels`. */
+  /** Defaults to `blocks.notifications.options.channels`. */
   readonly channels?: readonly string[];
   /** Also notify the user who caused it. Defaults to `false`. */
   readonly includeActor?: boolean;
@@ -46,6 +59,8 @@ interface SendInput<D = unknown> {
   readonly watchers?: boolean;
   /** Users left out after the watchers and the audience hook are added. */
   readonly exclude?: readonly string[];
+  /** Values for the events table's extra columns (`options.extraColumns`). */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
 }
 interface ListOptions<K extends string = string> extends CursorPageOptions<Temporal.Instant | Pick<NotificationItem, "createdAt" | "id">> {
   readonly tenant?: string;
@@ -139,10 +154,105 @@ interface DeliverOptions {
 }
 interface DeliverResult {
   readonly sent: number;
+  /**
+   * Deliveries not sent on purpose: the channel skipped them, the address
+   * is suppressed, or `audience` left the recipient out.
+   */
   readonly skipped: number;
-  /** Deliveries that threw; retried later unless they ran out of attempts. */
+  /**
+   * Deliveries that threw, or whose `audience` check threw; retried later
+   * unless they ran out of attempts.
+   */
   readonly failed: number;
 }
+type SuppressionReason = "bounce" | "complaint" | "manual";
+/** An address a channel stops sending to, written by a bounce or complaint webhook. */
+interface SuppressInput {
+  /** Stored in lower case. */
+  readonly address: string;
+  readonly reason: SuppressionReason;
+  /** Defaults to `email`. */
+  readonly channel?: string;
+  /** The provider that reported it, e.g. `resend`. */
+  readonly provider?: string;
+  /** The provider's event or webhook message id. */
+  readonly providerEventId?: string;
+  readonly detail?: Readonly<Record<string, unknown>>;
+}
+interface NotificationSuppression {
+  readonly channel: string;
+  readonly address: string;
+  /** The user with that address when it was suppressed, or `null`. */
+  readonly userId: string | null;
+  readonly reason: SuppressionReason;
+  readonly provider: string | null;
+  readonly createdAt: Temporal.Instant | null;
+}
+/** What a provider reported about a sent message. */
+type DeliveryEventKind = "delivered" | "opened" | "clicked" | "bounced" | "complained" | "delayed";
+/** One provider event for `recordDeliveryEvent`, usually from a webhook. */
+interface DeliveryEventInput {
+  /** The provider the delivery was sent with, e.g. `resend`. */
+  readonly provider: string;
+  /** The provider's id for the message, as the channel returned it. */
+  readonly providerMessageId: string;
+  readonly kind: DeliveryEventKind;
+  /** The provider's event or webhook message id; the same id is stored once. */
+  readonly providerEventId?: string;
+  /** When the provider saw it. Defaults to now. */
+  readonly occurredAt?: Temporal.Instant;
+  readonly detail?: Readonly<Record<string, unknown>>;
+  /**
+   * Whether a `bounced` or `complained` event suppresses the recipient's
+   * address. Defaults to `true`; pass `false` for a soft bounce.
+   */
+  readonly suppress?: boolean;
+}
+/** The delivery a provider event was recorded on. */
+interface RecordedDeliveryEvent {
+  readonly deliveryId: string;
+  readonly notificationId: string;
+  readonly tenant: string | null;
+  readonly type: string;
+  readonly channel: string;
+  readonly userId: string | null;
+  /** The notification's subject, or `notification` and its id without one. */
+  readonly subject: {
+    readonly type: string;
+    readonly id: string;
+  };
+  readonly kind: DeliveryEventKind;
+  /** The delivery's furthest provider status after this event. */
+  readonly providerStatus: DeliveryEventKind | null;
+  /** `false` when the provider event id was already stored. */
+  readonly recorded: boolean;
+}
+/** One stored provider event of a delivery. */
+interface DeliveryEvent {
+  readonly kind: DeliveryEventKind;
+  readonly occurredAt: Temporal.Instant | null;
+  readonly detail: Readonly<Record<string, unknown>>;
+}
+/** A delivery of a notification about one record, for `subjectDeliveries`. */
+interface SubjectDelivery {
+  readonly id: string;
+  readonly notificationId: string;
+  readonly type: string;
+  readonly channel: string;
+  readonly userId: string;
+  readonly status: "pending" | "sent" | "failed" | "skipped";
+  readonly provider: string | null;
+  readonly providerMessageId: string | null;
+  readonly providerStatus: DeliveryEventKind | null;
+  readonly providerStatusAt: Temporal.Instant | null;
+  readonly templateKey: string | null;
+  readonly error: string | null;
+  readonly attempts: number | null;
+  readonly createdAt: Temporal.Instant | null;
+  readonly deliveredAt: Temporal.Instant | null;
+  /** Oldest first. */
+  readonly events: readonly DeliveryEvent[];
+}
 interface Rendered<K extends string = string, D = unknown> extends NotificationItem<K, D> {
   /** What `render` returned. Absent without a `render` option. */
   readonly text?: RenderedText;
@@ -153,8 +263,10 @@ interface Rendered<K extends string = string, D = unknown> extends NotificationI
  * A notification as `get`, `list` and `page` return it: its `data` parsed
  * with its type's schema, so checking `type` narrows `data`.
  */
-type NotificationOf<K extends NotificationTypes> = { [N in TypeName<K>]: Rendered<N, StandardSchemaV1.InferOutput<K[N]>>; }[TypeName<K>];
-interface NotificationsOptions<K extends NotificationTypes, H = undefined> extends BlockTemporalOptions {
+type NotificationOf<K extends NotificationTypes, F extends object = Record<never, never>> = { [N in TypeName<K>]: Rendered<N, StandardSchemaV1.InferOutput<K[N]>> & {
+  readonly fields: RowFields<F>;
+}; }[TypeName<K>];
+interface NotificationsOptions<K extends NotificationTypes, H = undefined, S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
   /** `sqlTransport(postgres.asUser(claims))`, or over `postgres.admin` for the service. */
   readonly transport: BlockTransport;
   /**
@@ -165,9 +277,15 @@ interface NotificationsOptions<K extends NotificationTypes, H = undefined> exten
    * a type no longer listed keeps its data as stored.
    */
   readonly types: K;
+  /**
+   * A Standard Schema for the events table's extra columns
+   * (`blocks.notifications.options.extraColumns`): `send` validates them,
+   * and `get`, `list` and `page` parse them.
+   */
+  readonly fields?: S;
   /** `withBlockHooks` hooks around the methods, such as a rule on `send`. */
-  readonly hooks?: NoInfer<BlockHooks<Notifications<K>>>;
-  /** `sql.modules.notifications.schema`. Defaults to `better_supabase`. */
+  readonly hooks?: NoInfer<BlockHooks<Notifications<K, FieldsOf<S>>>>;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
   readonly schema?: string;
   /**
    * Loads what `render` needs for a whole page at once (actor names,
@@ -187,6 +305,26 @@ interface NotificationsOptions<K extends NotificationTypes, H = undefined> exten
   readonly avatars?: AvatarUrls;
   /** Senders for the non-`in_app` channels, used by `deliver()`. */
   readonly channels?: readonly NotificationChannel[];
+  /**
+   * Adds the `email` channel (`emailChannel`) over a
+   * `DeliveryTransport<"email">`, such as `resendTransport`. Don't also
+   * list a channel named `email`.
+   */
+  readonly email?: EmailChannelOptions;
+  /**
+   * Checks each claimed delivery's recipient before a channel sends it;
+   * a recipient it leaves out is skipped, and a throw retries the
+   * deliveries later. Defaults to `server.authorization.delivery.audience`;
+   * with `server.authorization` but no such policy, to
+   * `subjectReaders(transport)`, so a notification about a `config.subjects`
+   * record only reaches recipients who may read it. In-app recipients are
+   * decided in SQL (`holdersOf`, membership).
+   */
+  readonly audience?: SubscriberPolicy;
+  /** The `createServer` result, whose `authorization` hooks give the default `audience`. */
+  readonly server?: {
+    readonly authorization?: AuthorizationHooks | undefined;
+  };
   /** Runs after a notification is stored, e.g. to call Next's `updateTag`. */
   readonly onSent?: (sent: {
     readonly id: string;
@@ -207,12 +345,19 @@ interface NotificationsOptions<K extends NotificationTypes, H = undefined> exten
  * leaves out the actor and non-members and applies subscriptions and
  * preferences.
  */
-interface Notifications<K extends NotificationTypes> {
+interface Notifications<K extends NotificationTypes, F extends object = Record<never, never>> {
   /** The notification id, or `null` when nobody was left to notify. */
-  send<N extends TypeName<K>>(type: N, input: SendInput<StandardSchemaV1.InferInput<K[N]>>): AsyncResult<SentNotification | null>;
-  get(id: string, options?: Pick<ListOptions, "locale" | "include">): AsyncResult<NotificationOf<K> | null>;
-  list(options?: ListOptions<TypeName<K>>): AsyncResult<readonly NotificationOf<K>[]>;
-  page(options?: PageOptions<TypeName<K>>): AsyncResult<NotificationPage<TypeName<K>, NotificationOf<K>>>;
+  send<N extends TypeName<K>>(type: N, input: SendInput<StandardSchemaV1.InferInput<K[N]>, F>): AsyncResult<SentNotification | null>;
+  /**
+   * Sends up to 1000 notifications in one `send_notifications` call, with
+   * `send`'s checks per notification: one `Result` per item, in order, so a
+   * bad one never drops the others. The outer result fails only when the
+   * call does. Hooks on `send` don't run for these; hook `sendMany`.
+   */
+  sendMany(items: readonly SinkNotification<K, F>[]): AsyncResult<readonly Result<SentNotification | null>[]>;
+  get(id: string, options?: Pick<ListOptions, "locale" | "include">): AsyncResult<NotificationOf<K, F> | null>;
+  list(options?: ListOptions<TypeName<K>>): AsyncResult<readonly NotificationOf<K, F>[]>;
+  page(options?: PageOptions<TypeName<K>>): AsyncResult<NotificationPage<TypeName<K>, NotificationOf<K, F>>>;
   counts(options?: {
     readonly tenant?: string;
   }): AsyncResult<NotificationCounts>;
@@ -273,6 +418,41 @@ interface Notifications<K extends NotificationTypes> {
    * (`90 days`) with their recipients and deliveries. Service only.
    */
   purge(olderThan?: string, batch?: number): AsyncResult<number>;
+  /**
+   * Stops `channel` from sending to an address; `deliver()` skips its
+   * deliveries. `true` when the address was not suppressed yet. Service
+   * only; `resendWebhook` calls it for bounces and complaints.
+   */
+  suppress(input: SuppressInput): AsyncResult<boolean>;
+  /** Lifts a suppression. `true` when there was one. Service only. */
+  unsuppress(address: string, channel?: string): AsyncResult<boolean>;
+  /** The caller's own suppressions, newest first (every row for the service). */
+  suppressions(options?: {
+    readonly limit?: number;
+  }): AsyncResult<readonly NotificationSuppression[]>;
+  /**
+   * Records what a provider reported about a sent message: stores it on
+   * the delivery once per `providerEventId`, moves the delivery's provider
+   * status forward, suppresses the address on a bounce or a complaint, and
+   * emits `notification.<kind>` with the notification's subject. `null`
+   * when no delivery has that provider message id. Service only;
+   * `resendWebhook` calls it for every status.
+   */
+  recordDeliveryEvent(input: DeliveryEventInput): AsyncResult<RecordedDeliveryEvent | null>;
+  /**
+   * The deliveries of the notifications about one record, newest first,
+   * each with its provider events: a record's sent emails. The service
+   * reads every tenant; a member needs the send permission in `tenant`.
+   */
+  subjectDeliveries(options: {
+    readonly subject: {
+      readonly type: string;
+      readonly id: string;
+    };
+    readonly tenant?: string;
+    /** Up to 200. Defaults to 50. */
+    readonly limit?: number;
+  }): AsyncResult<readonly SubjectDelivery[]>;
   /**
    * An `EventSink` that sends a notification for each event `map` returns
    * one for. The key defaults to the event id and the tenant to its
@@ -283,15 +463,154 @@ interface Notifications<K extends NotificationTypes> {
   sink(options: NotificationSinkOptions<K>): EventSink;
 }
 /** A notification for `sink`, with its type next to the `send` input. */
-type SinkNotification<K extends NotificationTypes> = { [N in TypeName<K>]: {
+type SinkNotification<K extends NotificationTypes, F extends object = Record<never, never>> = { [N in TypeName<K>]: {
   readonly type: N;
-} & SendInput<StandardSchemaV1.InferInput<K[N]>>; }[TypeName<K>];
+} & SendInput<StandardSchemaV1.InferInput<K[N]>, F>; }[TypeName<K>];
 interface NotificationSinkOptions<K extends NotificationTypes> {
   /** The notification for an event, or `null` to skip it. `event.type` has no `typePrefix`. */
   map(event: CloudEvent): SinkNotification<K> | null | Promise<SinkNotification<K> | null>;
   /** Stripped from each event type before `map`. Defaults to `dev.better-supabase.`. */
   readonly typePrefix?: string;
 }
-export declare function createNotifications<const K extends NotificationTypes, H = undefined>(options: NotificationsOptions<K, H>): Notifications<K>;
 //#endregion
-export { type AvatarUrls, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type DeliverOptions, type DeliverResult, type ListOptions, type NotificationActor, type NotificationChannel, type NotificationCounts, type NotificationItem, type NotificationMessage, type NotificationOf, type NotificationPage, type NotificationPreference, type NotificationSendResult, type NotificationSinkOptions, type NotificationSubject, type NotificationSubscription, type NotificationTypes, type NotificationUpdate, type Notifications, type NotificationsOptions, type PageOptions, type Rendered, type RenderedText, type RpcClient, type SendInput, type SentNotification, type SinkNotification, type SubscriptionLevel, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };
+//#region src/blocks/notifications/notifications.d.ts
+export declare function createNotifications<const K extends NotificationTypes, H = undefined, S extends StandardSchemaV1 | undefined = undefined>(options: NotificationsOptions<K, H, S>): Notifications<K, FieldsOf<S>>;
+//#endregion
+//#region src/blocks/notifications/transports/resend.d.ts
+interface ResendTransportOptions {
+  /** A Resend API key with sending access. Read it from your own env; the library never does. */
+  readonly apiKey: string;
+  /** Defaults to `https://api.resend.com`. */
+  readonly baseUrl?: string;
+  /** Defaults to the global `fetch`. */
+  readonly fetch?: typeof fetch;
+}
+/** A failed Resend call. `status` is the HTTP status, 0 when the request never got an answer. */
+export declare class ResendError extends Error {
+  readonly status: number;
+  /** Resend's error name, such as `validation_error`. */
+  readonly code: string | undefined;
+  constructor(status: number, message: string, code?: string);
+}
+/**
+ * A `DeliveryTransport` over Resend's `POST /emails`. The delivery
+ * id goes in the `Idempotency-Key` header, so a retried delivery sends one
+ * email; the message category becomes a `category` tag.
+ */
+export declare function resendTransport(options: ResendTransportOptions): DeliveryTransport;
+//#endregion
+//#region src/blocks/notifications/transports/resend-webhook.d.ts
+/**
+ * What the handler writes through: `createNotifications` over the service
+ * transport. Without `recordDeliveryEvent` (a custom writer), it only
+ * writes suppressions.
+ */
+interface SuppressionWriter {
+  suppress(input: SuppressInput): AsyncResult<boolean>;
+  recordDeliveryEvent?(input: DeliveryEventInput): AsyncResult<RecordedDeliveryEvent | null>;
+}
+/**
+ * The delivery event a Resend event reports, matched to the delivery by
+ * `data.email_id`: `email.delivered`, `opened`, `clicked`, `bounced`,
+ * `complained` and `delivery_delayed`. A `Transient` bounce doesn't
+ * suppress the address. `undefined` for any other event.
+ */
+export declare function resendDeliveryEvent(event: unknown, eventId?: string): DeliveryEventInput | undefined;
+interface ResendWebhookOptions extends BlockProblemOptions, VerifyOptions {
+  /** The endpoint's signing secret (`whsec_…`); several while rotating. */
+  readonly secret: string | readonly string[];
+  readonly notifications: SuppressionWriter;
+  /** Defaults to 256 KiB. */
+  readonly maxBodyBytes?: number;
+}
+/**
+ * The suppressions a Resend event asks for: one per recipient of an
+ * `email.bounced` (unless Resend reports the bounce as `Transient`) or an
+ * `email.complained` event, and none for any other event. `eventId` is the
+ * webhook message id, stored with each suppression.
+ */
+export declare function resendSuppressions(event: unknown, eventId?: string): SuppressInput[];
+/**
+ * A `Request` handler for Resend's webhooks. It verifies the Svix (Standard
+ * Webhooks) signature, records each delivery status on its delivery
+ * (`recordDeliveryEvent`), writes a suppression for each bounced or
+ * complaining address, and answers 204. A failed write answers 500 so
+ * Resend retries; other events are acknowledged and ignored.
+ */
+export declare function resendWebhook(options: ResendWebhookOptions): (request: Request) => Promise<Response>;
+//#endregion
+//#region src/blocks/notifications/watcher-sink.d.ts
+/** A subject-bound event's data, with its tenant. */
+type WatchedEventData = SubjectEventData & {
+  readonly organizationId: string;
+} & Readonly<Record<string, unknown>>;
+/** How one event type reaches a subject's watchers. */
+interface WatcherRule<K extends NotificationTypes, N extends TypeName<K> = TypeName<K>> {
+  /** The notification type to send. */
+  readonly type: N;
+  /** `all` (the default) reaches only `all` watchers; `participating` reaches both levels. */
+  readonly activity?: "participating" | "all";
+  /** Users to notify besides the watchers, such as a reminder's owner. */
+  readonly recipients?: (data: WatchedEventData) => readonly string[];
+  /** The notification data. Defaults to the event data. */
+  readonly data?: (event: CloudEvent, data: WatchedEventData) => StandardSchemaV1.InferInput<K[N]>;
+  readonly summary?: (data: WatchedEventData) => string;
+}
+interface WatcherSinkOptions<K extends NotificationTypes> {
+  /**
+   * Event type (without `typePrefix`) to the notification type, or a rule.
+   * Only subject-bound events (`SubjectEventType`) reach watchers; others
+   * are skipped.
+   */
+  readonly types: Readonly<Record<string, TypeName<K> | WatcherRule<K> | undefined>>;
+  /** Stripped from each event type. Defaults to `dev.better-supabase.`. */
+  readonly typePrefix?: string;
+}
+/**
+ * An outbox sink that notifies the watchers of the subject an event is
+ * about: `outbox.relay('watchers', watcherSink(notifications, { types }))`.
+ * It reads `SubjectEventData` (tenant, subject type and id) from any block's
+ * event, leaves out the actor (`actorId` or `authorId`), and keys each
+ * notification by the event id, so a replayed event sends nothing new.
+ * Build `notifications` with a service transport.
+ */
+export declare function watcherSink<K extends NotificationTypes>(notifications: Pick<Notifications<K>, "sink">, options: WatcherSinkOptions<K>): EventSink;
+/** The outbox row fields `watcherHandler` reads; every `OutboxEvent` has them. */
+interface WatchedOutboxEvent {
+  readonly id: string;
+  readonly type: string;
+  readonly payload: unknown;
+  readonly subject: string | null;
+  readonly tenant: string | null;
+  readonly actorId: string | null;
+  readonly createdAt: Temporal.Instant;
+}
+/**
+ * `watcherSink` as an outbox handler:
+ * `outbox.consume('watchers', watcherHandler(notifications, { types }))`.
+ * CloudEvents leave the actor out, so a sink can only skip the author a
+ * payload names. The outbox row carries the actor of every event, so with
+ * this handler whoever tags, moves or shares a subject is not notified of it.
+ */
+export declare function watcherHandler<K extends NotificationTypes>(notifications: Pick<Notifications<K>, "sink">, options: WatcherSinkOptions<K>): (events: readonly WatchedOutboxEvent[]) => Promise<void>;
+//#endregion
+//#region src/blocks/notifications/events.d.ts
+/** The events of the `notifications` block: type to data. */
+type NotificationsEvents = {
+  readonly "notification.created": NotificationEventData;
+  readonly "notification.delivered": NotificationDeliveryEventData;
+  readonly "notification.failed": NotificationDeliveryEventData;
+  readonly "notification.opened": NotificationDeliveryEventData;
+  readonly "notification.clicked": NotificationDeliveryEventData;
+  readonly "notification.bounced": NotificationDeliveryEventData;
+  readonly "notification.complained": NotificationDeliveryEventData;
+  readonly "notification.delayed": NotificationDeliveryEventData;
+};
+/** The `notifications` block's event types, for its manifest and `onBlockEvent`. */
+export declare const notificationsEvents: Events<NotificationsEvents>;
+//#endregion
+//#region src/blocks/notifications/manifest.d.ts
+/** The `notifications` block's manifest (ADR 0029). */
+export declare const notificationsBlock: BlockOf<"notifications", typeof createNotifications, NotificationsEvents, Record<never, never>, "notifier">;
+//#endregion
+export { type AvatarUrls, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type ComposedEmail, type DeliverOptions, type DeliverResult, type DeliveryChannel, type DeliveryEvent, type DeliveryEventInput, type DeliveryEventKind, type DeliveryMessages, type DeliveryReceipt, type DeliverySendOptions, type DeliveryTransport, type EmailChannelOptions, type EmailMessage, type ListOptions, type MailCategory, type NotificationActor, type NotificationChannel, type NotificationCounts, type NotificationFeedOptions, type NotificationItem, type NotificationMessage, type NotificationOf, type NotificationPage, type NotificationPreference, type NotificationSendResult, type NotificationSinkOptions, type NotificationSource, type NotificationSubject, type NotificationSubscription, type NotificationSuppression, type NotificationTypes, type NotificationUpdate, type Notifications, type NotificationsActions, type NotificationsController, type NotificationsControllerOptions, type NotificationsEvents, type NotificationsOptions, type NotificationsSnapshot, type PageOptions, type RecordedDeliveryEvent, type Rendered, type RenderedText, type ResendTransportOptions, type ResendWebhookOptions, type RpcClient, type SendInput, type SentNotification, type SinkNotification, type SubjectDelivery, type SubscriptionLevel, type SuppressInput, type SuppressionReason, type SuppressionWriter, type UnsubscribeTarget, type WatchedEventData, type WatchedOutboxEvent, type WatcherRule, type WatcherSinkOptions, createNotificationsController, dbTransport, emailChannel, extendBlock, mailHeaders, rpcTransport, sqlTransport, unreadCount, withBlockHooks, wrapTransport };