@flowdular/sdk 0.2.3 → 0.3.0

package/modules/notifications/src/client/presentation.ts

@@ -0,0 +1,81 @@
+import type { TagTone } from '@flowdular/sdk/ui';
+import { activeLocale, t } from '@flowdular/sdk/client/i18n';
+import type {
+	DeliveryStatus,
+	NotificationKind,
+	NotificationsInboxStatus,
+	WebhookSubscriptionStatus,
+} from '../domain/types.ts';
+
+function formatted(value: number): string {
+	return new Intl.DateTimeFormat(activeLocale(), {
+		dateStyle: 'medium',
+		timeStyle: 'short',
+	}).format(value);
+}
+
+/** Epoch milliseconds as the reader's local date and time. */
+export function timestampLabel(value: number | null): string {
+	if (value === null) return t('notifications.common.notYet');
+	return formatted(value);
+}
+
+/** The inbox stores `readAt` as ISO text; an unparsable value stays visible. */
+export function isoTimestampLabel(value: string | null): string {
+	if (value === null || value === '') return t('notifications.common.notYet');
+	const parsed = Date.parse(value);
+	return Number.isNaN(parsed) ? value : formatted(parsed);
+}
+
+/** The second line of a delivery's timing cell: when the attempt ended. */
+export function deliveryCompletedLabel(value: number | null): string {
+	if (value === null) return t('notifications.deliveries.timing.pending');
+	return t('notifications.deliveries.timing.completed', {
+		value: formatted(value),
+	});
+}
+
+export function kindLabel(kind: NotificationKind): string {
+	return t('notifications.kind.' + kind);
+}
+
+export function inboxStatusLabel(status: NotificationsInboxStatus): string {
+	return t('notifications.status.' + status);
+}
+
+export function inboxStatusTone(status: NotificationsInboxStatus): TagTone {
+	if (status === 'unread') return 'info';
+	return status === 'read' ? 'success' : 'neutral';
+}
+
+export function subscriptionStatusLabel(
+	status: WebhookSubscriptionStatus,
+): string {
+	return t('notifications.subscription.status.' + status);
+}
+
+export function subscriptionStatusTone(
+	status: WebhookSubscriptionStatus,
+): TagTone {
+	if (status === 'active') return 'success';
+	return status === 'paused' ? 'warning' : 'neutral';
+}
+
+export function deliveryStatusLabel(status: DeliveryStatus): string {
+	return t('notifications.delivery.status.' + status);
+}
+
+export function deliveryStatusTone(status: DeliveryStatus): TagTone {
+	if (status === 'succeeded') return 'success';
+	if (status === 'pending') return 'info';
+	return status === 'failed' ? 'warning' : 'danger';
+}
+
+/* The ledger stores a stable class the server may extend. An unknown class is
+   shown as the server wrote it instead of being dropped. */
+export function errorClassLabel(value: string | null): string {
+	if (value === null || value === '') return '';
+	const key = 'notifications.deliveries.errorClass.' + value;
+	const translated = t(key);
+	return translated === key ? value : translated;
+}

package/modules/notifications/src/client/state.ts

@@ -0,0 +1,246 @@
+import { cell, createStore } from 'segment-state';
+import type {
+	DeliveryAttempt,
+	DeliveryStatus,
+	InboxTransition,
+	InboxTransitionOutcome,
+	NotificationKind,
+	NotificationPreference,
+	NotificationsInbox,
+	NotificationsInboxStatus,
+	WebhookSubscription,
+} from '../domain/types.ts';
+
+export type SortDirection = 'asc' | 'desc';
+
+/**
+ * The pages a keyset-paged screen has walked. `cursors[i]` is the cursor that
+ * opens page `i`; page 0 has none, and a page past the last one loaded has no
+ * cursor yet, so the screen can go back to any page it saw and forward one.
+ */
+export interface CursorStack {
+	readonly cursors: readonly string[];
+	/** Whether a page follows the last one loaded. */
+	readonly hasMore: boolean;
+}
+
+export const FIRST_PAGE: CursorStack = { cursors: [''], hasMore: false };
+
+/** The cursor that opens `pageIndex`, or null when the screen has not reached it. */
+export function pageCursor(
+	stack: CursorStack,
+	pageIndex: number,
+): string | null {
+	return stack.cursors[pageIndex] ?? null;
+}
+
+/**
+ * What the page just loaded said about the page after it. Pages beyond it are
+ * forgotten: they were reached through a cursor this response replaces.
+ */
+export function pageLoaded(
+	stack: CursorStack,
+	pageIndex: number,
+	nextCursor: string | null,
+): CursorStack {
+	const kept = stack.cursors.slice(0, pageIndex + 1);
+	return {
+		cursors: nextCursor === null ? kept : [...kept, nextCursor],
+		hasMore: nextCursor !== null,
+	};
+}
+
+/** `denied` is a 403 the shell could not hide; `error` is everything else. */
+export type ScreenStatus =
+	| 'idle'
+	| 'loading'
+	| 'submitting'
+	| 'denied'
+	| 'error';
+
+export interface SaveResult {
+	readonly ok: boolean;
+	readonly message: string;
+}
+
+export function createInboxClientState() {
+	const store = createStore({
+		items: cell<readonly NotificationsInbox[]>([]),
+		status: cell<ScreenStatus>('idle'),
+		error: '',
+		/* '' keeps the default inbox: everything the member has not archived. */
+		statusFilter: cell<NotificationsInboxStatus | ''>(''),
+		kindFilter: cell<NotificationKind | ''>(''),
+		filtersOpen: false,
+		selectedId: cell<string | null>(null),
+		pageIndex: 0,
+		pageSize: 25,
+		pages: cell<CursorStack>(FIRST_PAGE),
+		/* The open inbox came back empty while archived items exist: the default
+		   rule is hiding them, so the table reads as narrowed, not as a first run. */
+		archivedHidden: false,
+		/* Rows checked on the page; every new listing starts with none. */
+		selectedIds: cell<ReadonlySet<string>>(new Set()),
+		confirmArchiveMany: false,
+	});
+	return { store, state: store.state };
+}
+
+/**
+ * The checked rows one bulk change may name, by the same rule the row actions
+ * follow: mark-read is for unread rows, archive for rows not archived yet.
+ */
+export function transitionableIds(
+	items: readonly NotificationsInbox[],
+	selected: ReadonlySet<string>,
+	transition: InboxTransition,
+): readonly string[] {
+	return items
+		.filter(
+			(item) =>
+				selected.has(item.id) &&
+				(transition === 'mark-read'
+					? item.status === 'unread'
+					: item.status !== 'archived'),
+		)
+		.map((item) => item.id);
+}
+
+/** How many ids each outcome covered, for the notice after a bulk change. */
+export function transitionOutcomeCounts(
+	outcomes: readonly InboxTransitionOutcome[],
+): {
+	readonly updated: number;
+	readonly missing: number;
+	readonly refused: number;
+} {
+	let updated = 0;
+	let missing = 0;
+	let refused = 0;
+	for (const entry of outcomes) {
+		if (entry.outcome === 'updated') updated += 1;
+		else if (entry.outcome === 'not-found') missing += 1;
+		else refused += 1;
+	}
+	return { updated, missing, refused };
+}
+
+export function createPreferencesClientState() {
+	const store = createStore({
+		kinds: cell<readonly NotificationKind[]>([]),
+		preferences: cell<readonly NotificationPreference[]>([]),
+		/* The workspace-wide switch; off until the loaded settings say otherwise. */
+		emailDelivery: false,
+		status: cell<ScreenStatus>('idle'),
+		error: '',
+		/* Which switch is saving: a kind, the workspace-wide 'email', or none. */
+		busyKind: cell<NotificationKind | 'email' | ''>(''),
+		results: cell<Readonly<Record<string, SaveResult>>>({}),
+	});
+	return { store, state: store.state };
+}
+
+export interface EmailDeliverySwitchInput {
+	readonly status: ScreenStatus;
+	readonly canManage: boolean;
+	readonly busy: boolean;
+}
+
+export interface EmailDeliverySwitchState {
+	readonly shown: boolean;
+	readonly disabled: boolean;
+}
+
+/**
+ * The workspace-wide e-mail switch. It has no stored row to fall back on the
+ * way a kind does, so before the load answers and after one that failed the
+ * screen would show the store's `false` as the member's own answer and write
+ * that answer back on the first click.
+ */
+export function emailDeliverySwitchState(
+	input: EmailDeliverySwitchInput,
+): EmailDeliverySwitchState {
+	const loaded = input.status === 'idle';
+	return {
+		shown: loaded,
+		disabled: !input.canManage || input.busy || !loaded,
+	};
+}
+
+/** Which manage action is waiting for its confirmation dialog. */
+export type WebhookConfirm = 'rotate' | 'disable' | 'delete';
+
+export function createWebhooksClientState() {
+	const store = createStore({
+		subscriptions: cell<readonly WebhookSubscription[]>([]),
+		status: cell<ScreenStatus>('idle'),
+		error: '',
+		query: '',
+		/* The term the rows on screen answer; the box may be ahead of it. */
+		appliedQuery: '',
+		statusFilter: cell<WebhookSubscription['status'] | ''>(''),
+		direction: cell<SortDirection>('asc'),
+		pageIndex: 0,
+		pageSize: 25,
+		pages: cell<CursorStack>(FIRST_PAGE),
+		filtersOpen: false,
+		editorOpen: false,
+		selectedId: '',
+		formSession: 0,
+		/* Held only until the drawer closes; the server never returns it again. */
+		revealedSecret: '',
+		confirm: cell<WebhookConfirm | null>(null),
+	});
+	return { store, state: store.state };
+}
+
+export function createDeliveriesClientState() {
+	const store = createStore({
+		deliveries: cell<readonly DeliveryAttempt[]>([]),
+		subscriptions: cell<readonly WebhookSubscription[]>([]),
+		status: cell<ScreenStatus>('idle'),
+		error: '',
+		query: '',
+		appliedQuery: '',
+		statusFilter: cell<DeliveryStatus | ''>(''),
+		subscriptionFilter: '',
+		direction: cell<SortDirection>('desc'),
+		pageIndex: 0,
+		pageSize: 25,
+		pages: cell<CursorStack>(FIRST_PAGE),
+		filtersOpen: false,
+		replayId: cell<string | null>(null),
+	});
+	return { store, state: store.state };
+}
+
+/** The subscription name behind a delivery, or its id when names are not readable. */
+export function subscriptionNames(
+	subscriptions: readonly WebhookSubscription[],
+): ReadonlyMap<string, string> {
+	return new Map(
+		subscriptions.map((subscription) => [subscription.id, subscription.name]),
+	);
+}
+
+/**
+ * The subscriptions the ledger filter offers: every one the reader may see by
+ * name, plus any the page on screen names that the list did not, so the filter
+ * still works when the list is not readable or a row outlived its subscription.
+ */
+export function subscriptionOptions(
+	subscriptions: readonly WebhookSubscription[],
+	deliveries: readonly DeliveryAttempt[],
+): readonly { readonly value: string; readonly label: string }[] {
+	const names = subscriptionNames(subscriptions);
+	const ids = new Set(names.keys());
+	for (const delivery of deliveries) {
+		if (delivery.subscriptionId !== null) ids.add(delivery.subscriptionId);
+	}
+	return [...ids].map((id) => ({ value: id, label: names.get(id) ?? id }));
+}
+
+/** Whether the search box is ahead of the term the rows answer. */
+export function searchPending(query: string, applied: string): boolean {
+	return query.trim() !== applied;
+}

package/modules/notifications/src/client/unread-count.ts

@@ -0,0 +1,26 @@
+import { cell, createStore } from 'segment-state';
+import { loadUnreadCount } from './api.ts';
+
+/* One count behind the topbar badge and the inbox screen. The screen reports
+   what it just changed, so the badge follows a real event instead of polling
+   for one. */
+const store = createStore({ unread: cell(0) });
+
+export const unreadCount = store.state.unread;
+
+export function clearUnreadCount(): void {
+	store.set(store.state.unread, 0, 'notifications/unread-cleared');
+}
+
+export async function refreshUnreadCount(): Promise<void> {
+	try {
+		store.set(
+			store.state.unread,
+			await loadUnreadCount(),
+			'notifications/unread-loaded',
+		);
+	} catch {
+		/* The badge is an accessory. A failed count keeps the last one rather than
+   raising an error across the whole workspace. */
+	}
+}

package/modules/notifications/src/domain/locale.ts

@@ -0,0 +1,47 @@
+import { MAIL_LIMITS } from '@flowdular/sdk/server';
+import {
+	ModuleSettingsError,
+	type ModuleSettingsRuntime,
+} from '@flowdular/sdk/kernel';
+
+/* Declared and owned by auth.core as a shared tenant setting. This module reads
+   it through the settings runtime, never through auth.core storage. */
+export const TENANT_LOCALE_MODULE_ID = 'auth.core';
+export const TENANT_LOCALE_KEY = 'defaultLocale';
+export const DEFAULT_MAIL_LOCALE = 'en';
+
+/* Mirrors the tag the mail port accepts, whose length bound is MAIL_LIMITS. A
+   workspace whose stored value is not one must still be mailable: the port
+   refuses such a message on every attempt, which would dead-letter every
+   notification the workspace sends. */
+const LOCALE_PATTERN = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
+
+/**
+ * The language one workspace's messages say they are written in. A workspace
+ * that set nothing, a deployment without auth.core, and a stored value the mail
+ * port would refuse all resolve to English.
+ */
+export function tenantMailLocale(
+	settings: ModuleSettingsRuntime,
+	tenantId: string,
+): string {
+	let stored: string;
+	try {
+		stored = settings
+			.get<string>(tenantId, TENANT_LOCALE_MODULE_ID, TENANT_LOCALE_KEY)
+			.trim();
+	} catch (error) {
+		/* Absent auth.core is a deployment shape; an unprimed workspace is a
+		   caller defect and stays loud. */
+		if (
+			error instanceof ModuleSettingsError &&
+			error.code === 'SETTINGS_NOT_PRIMED'
+		) {
+			throw error;
+		}
+		return DEFAULT_MAIL_LOCALE;
+	}
+	return stored.length <= MAIL_LIMITS.locale && LOCALE_PATTERN.test(stored)
+		? stored
+		: DEFAULT_MAIL_LOCALE;
+}

package/modules/notifications/src/domain/publish.ts

@@ -0,0 +1,46 @@
+import type { NotificationKind } from './types.ts';
+
+/**
+ * The public cross-module surface. A publisher resolves it through
+ * `context.capabilities.get<NotificationPublisher>(NOTIFICATIONS_PUBLISH_CAPABILITY)`
+ * and continues without notifying when it is absent.
+ */
+export const NOTIFICATIONS_PUBLISH_CAPABILITY = 'notifications.publish.v1';
+
+export interface NotificationPublishInput {
+	readonly tenantId: string;
+	readonly kind: NotificationKind;
+	/** Publisher module id, for example `agents.core`. */
+	readonly sourceModule: string;
+	/** Stable reference to the publisher's record, for example a run id. */
+	readonly sourceRef: string;
+	readonly title: string;
+	readonly body?: string;
+	/** Account ids of the members the event is addressed to. */
+	readonly recipients: readonly string[];
+}
+
+export interface NotificationPublishResult {
+	/** Ascending by id, so a repeat returns arrays equal to the first call's. */
+	readonly inboxItemIds: readonly string[];
+	readonly deliveryIds: readonly string[];
+}
+
+export interface NotificationPublisher {
+	/**
+	 * Idempotent on (tenantId, kind, sourceRef): a repeat writes nothing and
+	 * returns the identifiers the first call created. Member preferences decide
+	 * whether an inbox item is written; webhook deliveries are unaffected by them.
+	 */
+	publish(input: NotificationPublishInput): Promise<NotificationPublishResult>;
+}
+
+/** Longest values the capability accepts; over any of them is a rejection. */
+export const PUBLISH_LIMITS = {
+	sourceModule: 64,
+	sourceRef: 200,
+	title: 200,
+	body: 4_000,
+	recipients: 64,
+	accountId: 128,
+} as const;

package/modules/notifications/src/domain/types.ts

@@ -0,0 +1,186 @@
+/** Every event this module carries. Inbox items, preferences, subscriptions and
+    deliveries all key off the same closed set. */
+export const NOTIFICATION_KINDS = [
+	'agent-run-completed',
+	'agent-run-failed',
+	'workflow-run-completed',
+	'workflow-run-failed',
+	'webhook-dead-letter',
+	'approval-requested',
+	'approval-decided',
+	'meter-threshold',
+] as const;
+
+export type NotificationKind = (typeof NOTIFICATION_KINDS)[number];
+
+export const INBOX_STATUSES = ['unread', 'read', 'archived'] as const;
+export type NotificationsInboxStatus = (typeof INBOX_STATUSES)[number];
+
+/** The changes a member may apply to many of their own items at once. */
+export const INBOX_TRANSITIONS = ['mark-read', 'archive'] as const;
+export type InboxTransition = (typeof INBOX_TRANSITIONS)[number];
+/** Most ids one bulk transition names. */
+export const INBOX_TRANSITION_MANY_LIMIT = 100;
+
+export interface InboxTransitionOutcome {
+	readonly id: string;
+	readonly outcome: 'updated' | 'not-found' | 'refused';
+	/** The stable code behind a refusal. */
+	readonly reason?: string;
+}
+
+export const SUBSCRIPTION_STATUSES = ['active', 'paused', 'disabled'] as const;
+export type WebhookSubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
+
+/**
+ * How an attempt leaves the process. A webhook attempt is addressed to a
+ * subscription of the workspace, an e-mail attempt to one member who asked for
+ * it; both share the queue, the retry budget and the dead letter.
+ */
+export const DELIVERY_CHANNELS = ['webhook', 'email'] as const;
+export type DeliveryChannel = (typeof DELIVERY_CHANNELS)[number];
+
+export const DELIVERY_STATUSES = [
+	'pending',
+	'succeeded',
+	'failed',
+	'dead-letter',
+] as const;
+export type DeliveryStatus = (typeof DELIVERY_STATUSES)[number];
+
+/** Stable failure classes recorded on an attempt. Never a response body. */
+export const DELIVERY_ERROR_CLASSES = [
+	'timeout',
+	'dns',
+	'egress-refused',
+	'response-4xx',
+	'response-5xx',
+	'network',
+	/** The port refused it: no transport, or a message it would not accept. */
+	'mail-refused',
+	/** The addressed member has no readable address or no inbox item left. */
+	'recipient-unknown',
+] as const;
+export type DeliveryErrorClass = (typeof DELIVERY_ERROR_CLASSES)[number];
+
+export interface NotificationsInbox {
+	readonly id: string;
+	readonly tenantId: string;
+	readonly recipientAccountId: string;
+	readonly kind: NotificationKind;
+	readonly title: string;
+	readonly body: string | null;
+	readonly sourceModule: string;
+	readonly sourceRef: string;
+	readonly status: NotificationsInboxStatus;
+	readonly readAt: string | null;
+	readonly createdAt: number;
+}
+
+/**
+ * The switches a member holds for the whole workspace rather than per kind. An
+ * absent row means the defaults: e-mail delivery off.
+ */
+export interface MemberNotificationSettings {
+	readonly tenantId: string;
+	readonly recipientAccountId: string;
+	/** Also send every inbox item this member receives to their address. */
+	readonly emailDelivery: boolean;
+	readonly createdAt: number;
+	readonly updatedAt: number;
+}
+
+export const DEFAULT_EMAIL_DELIVERY = false;
+
+export interface NotificationPreference {
+	readonly id: string;
+	readonly tenantId: string;
+	readonly recipientAccountId: string;
+	readonly kind: NotificationKind;
+	readonly enabled: boolean;
+	readonly createdAt: number;
+	readonly updatedAt: number;
+}
+
+/** A subscription as any read path may see it: fingerprint, never the secret. */
+export interface WebhookSubscription {
+	readonly id: string;
+	readonly tenantId: string;
+	readonly name: string;
+	readonly url: string;
+	readonly events: readonly NotificationKind[];
+	readonly secretFingerprint: string;
+	readonly secretRevision: number;
+	readonly status: WebhookSubscriptionStatus;
+	readonly description: string | null;
+	readonly lastDeliveryAt: number | null;
+	readonly createdAt: number;
+	readonly updatedAt: number;
+	readonly createdBy: string;
+}
+
+/** Returned once, at creation and at rotation, and never read back. */
+export interface WebhookSubscriptionSecret {
+	readonly subscription: WebhookSubscription;
+	readonly secret: string;
+}
+
+export interface CreateWebhookSubscriptionInput {
+	readonly name: string;
+	readonly url: string;
+	readonly events: readonly NotificationKind[];
+	readonly description?: string | null;
+}
+
+export interface UpdateWebhookSubscriptionInput
+	extends CreateWebhookSubscriptionInput {
+	readonly id: string;
+}
+
+export interface DeliveryAttempt {
+	readonly id: string;
+	readonly tenantId: string;
+	readonly channel: DeliveryChannel;
+	/** The subscription a webhook attempt is addressed to; null on e-mail. */
+	readonly subscriptionId: string | null;
+	/** The member an e-mail attempt is addressed to; null on a webhook. */
+	readonly recipientAccountId: string | null;
+	readonly kind: NotificationKind;
+	readonly sourceModule: string;
+	readonly sourceRef: string;
+	/** The published title, carried in the payload and signed with it. */
+	readonly title: string;
+	/** Attempt runs of one event: 1 for the original, one more per replay. */
+	readonly sequence: number;
+	readonly attemptNumber: number;
+	readonly status: DeliveryStatus;
+	readonly scheduledFor: number;
+	readonly completedAt: number | null;
+	readonly responseStatus: number | null;
+	readonly errorClass: string | null;
+	readonly payloadDigest: string;
+	readonly payloadBytes: number;
+	/** Publication time of the event; stable across every attempt and replay. */
+	readonly occurredAt: number;
+	readonly createdAt: number;
+}
+
+/** What the cross-tenant poll is allowed to learn on the background role. */
+export interface DeliveryRouting {
+	readonly tenantId: string;
+	readonly id: string;
+	readonly scheduledFor: number;
+	readonly status: DeliveryStatus;
+}
+
+/** The body signed and sent to a subscription, and rebuilt for every replay. */
+export interface WebhookEventPayload {
+	readonly version: 'notifications.v1';
+	readonly event: NotificationKind;
+	readonly tenantId: string;
+	readonly subscriptionId: string;
+	readonly sourceModule: string;
+	readonly sourceRef: string;
+	readonly title: string;
+	readonly occurredAt: number;
+}

package/modules/notifications/src/index.ts

@@ -0,0 +1,62 @@
+import type { ModuleManifest, RegisteredModule } from '@flowdular/sdk/contracts';
+import manifest from '../module.json' with { type: 'json' };
+import { NOTIFICATIONS_PERMISSIONS } from './acl/permissions.ts';
+
+export const moduleDefinition = {
+	manifest: manifest as ModuleManifest,
+	navigation: [
+		{
+			id: 'notifications.navigation',
+			label: 'Notifications Core',
+			href: '/notifications',
+			order: 50,
+			permission: NOTIFICATIONS_PERMISSIONS.read,
+		},
+	],
+	permissions: Object.values(NOTIFICATIONS_PERMISSIONS),
+} satisfies RegisteredModule;
+
+export { NOTIFICATIONS_PERMISSIONS } from './acl/permissions.ts';
+
+/* The cross-module contract. A publisher imports the identifier and the types
+   from here and resolves the implementation through the capability registry;
+   nothing else in this module is meant to be imported by another one. */
+export { NOTIFICATIONS_PUBLISH_CAPABILITY } from './domain/publish.ts';
+export type {
+	NotificationPublisher,
+	NotificationPublishInput,
+	NotificationPublishResult,
+} from './domain/publish.ts';
+
+export {
+	NOTIFICATION_KINDS,
+	DELIVERY_STATUSES,
+	DELIVERY_ERROR_CLASSES,
+	INBOX_STATUSES,
+	SUBSCRIPTION_STATUSES,
+} from './domain/types.ts';
+export type {
+	DeliveryAttempt,
+	DeliveryErrorClass,
+	DeliveryStatus,
+	NotificationKind,
+	NotificationPreference,
+	NotificationsInbox,
+	NotificationsInboxStatus,
+	WebhookEventPayload,
+	WebhookSubscription,
+	WebhookSubscriptionSecret,
+	WebhookSubscriptionStatus,
+} from './domain/types.ts';
+
+/* The receiver half of the signing scheme, so a customer and a test verify a
+   delivery with the code that produced it. */
+export {
+	verifyOutboundSignature,
+	WEBHOOK_SIGNATURE_HEADER,
+	WEBHOOK_SIGNATURE_VERSION,
+	WEBHOOK_TIMESTAMP_HEADER,
+} from './services/signature.ts';
+export type { OutboundSignatureCheck } from './services/signature.ts';
+
+export { NotificationsServiceError } from './services/service-error.ts';