@quanticjs/notification-ui 8.0.0

package/dist/index.d.cts

@@ -0,0 +1,1054 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { Socket } from 'socket.io-client';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as _quanticjs_react_core from '@quanticjs/react-core';
+
+type RealtimeStatus = 'connected' | 'reconnecting' | 'disconnected' | 'disabled';
+interface RealtimeContextValue {
+    socket: Socket | null;
+    status: RealtimeStatus;
+}
+interface NotificationRealtimeProviderProps {
+    /** Socket.IO server base URL — defaults to current origin (BFF proxy). */
+    serverUrl?: string;
+    /** Disable WebSocket (falls back to polling). Default: false. */
+    disabled?: boolean;
+    /**
+     * Scope realtime invalidation to a producing app (SPEC-application-scoping).
+     * When set, `notification:new` events for other apps are ignored; events for
+     * this app or system-wide (`appId: null`) still refresh the feed/badge. Omit
+     * for a portal that reacts to every app's events.
+     */
+    appId?: string;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Mounts a single shared Socket.IO connection to the engine's `/realtime`
+ * namespace using only the BFF httpOnly session cookie (`withCredentials`).
+ * On `notification:new` / `unread-count:changed` it invalidates the relevant
+ * TanStack Query keys (leading-edge debounced over a 200 ms window) so existing
+ * fetch logic is reused rather than patching caches. Exposes connection status
+ * via context so hooks can switch to REST polling when the socket is down.
+ */
+declare function NotificationRealtimeProvider({ serverUrl, disabled, appId, children, }: NotificationRealtimeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useRealtimeContext(): RealtimeContextValue;
+
+/**
+ * Resolved notification config shared with every bell / inbox / hook below the
+ * provider. A consumer app sets these once; components and hooks read them from
+ * context, so the bell dropped into `AppShell`'s `TopBar.actions` scopes to the
+ * registered app without prop-drilling `appId` everywhere.
+ */
+interface NotificationConfig {
+    /**
+     * The registered application slug this app's notifications are scoped to
+     * (must match a row in the engine's application registry). Flows to `?appId=`
+     * on list / unread-count / read-all and filters realtime events. Omit on a
+     * shell / portal to get the unified cross-app inbox.
+     */
+    appId?: string;
+    /** API path prefix the engine's notification endpoints are mounted on. Default `/notifications`. */
+    basePath: string;
+    /** Unread-count / feed poll interval in ms when the socket is down. Default 60_000. */
+    pollIntervalMs: number;
+}
+/**
+ * Reads the ambient notification config. Returns framework defaults when no
+ * `NotificationProvider` is mounted, so components still work with explicit
+ * props in isolation (and in tests).
+ */
+declare function useNotificationConfig(): NotificationConfig;
+interface NotificationProviderProps extends Pick<NotificationRealtimeProviderProps, 'serverUrl' | 'disabled'> {
+    /**
+     * The consumer app's registered slug — the one thing an app must declare to
+     * scope its bell. Omit on a shell / portal for the unified inbox.
+     */
+    appId?: string;
+    /** Endpoint path prefix (through the host BFF). Default `/notifications`. */
+    basePath?: string;
+    /** Poll interval (ms) used while the realtime socket is unavailable. Default 60_000. */
+    pollIntervalMs?: number;
+    children: ReactNode;
+}
+/**
+ * Single registration point for notifications. Wrap the app (above `AppShell`)
+ * once:
+ *
+ * ```tsx
+ * <NotificationProvider appId="delivery-hub">
+ *   <AppShell topBar={{ actions: <NotificationBell /> }}>…</AppShell>
+ * </NotificationProvider>
+ * ```
+ *
+ * It opens the shared realtime socket (app-filtered) and publishes `appId` /
+ * `basePath` / `pollIntervalMs` to every notification component and hook below.
+ */
+declare function NotificationProvider({ appId, basePath, pollIntervalMs, serverUrl, disabled, children, }: NotificationProviderProps): react_jsx_runtime.JSX.Element;
+
+type NotificationChannel = 'inapp' | 'email';
+type DigestPeriod = 'none' | 'hourly' | 'daily';
+interface NotificationPreferenceDto {
+    channel: NotificationChannel;
+    type: string;
+    enabled: boolean;
+    digest: DigestPeriod;
+}
+interface NotificationPreferencesProps {
+    /** API path prefix the engine's preference endpoints are mounted on (through the host app's BFF). */
+    basePath?: string;
+    /** Optional friendly labels per type key; unknown keys fall back to a derived label. */
+    typeLabels?: Record<string, string>;
+    className?: string;
+}
+/**
+ * Type × channel preference matrix with per-type email digest selection.
+ * Embeddable in any app fronting the QuanticJS notification engine — the
+ * host wraps it in its own page chrome and providers (QuanticProvider,
+ * QuanticQueryProvider, ToastProvider).
+ */
+declare function NotificationPreferences({ basePath, typeLabels, className, }: NotificationPreferencesProps): react_jsx_runtime.JSX.Element;
+
+interface UseUnreadCountOptions {
+    /** API path prefix the engine's notification endpoints are mounted on. */
+    basePath?: string;
+    /** Polling interval in ms when the socket is unavailable. Default: 60_000. */
+    pollIntervalMs?: number;
+    /** Scope the count to a producing app (its rows + system-wide). Omit for all. */
+    appId?: string;
+}
+/**
+ * Reads the unread badge count. When the realtime socket is connected, the
+ * count is kept fresh by socket-driven cache invalidation and polling is
+ * disabled; when the socket is down it transparently falls back to REST polling
+ * at `pollIntervalMs`. Any option omitted falls back to the ambient
+ * `NotificationProvider` config (where the consumer registered its `appId`).
+ */
+declare function useUnreadCount(options?: UseUnreadCountOptions): _tanstack_react_query.UseQueryResult<{
+    count: number;
+}, _quanticjs_react_core.ApiError>;
+
+interface NotificationFeedItem {
+    id: string;
+    userId: string;
+    type: string;
+    title: string;
+    body: string;
+    metadata: Record<string, unknown> | null;
+    isRead: boolean;
+    createdAt: string;
+}
+interface PaginatedFeed {
+    items: NotificationFeedItem[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface UseNotificationFeedOptions {
+    basePath?: string;
+    /** Polling interval in ms when the socket is unavailable. Default: 60_000. */
+    pollIntervalMs?: number;
+    limit?: number;
+    /**
+     * Scope the feed to a producing application (SPEC-application-scoping). When
+     * set, every request carries `?appId=` so the bell shows only that app's rows
+     * plus system-wide notifications. Omit for the unified portal view.
+     */
+    appId?: string;
+}
+/**
+ * Fetches the notification feed (list) and exposes mark-read / mark-all-read
+ * mutations. Falls back to REST polling when the socket is down. On socket
+ * reconnect it emits `backfill:request` with the newest known timestamp so any
+ * notifications created during the disconnect gap are pulled in.
+ */
+declare function useNotificationFeed(options?: UseNotificationFeedOptions): {
+    markRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, string, unknown>;
+    markAllRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, void, unknown>;
+    data: PaginatedFeed;
+    error: _quanticjs_react_core.ApiError;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: _quanticjs_react_core.ApiError | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedFeed, _quanticjs_react_core.ApiError>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedFeed>;
+} | {
+    markRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, string, unknown>;
+    markAllRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, void, unknown>;
+    data: PaginatedFeed;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: _quanticjs_react_core.ApiError | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedFeed, _quanticjs_react_core.ApiError>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedFeed>;
+} | {
+    markRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, string, unknown>;
+    markAllRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, void, unknown>;
+    data: undefined;
+    error: _quanticjs_react_core.ApiError;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: _quanticjs_react_core.ApiError | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedFeed, _quanticjs_react_core.ApiError>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedFeed>;
+} | {
+    markRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, string, unknown>;
+    markAllRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, void, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: _quanticjs_react_core.ApiError | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedFeed, _quanticjs_react_core.ApiError>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedFeed>;
+} | {
+    markRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, string, unknown>;
+    markAllRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, void, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: _quanticjs_react_core.ApiError | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedFeed, _quanticjs_react_core.ApiError>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedFeed>;
+} | {
+    markRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, string, unknown>;
+    markAllRead: _tanstack_react_query.UseMutationResult<void, _quanticjs_react_core.ApiError, void, unknown>;
+    data: PaginatedFeed;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: _quanticjs_react_core.ApiError | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedFeed, _quanticjs_react_core.ApiError>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedFeed>;
+};
+
+interface NotificationBellProps {
+    basePath?: string;
+    pollIntervalMs?: number;
+    /** Scope the unread badge to a producing app (its rows + system-wide). */
+    appId?: string;
+    /** Invoked when the bell is activated (e.g. to open the inbox panel). */
+    onClick?: () => void;
+    className?: string;
+}
+/**
+ * Accessible notification bell with an unread badge. The badge is hidden at
+ * zero; the wrapper exposes a live `role="status"` with an `aria-label`
+ * describing the count so assistive tech announces changes.
+ */
+declare function NotificationBell({ basePath, pollIntervalMs, appId, onClick, className, }: NotificationBellProps): react_jsx_runtime.JSX.Element;
+
+interface NotificationInboxProps {
+    basePath?: string;
+    pollIntervalMs?: number;
+    /** Scope the inbox to a producing app (its rows + system-wide). Omit for all. */
+    appId?: string;
+    className?: string;
+}
+/**
+ * Notification inbox panel: renders the feed with loading / error / empty
+ * states, marks individual items read on click, and offers a "Mark all read"
+ * action. All reads invalidate `['notifications']` and
+ * `['notifications','unread-count']` so the bell badge converges.
+ */
+declare function NotificationInbox({ basePath, pollIntervalMs, appId, className, }: NotificationInboxProps): react_jsx_runtime.JSX.Element;
+
+interface DeliveryAnalyticsPageProps {
+    basePath?: string;
+    organizationId?: string;
+    className?: string;
+}
+/**
+ * Admin delivery-analytics dashboard: channel/date-range filter, funnel stat
+ * cards, per-day trend chart, and a per-type table. Implements the standard
+ * loading / error / empty data-list states.
+ */
+declare function DeliveryAnalyticsPage({ basePath, organizationId, className, }: DeliveryAnalyticsPageProps): react_jsx_runtime.JSX.Element;
+
+interface DailyDeliveryStats {
+    day: string;
+    sends: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+    bounced: number;
+    failed: number;
+    deliveryRate: number;
+    openRate: number;
+    clickRate: number;
+    bounceRate: number;
+}
+interface DeliveryAnalyticsFilters {
+    from: string;
+    to: string;
+    channel?: string;
+    type?: string;
+    organizationId?: string;
+}
+interface UseDeliveryAnalyticsOptions extends DeliveryAnalyticsFilters {
+    basePath?: string;
+}
+/** Per-day delivery summary stats for the selected filters. */
+declare function useDeliveryAnalytics({ basePath, ...filters }: UseDeliveryAnalyticsOptions): _tanstack_react_query.UseQueryResult<DailyDeliveryStats[], _quanticjs_react_core.ApiError>;
+
+interface DeliveryFunnel {
+    sends: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+    bounced: number;
+    failed: number;
+    openRate: number;
+    clickRate: number;
+    bounceRate: number;
+    deliveryRate: number;
+}
+interface UseFunnelStatsOptions extends DeliveryAnalyticsFilters {
+    basePath?: string;
+}
+/** Single aggregated funnel over the selected date range. */
+declare function useFunnelStats({ basePath, ...filters }: UseFunnelStatsOptions): _tanstack_react_query.UseQueryResult<DeliveryFunnel, _quanticjs_react_core.ApiError>;
+
+interface FunnelStatsProps {
+    funnel: DeliveryFunnel;
+    className?: string;
+}
+/** Funnel stat cards: sends → delivered → opened → clicked, plus key rates. */
+declare function FunnelStats({ funnel, className }: FunnelStatsProps): react_jsx_runtime.JSX.Element;
+
+interface TrendChartProps {
+    data: DailyDeliveryStats[];
+    className?: string;
+}
+/**
+ * Per-day delivery trend line chart (sends / delivered / opened / clicked).
+ * Route-split-friendly — recharts is only loaded with the analytics page.
+ */
+declare function TrendChart({ data, className }: TrendChartProps): react_jsx_runtime.JSX.Element;
+
+interface DeliveryTypeBreakdown {
+    type: string;
+    sends: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+    bounced: number;
+    failed: number;
+    openRate: number;
+    clickRate: number;
+}
+interface UseDeliveryTypesOptions extends Pick<DeliveryAnalyticsFilters, 'from' | 'to' | 'organizationId'> {
+    basePath?: string;
+}
+/** Per-type breakdown sorted by send volume descending. */
+declare function useDeliveryTypes({ basePath, ...filters }: UseDeliveryTypesOptions): _tanstack_react_query.UseQueryResult<DeliveryTypeBreakdown[], _quanticjs_react_core.ApiError>;
+
+interface TypeTableProps {
+    rows: DeliveryTypeBreakdown[];
+    className?: string;
+}
+/** Per-notification-type delivery breakdown, sorted by send volume. */
+declare function TypeTable({ rows, className }: TypeTableProps): react_jsx_runtime.JSX.Element;
+
+type TemplateStatus = 'draft' | 'published' | 'archived' | string;
+/**
+ * Small status pill shared across the template admin components. Falls back to
+ * a neutral style for unknown status values. Semantic tokens only — no hex.
+ */
+declare function TemplateStatusBadge({ status, className, }: {
+    status: TemplateStatus;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface TemplateListItem {
+    templateId: string;
+    locales: string[];
+    latestStatus: TemplateStatus;
+    versionCount: number;
+}
+interface TemplateListProps {
+    /** API path the template admin endpoints are mounted on (through the BFF). */
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Admin data-list of notification templates. Renders the template id, the
+ * latest version status, available locales, and version count with full
+ * loading / error / empty / happy coverage.
+ */
+declare function TemplateList({ basePath, className }: TemplateListProps): react_jsx_runtime.JSX.Element;
+
+interface TemplateEditorFields {
+    subject: string;
+    heading: string;
+    body: string;
+    cta: string;
+    html: string;
+}
+interface TemplateVersionResponse {
+    id: string;
+    versionNumber: number;
+    status: TemplateStatus;
+}
+interface TemplateEditorProps {
+    templateId: string;
+    /** Existing version id to publish; falls back to the id returned by the draft save. */
+    versionId?: string;
+    initialFields?: Partial<TemplateEditorFields>;
+    initialStatus?: TemplateStatus;
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Template draft editor. Validates Handlebars brace balance client-side before
+ * submitting; saves a draft via PUT and offers a publish action. Surfaces
+ * field-level errors and ApiError-aware toasts.
+ */
+declare function TemplateEditor({ templateId, versionId, initialFields, initialStatus, basePath, className, }: TemplateEditorProps): react_jsx_runtime.JSX.Element;
+
+interface PreviewResult {
+    subject: string;
+    html: string;
+    text: string;
+}
+interface TemplatePreviewPaneProps {
+    templateId: string;
+    versionId: string;
+    /** Sample variables passed to the render. */
+    vars?: Record<string, unknown>;
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Renders a server-side preview of a template version. POSTs the version id and
+ * sample vars, then displays the rendered subject, sandboxed HTML, and plaintext.
+ */
+declare function TemplatePreviewPane({ templateId, versionId, vars, basePath, className, }: TemplatePreviewPaneProps): react_jsx_runtime.JSX.Element;
+
+interface TemplateVersion {
+    id: string;
+    versionNumber: number;
+    status: TemplateStatus;
+    createdBy: string;
+    createdAt: string;
+    locale: string;
+}
+interface TemplateVersionHistoryProps {
+    templateId: string;
+    basePath?: string;
+    className?: string;
+    /** Whether the roll back action is offered for archived versions. */
+    canRollback?: boolean;
+}
+/**
+ * Version history data-list for a template. Lists every version with its status,
+ * author, and date, and offers a roll back action for archived versions.
+ */
+declare function TemplateVersionHistory({ templateId, basePath, className, canRollback, }: TemplateVersionHistoryProps): react_jsx_runtime.JSX.Element;
+
+interface DeliveryLogRow {
+    id: string;
+    recipientEmail: string;
+    status: TemplateStatus;
+    attempts: number;
+    lastError: string | null;
+    createdAt: string;
+}
+interface DeliveryLogPage {
+    items: DeliveryLogRow[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface DeliveryLogViewerProps {
+    templateId: string;
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Paginated viewer for email delivery logs filtered by template. Renders
+ * recipient, status, attempt count, and the last error per row.
+ */
+declare function DeliveryLogViewer({ templateId, basePath, className, }: DeliveryLogViewerProps): react_jsx_runtime.JSX.Element;
+
+interface BroadcastListItem {
+    id: string;
+    templateId: string;
+    type: string | null;
+    status: string;
+    channels: string[];
+    totalRecipients: number;
+    sentCount: number;
+    failedCount: number;
+    skippedCount: number;
+    createdBy: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+interface BroadcastListPage {
+    items: BroadcastListItem[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface UseBroadcastsOptions {
+    page?: number;
+    status?: string;
+    basePath?: string;
+}
+/** Paginated broadcast history. Optionally filters by status. */
+declare function useBroadcasts({ page, status, basePath }?: UseBroadcastsOptions): _tanstack_react_query.UseQueryResult<BroadcastListPage, _quanticjs_react_core.ApiError>;
+
+interface BroadcastListProps {
+    basePath?: string;
+    status?: string;
+    onSelect?: (id: string) => void;
+    className?: string;
+}
+/**
+ * Paginated table of broadcast history. Renders template, status, channels,
+ * sent/failed/skipped counts, creator, and creation time. When `onSelect` is
+ * supplied each row becomes a button to drill into that broadcast.
+ */
+declare function BroadcastList({ basePath, status, onSelect, className, }: BroadcastListProps): react_jsx_runtime.JSX.Element;
+
+interface BroadcastDetail {
+    id: string;
+    templateId: string;
+    status: string;
+    channels: string[];
+    totalRecipients: number;
+    sentCount: number;
+    failedCount: number;
+    skippedCount: number;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+interface BroadcastProgressProps {
+    broadcastId: string;
+    basePath?: string;
+    onCancelled?: () => void;
+    className?: string;
+}
+/**
+ * Live progress for a single broadcast. Polls every 5s while the status is
+ * non-terminal, then stops. Shows sent/failed/skipped/total counters, a
+ * progress bar, and a Cancel action.
+ */
+declare function BroadcastProgress({ broadcastId, basePath, onCancelled, className, }: BroadcastProgressProps): react_jsx_runtime.JSX.Element;
+
+interface BroadcastCreatedResult {
+    id: string;
+}
+interface BroadcastComposerProps {
+    basePath?: string;
+    onCreated?: (id: string) => void;
+    className?: string;
+}
+/**
+ * Compose and dispatch a broadcast. Loads templates and segments, lets the user
+ * pick channels and either a segment or an explicit recipient list, and submits
+ * with a stable idempotency key per compose session.
+ */
+declare function BroadcastComposer({ basePath, onCreated, className, }: BroadcastComposerProps): react_jsx_runtime.JSX.Element;
+
+interface Segment {
+    id: string;
+    name: string;
+    type: string;
+    description: string | null;
+    recipientIds: string[] | null;
+    createdBy: string;
+    createdAt: string;
+}
+interface SegmentListProps {
+    basePath?: string;
+    onSelect?: (id: string) => void;
+    onCreate?: () => void;
+    className?: string;
+}
+/**
+ * Table of audience segments. Renders name, type, description, recipient count,
+ * and creation time. When `onSelect` is supplied each name becomes a button.
+ * When `onCreate` is supplied a "New segment" button is rendered in the header.
+ */
+declare function SegmentList({ basePath, onSelect, onCreate, className, }: SegmentListProps): react_jsx_runtime.JSX.Element;
+
+type SegmentType = 'static' | 'dynamic';
+interface SegmentForm {
+    name: string;
+    type: SegmentType;
+    description: string;
+    recipientIds: string[];
+}
+interface SegmentBuilderProps {
+    basePath?: string;
+    segmentId?: string;
+    initial?: Partial<SegmentForm>;
+    onSaved?: (id: string) => void;
+    onDeleted?: () => void;
+    className?: string;
+}
+/**
+ * Create/edit form for audience segments. Creates via POST and (when
+ * `segmentId` is set) edits via PATCH with a guarded Delete action. Validates
+ * client-side and surfaces field-level errors plus ApiError-aware toasts.
+ */
+declare function SegmentBuilder({ basePath, segmentId, initial, onSaved, onDeleted, className, }: SegmentBuilderProps): react_jsx_runtime.JSX.Element;
+
+type SuppressionChannel = 'inapp' | 'email' | 'push' | 'sms';
+interface Suppression {
+    id: string;
+    channel: string;
+    address: string;
+    reason: string;
+    createdAt: string;
+}
+interface SuppressionPage {
+    items: Suppression[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface SuppressionManagerProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Manage the delivery suppression list. Lists suppressed addresses (paginated)
+ * with per-row removal, and an inline add form. All mutations refetch the list
+ * and surface ApiError-aware toasts.
+ */
+declare function SuppressionManager({ basePath, className }: SuppressionManagerProps): react_jsx_runtime.JSX.Element;
+
+type DlqStatusFilter = 'queued' | 'replayed' | 'discarded';
+interface DlqMessage {
+    id: string;
+    requestId: string | null;
+    failureReason: string;
+    status: string;
+    attemptCount: number;
+    firstSeenAt: string;
+}
+interface DlqPage {
+    items: DlqMessage[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface DlqMessageDetail {
+    id: string;
+    requestId: string | null;
+    failureReason: string;
+    errorMessage: string | null;
+    status: string;
+    attemptCount: number;
+    firstSeenAt: string;
+    replayedAt: string | null;
+    payload?: unknown;
+}
+interface DlqConsoleProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Dead-letter queue console. Lists failed messages (paginated, status-filtered)
+ * with per-row expand to view payload/detail, plus Replay and Discard actions.
+ * All mutations refetch the list and surface ApiError-aware toasts.
+ */
+declare function DlqConsole({ basePath, className }: DlqConsoleProps): react_jsx_runtime.JSX.Element;
+
+interface CatalogEntry {
+    key: string;
+    locale: string;
+    value: string;
+}
+interface CatalogEditorProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * i18n catalog editor. Lists catalog entries with a key filter, supports inline
+ * value editing, per-entry delete, and an add form. All mutations refetch and
+ * surface ApiError-aware toasts.
+ */
+declare function CatalogEditor({ basePath, className }: CatalogEditorProps): react_jsx_runtime.JSX.Element;
+
+interface MissingEntry {
+    key: string;
+    locale: string;
+    type?: string;
+}
+interface MissingTranslationsPanelProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Reports translation keys that have no value for one or more locales. An empty
+ * result is the healthy state ("No missing translations").
+ */
+declare function MissingTranslationsPanel({ basePath, className, }: MissingTranslationsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface FallbackEntry {
+    key: string;
+    requestedLocale: string;
+    resolvedLocale: string;
+    steps?: string[];
+}
+interface FallbackReportPanelProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Shows translation keys that resolved through locale fallback, including the
+ * requested vs. resolved locale and the resolution chain when available.
+ */
+declare function FallbackReportPanel({ basePath, className }: FallbackReportPanelProps): react_jsx_runtime.JSX.Element;
+
+interface RecipientSummary {
+    userId: string;
+    email: string | null;
+    emailVerified: boolean;
+    phone: string | null;
+    phoneVerified: boolean;
+    locale: string | null;
+    timezone: string | null;
+    consentEmail: boolean;
+    consentPush: boolean;
+    consentSms: boolean;
+    createdAt: string;
+}
+interface RecipientPage {
+    items: RecipientSummary[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface RecipientAdminPanelProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Recipient search with GDPR actions. Paginated, searchable recipient table
+ * with per-row data export and erase (confirmed). All mutations surface
+ * ApiError-aware toasts; erase refetches the list.
+ */
+declare function RecipientAdminPanel({ basePath, className }: RecipientAdminPanelProps): react_jsx_runtime.JSX.Element;
+
+interface WebhookEndpoint {
+    id: string;
+    url: string;
+    events: string[];
+    active: boolean;
+    createdAt: string;
+}
+interface WebhookDelivery {
+    id: string;
+    status: string;
+    createdAt: string;
+}
+interface WebhookEndpointManagerProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Manage webhook endpoints. Lists endpoints with create form, per-row active
+ * toggle, delete (confirmed), and a lazy deliveries expander. All mutations
+ * refetch and surface ApiError-aware toasts.
+ */
+declare function WebhookEndpointManager({ basePath, className, }: WebhookEndpointManagerProps): react_jsx_runtime.JSX.Element;
+
+interface OperationsChannelStat {
+    channel: string;
+    sends: number;
+    delivered: number;
+    failed: number;
+}
+interface OperationsOverviewResponse {
+    windowHours: number;
+    channels: OperationsChannelStat[];
+    totalSends: number;
+    totalDelivered: number;
+    totalFailed: number;
+    dlqPending: number;
+    broadcastsInFlight: number;
+    queueHealthy: boolean;
+    generatedAt: string;
+}
+interface OperationsOverviewProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Operations overview dashboard. Renders summary stat cards (sends / delivered
+ * / failed over the reporting window), a per-channel breakdown table, and
+ * health indicators (DLQ pending, broadcasts in flight, queue health).
+ */
+declare function OperationsOverview({ basePath, className }: OperationsOverviewProps): react_jsx_runtime.JSX.Element;
+
+interface DeliveryLogExplorerRow {
+    id: string;
+    channel: string;
+    userId: string;
+    recipient: string | null;
+    status: string;
+    provider: string | null;
+    attempts: number;
+    sentAt: string | null;
+    createdAt: string;
+}
+interface DeliveryLogExplorerPage {
+    items: DeliveryLogExplorerRow[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface DeliveryLogExplorerProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Cross-channel delivery log explorer. Filterable by channel, status,
+ * recipient, user, and date range; paginated. Recipients are masked
+ * server-side. Changing any filter resets to page 1.
+ */
+declare function DeliveryLogExplorer({ basePath, className }: DeliveryLogExplorerProps): react_jsx_runtime.JSX.Element;
+
+interface QuietHours {
+    enabled: boolean;
+    start: string;
+    end: string;
+    timezone: string;
+}
+interface QuietHoursFormProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Quiet-hours configuration form. Loads the current window via GET and saves
+ * via PUT. Tolerates absent/legacy fields (startHour/endHour) and falls back
+ * to sensible defaults. ApiError-aware toasts on save.
+ */
+declare function QuietHoursForm({ basePath, className }: QuietHoursFormProps): react_jsx_runtime.JSX.Element;
+
+interface Cap {
+    type: string;
+    maxPerDay: number;
+}
+interface FrequencyCapTableProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Frequency-cap editor. Loads the current per-type caps via GET, renders an
+ * editable table with add/remove rows, and saves the full list via PUT.
+ * Tolerates array | { caps } shapes and limit/maxPerDay/perDay field names.
+ */
+declare function FrequencyCapTable({ basePath, className }: FrequencyCapTableProps): react_jsx_runtime.JSX.Element;
+
+interface TenantConfig {
+    notificationTypes: string[];
+    immediateEmailTypes: string[];
+}
+interface TenantConfigFormProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Tenant notification-config form. Edits the set of notification types and the
+ * subset enabled for immediate email. Enforces (matching the backend rule)
+ * that immediateEmailTypes is a subset of notificationTypes.
+ */
+declare function TenantConfigForm({ basePath, className }: TenantConfigFormProps): react_jsx_runtime.JSX.Element;
+
+interface TrackingConfig {
+    openTrackingEnabled: boolean;
+    clickTrackingEnabled: boolean;
+}
+interface TrackingConfigFormProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Email tracking-config form. Loads open/click tracking flags via GET and
+ * persists them via POST. Tolerates absent or legacy field names and defaults
+ * both flags to off. ApiError-aware toasts on save.
+ */
+declare function TrackingConfigForm({ basePath, className }: TrackingConfigFormProps): react_jsx_runtime.JSX.Element;
+
+interface ApiKey {
+    id: string;
+    name: string;
+    prefix?: string;
+    /** Bound application slug (SPEC-application-scoping); null/absent = unscoped. */
+    applicationKey?: string | null;
+    createdAt: string;
+    lastUsedAt?: string | null;
+    revoked?: boolean;
+}
+interface ApiKeyCreateResponse {
+    id?: string;
+    name?: string;
+    key?: string;
+    secret?: string;
+}
+interface ApiKeyManagerProps {
+    basePath?: string;
+    className?: string;
+}
+/**
+ * API key manager. Lists keys, creates new keys (surfacing the one-time secret
+ * in a toast), and revokes keys (confirmed). All mutations surface
+ * ApiError-aware toasts. See file-level note re: backend availability.
+ */
+declare function ApiKeyManager({ basePath, className }: ApiKeyManagerProps): react_jsx_runtime.JSX.Element;
+
+interface Application {
+    id: string;
+    key: string;
+    displayName: string;
+    description: string | null;
+    status: 'active' | 'disabled';
+    createdAt: string;
+    updatedAt: string;
+}
+interface ApplicationRegistryPanelProps {
+    /** API path prefix (BFF). Endpoints are mounted at `${basePath}/admin/applications`. */
+    basePath?: string;
+    className?: string;
+}
+/**
+ * Global application registry manager (SPEC-application-scoping-and-registry).
+ * Lists registered applications, registers new ones, and enables/disables them.
+ * Platform-admin only (the backend gates `notification:platform-admin`). All
+ * mutations surface ApiError-aware toasts.
+ */
+declare function ApplicationRegistryPanel({ basePath, className, }: ApplicationRegistryPanelProps): react_jsx_runtime.JSX.Element;
+
+export { type ApiKey, type ApiKeyCreateResponse, ApiKeyManager, type ApiKeyManagerProps, type Application, ApplicationRegistryPanel, type ApplicationRegistryPanelProps, BroadcastComposer, type BroadcastComposerProps, type BroadcastCreatedResult, type BroadcastDetail, BroadcastList, type BroadcastListItem, type BroadcastListPage, type BroadcastListProps, BroadcastProgress, type BroadcastProgressProps, type Cap, CatalogEditor, type CatalogEditorProps, type CatalogEntry, type DailyDeliveryStats, type DeliveryAnalyticsFilters, DeliveryAnalyticsPage, type DeliveryAnalyticsPageProps, type DeliveryFunnel, DeliveryLogExplorer, type DeliveryLogExplorerPage, type DeliveryLogExplorerProps, type DeliveryLogExplorerRow, type DeliveryLogPage, type DeliveryLogRow, DeliveryLogViewer, type DeliveryLogViewerProps, type DeliveryTypeBreakdown, type DigestPeriod, DlqConsole, type DlqConsoleProps, type DlqMessage, type DlqMessageDetail, type DlqPage, type DlqStatusFilter, type FallbackEntry, FallbackReportPanel, type FallbackReportPanelProps, FrequencyCapTable, type FrequencyCapTableProps, FunnelStats, type FunnelStatsProps, type MissingEntry, MissingTranslationsPanel, type MissingTranslationsPanelProps, NotificationBell, type NotificationBellProps, type NotificationChannel, type NotificationConfig, type NotificationFeedItem, NotificationInbox, type NotificationInboxProps, type NotificationPreferenceDto, NotificationPreferences, type NotificationPreferencesProps, NotificationProvider, type NotificationProviderProps, NotificationRealtimeProvider, type NotificationRealtimeProviderProps, type OperationsChannelStat, OperationsOverview, type OperationsOverviewProps, type OperationsOverviewResponse, type PaginatedFeed, type PreviewResult, type QuietHours, QuietHoursForm, type QuietHoursFormProps, type RealtimeStatus, RecipientAdminPanel, type RecipientAdminPanelProps, type RecipientPage, type RecipientSummary, type Segment, SegmentBuilder, type SegmentBuilderProps, type SegmentForm, SegmentList, type SegmentListProps, type SegmentType, type Suppression, type SuppressionChannel, SuppressionManager, type SuppressionManagerProps, type SuppressionPage, TemplateEditor, type TemplateEditorFields, type TemplateEditorProps, TemplateList, type TemplateListItem, type TemplateListProps, TemplatePreviewPane, type TemplatePreviewPaneProps, type TemplateStatus, TemplateStatusBadge, type TemplateVersion, TemplateVersionHistory, type TemplateVersionHistoryProps, type TemplateVersionResponse, type TenantConfig, TenantConfigForm, type TenantConfigFormProps, type TrackingConfig, TrackingConfigForm, type TrackingConfigFormProps, TrendChart, type TrendChartProps, TypeTable, type TypeTableProps, type UseBroadcastsOptions, type UseDeliveryAnalyticsOptions, type UseDeliveryTypesOptions, type UseFunnelStatsOptions, type UseNotificationFeedOptions, type UseUnreadCountOptions, type WebhookDelivery, type WebhookEndpoint, WebhookEndpointManager, type WebhookEndpointManagerProps, useBroadcasts, useDeliveryAnalytics, useDeliveryTypes, useFunnelStats, useNotificationConfig, useNotificationFeed, useRealtimeContext, useUnreadCount };