@holo-js/notifications 0.1.3

package/dist/chunk-INGM2JYY.mjs

@@ -0,0 +1,126 @@
+// src/contracts.ts
+import { defineNotificationsConfig } from "@holo-js/config";
+var HOLO_NOTIFICATION_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.notifications.definition");
+var BUILT_IN_NOTIFICATION_CHANNELS = ["email", "database", "broadcast"];
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeOptionalString(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`[@holo-js/notifications] ${label} must be a non-empty string when provided.`);
+  }
+  return normalized;
+}
+function normalizeDelayValue(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`[@holo-js/notifications] ${label} must be a finite number greater than or equal to 0.`);
+    }
+    return value;
+  }
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    throw new Error(`[@holo-js/notifications] ${label} dates must be valid Date instances.`);
+  }
+  return value;
+}
+function normalizeOptionalBoolean(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`[@holo-js/notifications] ${label} must be a boolean when provided.`);
+  }
+  return value;
+}
+function isNotificationDefinition(value) {
+  return !!value && typeof value === "object" && "via" in value && typeof value.via === "function" && "build" in value && isObject(value.build);
+}
+function normalizeQueueOptions(value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  return Object.freeze({
+    connection: normalizeOptionalString(value.connection, "Notification queue connection"),
+    queue: normalizeOptionalString(value.queue, "Notification queue name"),
+    ...typeof value.delay === "undefined" ? {} : { delay: normalizeDelayValue(value.delay, "Notification queue delay") },
+    ...typeof normalizeOptionalBoolean(value.afterCommit, "Notification queue afterCommit") === "undefined" ? {} : { afterCommit: value.afterCommit }
+  });
+}
+function normalizeDelayConfig(value) {
+  if (typeof value === "undefined" || typeof value === "function") {
+    return value;
+  }
+  if (typeof value === "number" || value instanceof Date) {
+    return normalizeDelayValue(value, "Notification delay");
+  }
+  if (!isObject(value)) {
+    throw new Error("[@holo-js/notifications] Notification delay must be a number, Date, plain object, or function.");
+  }
+  return Object.freeze(Object.fromEntries(Object.entries(value).map(([channel, delay]) => {
+    const normalizedChannel = normalizeOptionalString(channel, "Notification delay channel");
+    return [normalizedChannel, normalizeDelayValue(delay, `Notification delay for channel "${channel}"`)];
+  })));
+}
+function normalizeNotificationDefinition(definition) {
+  if (!isNotificationDefinition(definition)) {
+    throw new Error("[@holo-js/notifications] Notifications must define via() and build.");
+  }
+  const buildEntries = Object.entries(definition.build);
+  if (buildEntries.length === 0) {
+    throw new Error("[@holo-js/notifications] Notifications must define at least one channel payload builder.");
+  }
+  const build = Object.freeze(Object.fromEntries(buildEntries.map(([channel, factory]) => {
+    const normalizedChannel = normalizeOptionalString(channel, "Notification channel name");
+    if (typeof factory !== "function") {
+      throw new Error(`[@holo-js/notifications] Notification channel "${normalizedChannel}" must be a function.`);
+    }
+    return [normalizedChannel, factory];
+  })));
+  const queue = typeof definition.queue === "function" ? definition.queue : typeof definition.queue === "boolean" ? definition.queue : normalizeQueueOptions(definition.queue);
+  const normalized = {
+    ...definition,
+    ...typeof definition.type === "undefined" ? {} : { type: normalizeOptionalString(definition.type, "Notification type") },
+    build,
+    queue,
+    delay: normalizeDelayConfig(definition.delay)
+  };
+  Object.defineProperty(normalized, HOLO_NOTIFICATION_DEFINITION_MARKER, {
+    value: true,
+    enumerable: false
+  });
+  return Object.freeze(normalized);
+}
+function defineNotification(definition) {
+  return normalizeNotificationDefinition(definition);
+}
+function createAnonymousNotificationTarget(routes) {
+  return Object.freeze({
+    anonymous: true,
+    routes: Object.freeze({ ...routes })
+  });
+}
+var notificationsInternals = {
+  BUILT_IN_NOTIFICATION_CHANNELS,
+  HOLO_NOTIFICATION_DEFINITION_MARKER,
+  createAnonymousNotificationTarget,
+  isObject,
+  normalizeDelayConfig,
+  normalizeDelayValue,
+  normalizeNotificationDefinition,
+  normalizeOptionalBoolean,
+  normalizeOptionalString,
+  normalizeQueueOptions
+};
+
+export {
+  defineNotificationsConfig,
+  isNotificationDefinition,
+  normalizeNotificationDefinition,
+  defineNotification,
+  createAnonymousNotificationTarget,
+  notificationsInternals
+};

package/dist/contracts.d.ts

@@ -0,0 +1,212 @@
+import { NormalizedHoloNotificationsConfig } from '@holo-js/config';
+export { defineNotificationsConfig } from '@holo-js/config';
+
+type NotificationJsonPrimitive = string | number | boolean | null;
+type NotificationJsonValue = NotificationJsonPrimitive | readonly NotificationJsonValue[] | {
+    readonly [key: string]: NotificationJsonValue;
+};
+type NotificationDelayValue = number | Date;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function normalizeOptionalString(value: string | undefined, label: string): string | undefined;
+declare function normalizeDelayValue(value: NotificationDelayValue, label: string): NotificationDelayValue;
+declare function normalizeOptionalBoolean(value: boolean | undefined, label: string): boolean | undefined;
+interface NotificationMailMessage {
+    readonly subject: string;
+    readonly greeting?: string;
+    readonly lines?: readonly string[];
+    readonly action?: {
+        readonly label: string;
+        readonly url: string;
+    };
+    readonly html?: string;
+    readonly text?: string;
+    readonly metadata?: Readonly<Record<string, NotificationJsonValue>>;
+}
+interface NotificationDatabaseMessage<TData extends NotificationJsonValue = NotificationJsonValue> {
+    readonly data: TData;
+}
+interface NotificationBroadcastMessage<TData extends NotificationJsonValue = NotificationJsonValue> {
+    readonly event?: string;
+    readonly data: TData;
+}
+type NotificationEmailRoute = string | {
+    readonly email: string;
+    readonly name?: string;
+};
+interface NotificationDatabaseRoute {
+    readonly id: string | number;
+    readonly type: string;
+}
+type NotificationBroadcastRoute = string | readonly string[] | {
+    readonly channels: readonly string[];
+};
+interface NotificationContext {
+    readonly anonymous: boolean;
+}
+interface NotificationBuildContext<TChannel extends string = string> extends NotificationContext {
+    readonly channel: TChannel;
+}
+interface NotificationSendContext<TRoute = unknown, TPayload = unknown, TNotifiable = unknown, TChannel extends string = string> extends NotificationBuildContext<TChannel> {
+    readonly route?: TRoute;
+    readonly notifiable: TNotifiable;
+    readonly notificationType?: string;
+    readonly payload: TPayload;
+    readonly targetIndex: number;
+}
+interface NotificationChannel<TRoute = unknown, TPayload = unknown, TResult = unknown> {
+    validateRoute?(route: TRoute): TRoute;
+    send(input: NotificationSendContext<TRoute, TPayload>): TResult | Promise<TResult>;
+}
+interface BuiltInNotificationChannelRegistry {
+    readonly email: NotificationChannel<NotificationEmailRoute, NotificationMailMessage, void>;
+    readonly database: NotificationChannel<NotificationDatabaseRoute, NotificationDatabaseMessage, void>;
+    readonly broadcast: NotificationChannel<NotificationBroadcastRoute, NotificationBroadcastMessage, void>;
+}
+interface HoloNotificationChannelRegistry {
+}
+type NotificationChannelRegistry = BuiltInNotificationChannelRegistry & HoloNotificationChannelRegistry;
+type NotificationChannelName = Extract<keyof NotificationChannelRegistry, string>;
+type ResolveRegisteredChannel<TChannel extends string> = TChannel extends NotificationChannelName ? Extract<NotificationChannelRegistry[TChannel], NotificationChannel> extends never ? NotificationChannel : Extract<NotificationChannelRegistry[TChannel], NotificationChannel> : NotificationChannel;
+type NotificationRouteFor<TChannel extends string> = ResolveRegisteredChannel<TChannel> extends NotificationChannel<infer TRoute, unknown, unknown> ? TRoute : never;
+type NotificationPayloadFor<TChannel extends string> = ResolveRegisteredChannel<TChannel> extends NotificationChannel<unknown, infer TPayload, unknown> ? TPayload : never;
+type NotificationResultFor<TChannel extends string> = ResolveRegisteredChannel<TChannel> extends NotificationChannel<unknown, unknown, infer TResult> ? TResult : unknown;
+interface NotificationQueueOptions {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly delay?: NotificationDelayValue;
+    readonly afterCommit?: boolean;
+}
+type NotificationQueueResolver<TNotifiable, TChannel extends string> = (notifiable: TNotifiable, channel: TChannel, context: NotificationContext) => boolean | NotificationQueueOptions;
+type NotificationDelayResolver<TNotifiable, TChannel extends string> = (notifiable: TNotifiable, channel: TChannel, context: NotificationContext) => NotificationDelayValue | undefined;
+type NotificationBuildFactories<TNotifiable> = Partial<{
+    [TChannel in NotificationChannelName]: (notifiable: TNotifiable, context: NotificationBuildContext<TChannel>) => NotificationPayloadFor<TChannel>;
+}>;
+interface NotificationDefinition<TNotifiable = unknown, TBuild extends NotificationBuildFactories<TNotifiable> = NotificationBuildFactories<TNotifiable>> {
+    readonly type?: string;
+    via(notifiable: TNotifiable, context: NotificationContext): readonly Extract<keyof TBuild, string>[];
+    readonly build: TBuild;
+    readonly queue?: boolean | NotificationQueueOptions | NotificationQueueResolver<TNotifiable, string>;
+    readonly delay?: NotificationDelayValue | Partial<Record<Extract<keyof TBuild, string>, NotificationDelayValue>> | NotificationDelayResolver<TNotifiable, string>;
+}
+type InferNotificationNotifiable<TNotification> = TNotification extends NotificationDefinition<infer TNotifiable, NotificationBuildFactories<unknown>> ? TNotifiable : TNotification extends NotificationDefinition<infer TNotifiable, infer _TBuild> ? TNotifiable : never;
+type InferNotificationChannels<TNotification> = TNotification extends NotificationDefinition<unknown, infer TBuild> ? Extract<keyof TBuild, string> : never;
+interface AnonymousNotificationTarget<TRoutes extends Partial<{
+    readonly [TChannel in NotificationChannelName]: NotificationRouteFor<TChannel>;
+}> = Partial<{
+    readonly [TChannel in NotificationChannelName]: NotificationRouteFor<TChannel>;
+}>> {
+    readonly anonymous: true;
+    readonly routes: TRoutes;
+}
+type AnonymousRoutesWithChannel<TRoutes extends Partial<{
+    readonly [TChannel in NotificationChannelName]: NotificationRouteFor<TChannel>;
+}>, TChannel extends NotificationChannelName> = Readonly<Omit<TRoutes, TChannel> & {
+    readonly [TKey in TChannel]: NotificationRouteFor<TChannel>;
+}>;
+interface NotificationChannelDispatchResult<TChannel extends string = string> {
+    readonly channel: TChannel;
+    readonly targetIndex: number;
+    readonly queued: boolean;
+    readonly success: boolean;
+    readonly deferred?: boolean;
+    readonly result?: NotificationResultFor<TChannel>;
+    readonly error?: unknown;
+}
+interface NotificationDispatchResult {
+    readonly totalTargets: number;
+    readonly channels: readonly NotificationChannelDispatchResult[];
+    readonly deferred?: boolean;
+}
+interface PendingNotificationDispatch<TResult = NotificationDispatchResult> extends PromiseLike<TResult> {
+    onConnection(name: string): PendingNotificationDispatch<TResult>;
+    onQueue(name: string): PendingNotificationDispatch<TResult>;
+    delay(value: NotificationDelayValue): PendingNotificationDispatch<TResult>;
+    delayFor<TChannel extends NotificationChannelName>(channel: TChannel, value: NotificationDelayValue): PendingNotificationDispatch<TResult>;
+    afterCommit(): PendingNotificationDispatch<TResult>;
+    then<TResult1 = TResult, TResult2 = never>(onfulfilled?: ((value: TResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult1 = never>(onrejected?: ((reason: unknown) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult | TResult1>;
+    finally(onfinally?: (() => void) | null): Promise<TResult>;
+}
+interface PendingAnonymousNotification<TRoutes extends Partial<{
+    readonly [TChannel in NotificationChannelName]: NotificationRouteFor<TChannel>;
+}> = Record<never, never>> {
+    readonly target: AnonymousNotificationTarget<TRoutes>;
+    channel<TChannel extends NotificationChannelName>(channel: TChannel, route: NotificationRouteFor<TChannel>): PendingAnonymousNotification<AnonymousRoutesWithChannel<TRoutes, TChannel>>;
+    notify<TNotification extends NotificationDefinition<unknown, NotificationBuildFactories<unknown>>>(notification: TNotification): PendingNotificationDispatch<NotificationDispatchResult>;
+}
+interface NotificationMailSender {
+    send(message: NotificationMailMessage, context: NotificationSendContext<NotificationEmailRoute, NotificationMailMessage>): Promise<void> | void;
+}
+interface NotificationBroadcaster {
+    send(message: NotificationBroadcastMessage, context: NotificationSendContext<NotificationBroadcastRoute, NotificationBroadcastMessage>): Promise<void> | void;
+}
+interface NotificationRecord<TData extends NotificationJsonValue = NotificationJsonValue> {
+    readonly id: string;
+    readonly type?: string;
+    readonly notifiableType: string;
+    readonly notifiableId: string | number;
+    readonly data: TData;
+    readonly readAt?: Date | null;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+interface NotificationStore {
+    create(record: NotificationRecord): Promise<void>;
+    list(notifiable: NotificationDatabaseRoute): Promise<readonly NotificationRecord[]>;
+    unread(notifiable: NotificationDatabaseRoute): Promise<readonly NotificationRecord[]>;
+    markAsRead(ids: readonly string[]): Promise<number>;
+    markAsUnread(ids: readonly string[]): Promise<number>;
+    delete(ids: readonly string[]): Promise<number>;
+}
+interface NotificationDispatchTarget {
+    readonly kind: 'notifiable' | 'many' | 'anonymous';
+    readonly value: unknown;
+}
+interface NotificationDispatchOptions {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly delay?: NotificationDelayValue;
+    readonly delayByChannel?: Partial<Record<string, NotificationDelayValue>>;
+    readonly afterCommit?: boolean;
+}
+interface NotificationDispatchInput<TNotification extends NotificationDefinition = NotificationDefinition> {
+    readonly target: NotificationDispatchTarget;
+    readonly notification: TNotification;
+    readonly options: NotificationDispatchOptions;
+}
+interface NotificationRuntimeBindings {
+    readonly config?: NormalizedHoloNotificationsConfig;
+    readonly mailer?: NotificationMailSender;
+    readonly broadcaster?: NotificationBroadcaster;
+    readonly store?: NotificationStore;
+    dispatch?<TNotification extends NotificationDefinition = NotificationDefinition>(input: NotificationDispatchInput<TNotification>): Promise<NotificationDispatchResult>;
+}
+interface RegisterNotificationChannelOptions {
+    readonly replaceExisting?: boolean;
+}
+interface RegisteredNotificationChannel<TChannel extends string = string> {
+    readonly name: TChannel;
+    readonly channel: NotificationChannel;
+}
+declare function isNotificationDefinition(value: unknown): value is NotificationDefinition;
+declare function normalizeQueueOptions(value: NotificationQueueOptions | undefined): NotificationQueueOptions | undefined;
+declare function normalizeDelayConfig<TChannels extends string>(value: NotificationDefinition<unknown, NotificationBuildFactories<unknown>>['delay'] | undefined): NotificationDefinition<unknown, NotificationBuildFactories<unknown>>['delay'] | undefined;
+declare function normalizeNotificationDefinition<TNotifiable, TBuild extends NotificationBuildFactories<TNotifiable>>(definition: NotificationDefinition<TNotifiable, TBuild>): NotificationDefinition<TNotifiable, TBuild>;
+declare function defineNotification<TNotifiable, TBuild extends NotificationBuildFactories<TNotifiable>>(definition: NotificationDefinition<TNotifiable, TBuild>): NotificationDefinition<TNotifiable, TBuild>;
+declare function createAnonymousNotificationTarget<TRoutes extends Partial<{
+    readonly [TChannel in NotificationChannelName]: NotificationRouteFor<TChannel>;
+}>>(routes: TRoutes): AnonymousNotificationTarget<TRoutes>;
+declare const notificationsInternals: {
+    BUILT_IN_NOTIFICATION_CHANNELS: readonly ["email", "database", "broadcast"];
+    HOLO_NOTIFICATION_DEFINITION_MARKER: symbol;
+    createAnonymousNotificationTarget: typeof createAnonymousNotificationTarget;
+    isObject: typeof isObject;
+    normalizeDelayConfig: typeof normalizeDelayConfig;
+    normalizeDelayValue: typeof normalizeDelayValue;
+    normalizeNotificationDefinition: typeof normalizeNotificationDefinition;
+    normalizeOptionalBoolean: typeof normalizeOptionalBoolean;
+    normalizeOptionalString: typeof normalizeOptionalString;
+    normalizeQueueOptions: typeof normalizeQueueOptions;
+};
+
+export { type AnonymousNotificationTarget, type BuiltInNotificationChannelRegistry, type HoloNotificationChannelRegistry, type InferNotificationChannels, type InferNotificationNotifiable, type NotificationBroadcastMessage, type NotificationBroadcastRoute, type NotificationBroadcaster, type NotificationBuildContext, type NotificationBuildFactories, type NotificationChannel, type NotificationChannelDispatchResult, type NotificationChannelName, type NotificationChannelRegistry, type NotificationContext, type NotificationDatabaseMessage, type NotificationDatabaseRoute, type NotificationDefinition, type NotificationDelayResolver, type NotificationDelayValue, type NotificationDispatchInput, type NotificationDispatchOptions, type NotificationDispatchResult, type NotificationDispatchTarget, type NotificationEmailRoute, type NotificationJsonValue, type NotificationMailMessage, type NotificationMailSender, type NotificationPayloadFor, type NotificationQueueOptions, type NotificationQueueResolver, type NotificationRecord, type NotificationResultFor, type NotificationRouteFor, type NotificationRuntimeBindings, type NotificationSendContext, type NotificationStore, type PendingAnonymousNotification, type PendingNotificationDispatch, type RegisterNotificationChannelOptions, type RegisteredNotificationChannel, createAnonymousNotificationTarget, defineNotification, isNotificationDefinition, normalizeNotificationDefinition, notificationsInternals };

package/dist/contracts.mjs

@@ -0,0 +1,16 @@
+import {
+  createAnonymousNotificationTarget,
+  defineNotification,
+  defineNotificationsConfig,
+  isNotificationDefinition,
+  normalizeNotificationDefinition,
+  notificationsInternals
+} from "./chunk-INGM2JYY.mjs";
+export {
+  createAnonymousNotificationTarget,
+  defineNotification,
+  defineNotificationsConfig,
+  isNotificationDefinition,
+  normalizeNotificationDefinition,
+  notificationsInternals
+};

package/dist/index.d.ts

@@ -0,0 +1,226 @@
+import { NotificationRuntimeBindings, NotificationDatabaseRoute, NotificationRecord, NotificationDefinition, InferNotificationNotifiable, PendingNotificationDispatch, NotificationDispatchResult, PendingAnonymousNotification, NotificationChannelName, NotificationRouteFor, AnonymousNotificationTarget, NotificationDispatchTarget, NotificationDelayValue, NotificationChannel, NotificationBuildContext, NotificationSendContext, NotificationDispatchInput, NotificationBroadcastRoute, NotificationEmailRoute, NotificationDatabaseMessage, NotificationDispatchOptions, RegisteredNotificationChannel, RegisterNotificationChannelOptions } from './contracts.js';
+export { BuiltInNotificationChannelRegistry, HoloNotificationChannelRegistry, InferNotificationChannels, NotificationBroadcastMessage, NotificationBroadcaster, NotificationBuildFactories, NotificationChannelDispatchResult, NotificationContext, NotificationDelayResolver, NotificationJsonValue, NotificationMailMessage, NotificationMailSender, NotificationPayloadFor, NotificationQueueOptions, NotificationQueueResolver, NotificationResultFor, NotificationStore, defineNotification, isNotificationDefinition, normalizeNotificationDefinition, notificationsInternals } from './contracts.js';
+import { HoloNotificationsConfig } from '@holo-js/config';
+export { HoloNotificationsConfig, NormalizedHoloNotificationsConfig } from '@holo-js/config';
+
+declare function normalizeOptionalString(value: string, label: string): string;
+declare function normalizeDelayValue(value: NotificationDelayValue, label: string): NotificationDelayValue;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function isAnonymousTarget(value: unknown): value is AnonymousNotificationTarget;
+declare function getRuntimeBindings(): NotificationRuntimeBindings;
+type RuntimeState = {
+    bindings?: NotificationRuntimeBindings;
+    loadQueueModule?: () => Promise<QueueModule>;
+    loadDbModule?: () => Promise<DbModule | null>;
+};
+declare function getRuntimeState(): RuntimeState;
+declare function getDispatchHandler(): typeof dispatchNotifications;
+declare function loadQueueModule(): Promise<QueueModule>;
+declare function loadDbModule(): Promise<DbModule | null>;
+type MutableDispatchOptions = {
+    connection?: string;
+    queue?: string;
+    delay?: NotificationDelayValue;
+    delayByChannel?: Record<string, NotificationDelayValue>;
+    afterCommit?: boolean;
+};
+type DispatchTargetInput = NotificationDispatchTarget | (() => NotificationDispatchTarget);
+type ResolvedTarget = {
+    readonly index: number;
+    readonly anonymous: boolean;
+    readonly notifiable: unknown;
+    readonly routes?: Record<string, unknown>;
+};
+type RouteResolver = (notifiable: unknown) => unknown;
+type ResolvedChannelPlan = {
+    readonly channel: string;
+    readonly queued: boolean;
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly delay?: NotificationDelayValue;
+    readonly afterCommit: boolean;
+};
+type DispatchExecutionOptions = {
+    readonly allowAfterCommitDeferral?: boolean;
+};
+type QueueDispatchChain = {
+    onConnection(name: string): QueueDispatchChain;
+    onQueue(name: string): QueueDispatchChain;
+    delay(value: number | Date): QueueDispatchChain;
+    dispatch(): Promise<unknown>;
+};
+type QueueModule = {
+    defineJob(definition: {
+        handle(payload: QueuedNotificationDeliveryPayload): Promise<unknown> | unknown;
+    }): unknown;
+    dispatch(jobName: string, payload: QueuedNotificationDeliveryPayload): QueueDispatchChain;
+    getRegisteredQueueJob(name: string): unknown;
+    registerQueueJob(definition: unknown, options: {
+        name: string;
+    }): void;
+};
+type DbModule = {
+    connectionAsyncContext: {
+        getActive(): {
+            connection: {
+                getScope(): {
+                    kind: string;
+                };
+                afterCommit(callback: () => Promise<void>): void;
+            };
+        } | undefined;
+    };
+};
+type QueuedNotificationDeliveryPayload = Readonly<{
+    readonly channel: string;
+    readonly anonymous: boolean;
+    readonly notifiable: unknown;
+    readonly route?: unknown;
+    readonly notificationType?: string;
+    readonly payload: unknown;
+    readonly targetIndex: number;
+}>;
+type BuiltInChannelDefinition = NotificationChannel & {
+    readonly resolveRoute?: RouteResolver;
+};
+declare function createNotificationContext(anonymous: boolean): {
+    readonly anonymous: boolean;
+};
+declare function createBuildContext<TChannel extends string>(channel: TChannel, anonymous: boolean): NotificationBuildContext<TChannel>;
+declare function normalizeEmailRouteFromValue(value: unknown): NotificationEmailRoute;
+declare function resolveEmailRouteFromNotifiable(notifiable: unknown): NotificationEmailRoute;
+declare function normalizeDatabaseRouteFromValue(value: unknown): NotificationDatabaseRoute;
+declare function resolveDatabaseRouteFromNotifiable(notifiable: unknown): NotificationDatabaseRoute;
+declare function normalizeBroadcastRouteFromValue(value: unknown): NotificationBroadcastRoute;
+declare function resolveBroadcastRouteFromNotifiable(notifiable: unknown): NotificationBroadcastRoute;
+declare function normalizeNotificationRecord(route: NotificationDatabaseRoute, payload: NotificationDatabaseMessage, notificationType: string | undefined): NotificationRecord;
+declare function normalizeNotificationRecordIds(ids: readonly string[]): readonly string[];
+declare function getNotificationChannel(name: string): NotificationChannel | BuiltInChannelDefinition | undefined;
+declare function resolveTargets(target: NotificationDispatchTarget): readonly ResolvedTarget[];
+declare function resolveChannels(notification: NotificationDefinition, target: ResolvedTarget): readonly string[];
+declare function resolvePayload(notification: NotificationDefinition, channel: string, target: ResolvedTarget): unknown;
+declare function resolveNotificationQueueOptions(notification: NotificationDefinition, target: ResolvedTarget, channel: string): boolean | NotificationDispatchOptions;
+declare function resolveNotificationDelay(notification: NotificationDefinition, target: ResolvedTarget, channel: string): NotificationDelayValue | undefined;
+declare function resolveRoute(channel: string, target: ResolvedTarget): unknown;
+declare function resolveChannelDispatchPlan(notification: NotificationDefinition, target: ResolvedTarget, channel: string, options: NotificationDispatchOptions): ResolvedChannelPlan;
+declare function deliverResolvedNotificationChannel(context: NotificationSendContext): Promise<unknown>;
+declare function createQueuedDeliveryPayload(context: NotificationSendContext): QueuedNotificationDeliveryPayload;
+declare function runQueuedNotificationDelivery(payload: QueuedNotificationDeliveryPayload): Promise<unknown>;
+declare function ensureNotificationsQueueJobRegistered(queueModule?: QueueModule): Promise<QueueModule>;
+declare function dispatchQueuedNotificationChannel(context: NotificationSendContext, plan: ResolvedChannelPlan): Promise<void>;
+declare function deferDispatchUntilCommit(input: NotificationDispatchInput, targets: readonly ResolvedTarget[], notification: NotificationDefinition): Promise<NotificationDispatchResult | null>;
+declare function dispatchNotifications(input: NotificationDispatchInput, execution?: DispatchExecutionOptions): Promise<NotificationDispatchResult>;
+declare class PendingDispatch<TResult = NotificationDispatchResult> implements PendingNotificationDispatch<TResult> {
+    #private;
+    private readonly target;
+    private readonly notification;
+    private readonly options;
+    constructor(target: DispatchTargetInput, notification: NotificationDefinition<any, any>, options?: MutableDispatchOptions);
+    onConnection(name: string): PendingNotificationDispatch<TResult>;
+    onQueue(name: string): PendingNotificationDispatch<TResult>;
+    delay(value: NotificationDelayValue): PendingNotificationDispatch<TResult>;
+    delayFor<TChannel extends NotificationChannelName>(channel: TChannel, value: NotificationDelayValue): PendingNotificationDispatch<TResult>;
+    afterCommit(): PendingNotificationDispatch<TResult>;
+    then<TResult1 = TResult, TResult2 = never>(onfulfilled?: ((value: TResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult1 = never>(onrejected?: ((reason: unknown) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult | TResult1>;
+    finally(onfinally?: (() => void) | null): Promise<TResult>;
+}
+declare class AnonymousNotificationBuilder<TRoutes extends Partial<{
+    readonly [TChannel in NotificationChannelName]: NotificationRouteFor<TChannel>;
+}> = Record<never, never>> implements PendingAnonymousNotification<TRoutes> {
+    readonly target: AnonymousNotificationTarget<TRoutes>;
+    constructor(routes?: TRoutes);
+    channel<TChannel extends NotificationChannelName>(channel: TChannel, route: NotificationRouteFor<TChannel>): PendingAnonymousNotification<Readonly<Omit<TRoutes, TChannel> & {
+        readonly [TKey in TChannel]: NotificationRouteFor<TChannel>;
+    }>>;
+    notify<TNotification extends NotificationDefinition<any, any>>(notification: TNotification): PendingNotificationDispatch<NotificationDispatchResult>;
+}
+interface NotificationRuntimeFacade {
+    notify<TNotification extends NotificationDefinition<any, any>>(notifiable: InferNotificationNotifiable<TNotification>, notification: TNotification): PendingNotificationDispatch<NotificationDispatchResult>;
+    notifyMany<TNotification extends NotificationDefinition<any, any>>(notifiables: readonly InferNotificationNotifiable<TNotification>[] | Iterable<InferNotificationNotifiable<TNotification>>, notification: TNotification): PendingNotificationDispatch<NotificationDispatchResult>;
+    notifyUsing(): PendingAnonymousNotification;
+    listNotifications(notifiable: NotificationDatabaseRoute | Record<string, unknown>): Promise<readonly NotificationRecord[]>;
+    unreadNotifications(notifiable: NotificationDatabaseRoute | Record<string, unknown>): Promise<readonly NotificationRecord[]>;
+    markNotificationsAsRead(ids: readonly string[]): Promise<number>;
+    markNotificationsAsUnread(ids: readonly string[]): Promise<number>;
+    deleteNotifications(ids: readonly string[]): Promise<number>;
+}
+declare function configureNotificationsRuntime(bindings?: NotificationRuntimeBindings): void;
+declare function getNotificationsRuntimeBindings(): NotificationRuntimeBindings;
+declare function resetNotificationsRuntime(): void;
+declare function notify<TNotification extends NotificationDefinition<any, any>>(notifiable: InferNotificationNotifiable<TNotification>, notification: TNotification): PendingNotificationDispatch<NotificationDispatchResult>;
+declare function notifyMany<TNotification extends NotificationDefinition<any, any>>(notifiables: readonly InferNotificationNotifiable<TNotification>[] | Iterable<InferNotificationNotifiable<TNotification>>, notification: TNotification): PendingNotificationDispatch<NotificationDispatchResult>;
+declare function notifyUsing(): PendingAnonymousNotification;
+declare function listNotifications(notifiable: NotificationDatabaseRoute | Record<string, unknown>): Promise<readonly NotificationRecord[]>;
+declare function unreadNotifications(notifiable: NotificationDatabaseRoute | Record<string, unknown>): Promise<readonly NotificationRecord[]>;
+declare function markNotificationsAsRead(ids: readonly string[]): Promise<number>;
+declare function markNotificationsAsUnread(ids: readonly string[]): Promise<number>;
+declare function deleteNotifications(ids: readonly string[]): Promise<number>;
+declare function getNotificationsRuntime(): NotificationRuntimeFacade;
+declare const notificationsRuntimeInternals: {
+    HOLO_NOTIFICATIONS_DELIVER_JOB: string;
+    AnonymousNotificationBuilder: typeof AnonymousNotificationBuilder;
+    PendingDispatch: typeof PendingDispatch;
+    builtInChannels: Readonly<Record<"email" | "database" | "broadcast", BuiltInChannelDefinition>>;
+    createBuildContext: typeof createBuildContext;
+    createNotificationContext: typeof createNotificationContext;
+    createQueuedDeliveryPayload: typeof createQueuedDeliveryPayload;
+    deferDispatchUntilCommit: typeof deferDispatchUntilCommit;
+    deliverResolvedNotificationChannel: typeof deliverResolvedNotificationChannel;
+    dispatchNotifications: typeof dispatchNotifications;
+    dispatchQueuedNotificationChannel: typeof dispatchQueuedNotificationChannel;
+    ensureNotificationsQueueJobRegistered: typeof ensureNotificationsQueueJobRegistered;
+    getDispatchHandler: typeof getDispatchHandler;
+    getRuntimeBindings: typeof getRuntimeBindings;
+    getRuntimeState: typeof getRuntimeState;
+    getNotificationChannel: typeof getNotificationChannel;
+    isAnonymousTarget: typeof isAnonymousTarget;
+    isObject: typeof isObject;
+    loadDbModule: typeof loadDbModule;
+    loadQueueModule: typeof loadQueueModule;
+    normalizeBroadcastRouteFromValue: typeof normalizeBroadcastRouteFromValue;
+    normalizeDatabaseRouteFromValue: typeof normalizeDatabaseRouteFromValue;
+    normalizeDelayValue: typeof normalizeDelayValue;
+    normalizeEmailRouteFromValue: typeof normalizeEmailRouteFromValue;
+    normalizeNotificationRecord: typeof normalizeNotificationRecord;
+    normalizeNotificationRecordIds: typeof normalizeNotificationRecordIds;
+    normalizeOptionalString: typeof normalizeOptionalString;
+    resolveBroadcastRouteFromNotifiable: typeof resolveBroadcastRouteFromNotifiable;
+    resolveChannelDispatchPlan: typeof resolveChannelDispatchPlan;
+    resolveChannels: typeof resolveChannels;
+    resolveDatabaseRouteFromNotifiable: typeof resolveDatabaseRouteFromNotifiable;
+    resolveEmailRouteFromNotifiable: typeof resolveEmailRouteFromNotifiable;
+    resolveNotificationDelay: typeof resolveNotificationDelay;
+    resolveNotificationQueueOptions: typeof resolveNotificationQueueOptions;
+    resolvePayload: typeof resolvePayload;
+    resolveRoute: typeof resolveRoute;
+    runQueuedNotificationDelivery: typeof runQueuedNotificationDelivery;
+    resolveTargets: typeof resolveTargets;
+    setDbModuleLoader(loader: (() => Promise<DbModule | null>) | undefined): void;
+    setQueueModuleLoader(loader: (() => Promise<QueueModule>) | undefined): void;
+};
+
+declare function normalizeChannelName(value: string): string;
+declare function getRegistry(): Map<string, RegisteredNotificationChannel>;
+declare function registerNotificationChannel<TChannel extends string>(name: TChannel, channel: NotificationChannel, options?: RegisterNotificationChannelOptions): void;
+declare function getRegisteredNotificationChannel<TChannel extends string>(name: TChannel): RegisteredNotificationChannel<TChannel> | undefined;
+declare function listRegisteredNotificationChannels(): readonly RegisteredNotificationChannel[];
+declare function resetNotificationChannelRegistry(): void;
+declare const notificationRegistryInternals: {
+    getRegistry: typeof getRegistry;
+    normalizeChannelName: typeof normalizeChannelName;
+};
+
+declare function defineNotificationsConfig<const TConfig extends HoloNotificationsConfig>(config: TConfig): Readonly<TConfig>;
+declare const notifications: Readonly<{
+    deleteNotifications: typeof deleteNotifications;
+    listNotifications: typeof listNotifications;
+    markNotificationsAsRead: typeof markNotificationsAsRead;
+    markNotificationsAsUnread: typeof markNotificationsAsUnread;
+    notify: typeof notify;
+    notifyMany: typeof notifyMany;
+    notifyUsing: typeof notifyUsing;
+    unreadNotifications: typeof unreadNotifications;
+}>;
+
+export { AnonymousNotificationTarget, InferNotificationNotifiable, NotificationBroadcastRoute, NotificationBuildContext, NotificationChannel, NotificationChannelName, NotificationDatabaseMessage, NotificationDatabaseRoute, NotificationDefinition, NotificationDelayValue, NotificationDispatchInput, NotificationDispatchOptions, NotificationDispatchResult, NotificationDispatchTarget, NotificationEmailRoute, NotificationRecord, NotificationRouteFor, NotificationRuntimeBindings, NotificationSendContext, PendingAnonymousNotification, PendingNotificationDispatch, RegisterNotificationChannelOptions, RegisteredNotificationChannel, configureNotificationsRuntime, notifications as default, defineNotificationsConfig, deleteNotifications, getNotificationsRuntime, getNotificationsRuntimeBindings, getRegisteredNotificationChannel, listNotifications, listRegisteredNotificationChannels, markNotificationsAsRead, markNotificationsAsUnread, notificationRegistryInternals, notificationsRuntimeInternals, notify, notifyMany, notifyUsing, registerNotificationChannel, resetNotificationChannelRegistry, resetNotificationsRuntime, unreadNotifications };