@house-rules/notifications 0.0.0-stage → 0.1.0

package/dist/notification/notifications.d.ts

@@ -0,0 +1,206 @@
+import { type Actor } from "@house-rules/domain";
+import { Effect, Schema } from "effect";
+import type { NotificationStore } from "../storage.js";
+import { type Channel, NotificationInputInvalid, Recipient } from "./notification.js";
+import type { NotificationsOptions } from "./options.js";
+export declare const makeNotifications: (store: NotificationStore["Service"], options: NotificationsOptions) => {
+    notify: (input: {
+        readonly recipients: readonly {
+            readonly kind: string;
+            readonly id: string;
+        }[];
+        readonly category: string;
+        readonly title: string;
+        readonly body: string;
+        readonly data: Schema.Json;
+    }) => Effect.Effect<{
+        notifications: {
+            readonly id: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly category: string;
+            readonly title: string;
+            readonly body: string;
+            readonly data: Schema.Json;
+            readonly createdAt: number;
+            readonly readAt: number | null;
+        }[];
+        events: {
+            kind: "NotificationCreated";
+            notificationId: string;
+            recipient: Recipient;
+            channels: Channel[];
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    listMine: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, page?: {
+        readonly size?: number;
+        readonly cursor?: {
+            readonly createdAt: number;
+            readonly id: string;
+        };
+    } | undefined) => Effect.Effect<{
+        notifications: {
+            readonly id: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly category: string;
+            readonly title: string;
+            readonly body: string;
+            readonly data: Schema.Json;
+            readonly createdAt: number;
+            readonly readAt: number | null;
+        }[];
+        next: {
+            createdAt: number;
+            id: string;
+        };
+    } | {
+        next?: never;
+        notifications: {
+            readonly id: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly category: string;
+            readonly title: string;
+            readonly body: string;
+            readonly data: Schema.Json;
+            readonly createdAt: number;
+            readonly readAt: number | null;
+        }[];
+    }, NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    unreadCount: (actor: Actor) => Effect.Effect<number, import("./notification.js").NotificationStoreUnavailable, never>;
+    markRead: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, notificationId: string) => Effect.Effect<{
+        readonly notifications: readonly {
+            readonly id: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly category: string;
+            readonly title: string;
+            readonly body: string;
+            readonly data: Schema.Json;
+            readonly createdAt: number;
+            readonly readAt: number | null;
+        }[];
+        readonly events: readonly {
+            readonly kind: "NotificationRead";
+            readonly notificationId: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    markAllRead: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }) => Effect.Effect<{
+        readonly notifications: readonly {
+            readonly id: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly category: string;
+            readonly title: string;
+            readonly body: string;
+            readonly data: Schema.Json;
+            readonly createdAt: number;
+            readonly readAt: number | null;
+        }[];
+        readonly events: readonly {
+            readonly kind: "NotificationRead";
+            readonly notificationId: string;
+            readonly recipient: {
+                readonly kind: string;
+                readonly id: string;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | import("./notification.js").NotificationStoreUnavailable, never>;
+    getMyPreferences: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }) => Effect.Effect<{
+        preferences: {
+            category: string;
+            channel: "email" | "inapp" | "push";
+            mode: "daily" | "hourly" | "immediate" | "off";
+        }[];
+        quietHours: {
+            readonly start: string;
+            readonly end: string;
+        } | null;
+        timeZone: string | null;
+    }, import("./notification.js").NotificationStoreUnavailable, never>;
+    setMyPreference: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, preference: {
+        readonly category: string;
+        readonly channel: "email" | "inapp" | "push";
+        readonly mode: "daily" | "hourly" | "immediate" | "off";
+    }) => Effect.Effect<undefined, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    setMyQuietHours: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, hours: {
+        readonly start: string;
+        readonly end: string;
+    } | null) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    setMyTimeZone: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, timeZone: string | null) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    dueDeliveries: () => Effect.Effect<{
+        readonly recipient: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly channel: "email" | "inapp" | "push";
+        readonly mode: "daily" | "hourly" | "immediate";
+        readonly deliveries: readonly {
+            readonly delivery: {
+                readonly id: string;
+                readonly notificationId: string;
+                readonly recipient: {
+                    readonly kind: string;
+                    readonly id: string;
+                };
+                readonly channel: "email" | "inapp" | "push";
+                readonly mode: "daily" | "hourly" | "immediate";
+                readonly state: "cancelled" | "failed" | "held" | "pending" | "sent";
+                readonly dueAt: number;
+                readonly retryAt: number | null;
+                readonly sentAt: number | null;
+                readonly attempts: number;
+                readonly lastError: string | null;
+            };
+            readonly notification: {
+                readonly id: string;
+                readonly recipient: {
+                    readonly kind: string;
+                    readonly id: string;
+                };
+                readonly category: string;
+                readonly title: string;
+                readonly body: string;
+                readonly data: Schema.Json;
+                readonly createdAt: number;
+                readonly readAt: number | null;
+            };
+        }[];
+    }[], import("./notification.js").NotificationStoreUnavailable, never>;
+    markSent: (deliveryIds: readonly string[]) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    markFailed: (deliveryId: string, error: string) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+    erase: (recipient: {
+        readonly kind: string;
+        readonly id: string;
+    }) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | NotificationInputInvalid | import("./notification.js").NotificationStoreUnavailable, never>;
+};
+export type NotificationsService = ReturnType<typeof makeNotifications>;

package/dist/notification/notifications.js

@@ -0,0 +1,224 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { DateTime, Effect, Random, Schema } from "effect";
+import { NotificationInputInvalid, NotificationPage, NotifyInput, Preference, QuietHours, Recipient, TimeZone, } from "./notification.js";
+import { digestAt, releaseAt } from "./timing.js";
+const invalid = () => new NotificationInputInvalid({ message: "Invalid notification input." });
+const decode = (schema) => (value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(invalid));
+const now = DateTime.now.pipe(Effect.map(DateTime.toEpochMillis));
+const newId = Effect.all(Array.from({ length: 4 }, () => Random.nextIntBetween(0, 0xffff_ffff))).pipe(Effect.map((words) => words.map((word) => word.toString(16).padStart(8, "0")).join("")));
+const readResult = (notifications) => ({
+    notifications,
+    events: notifications.map((n) => ({
+        kind: "NotificationRead",
+        notificationId: n.id,
+        recipient: n.recipient,
+    })),
+});
+export const makeNotifications = (store, options) => {
+    const mine = (actor) => ({ kind: options.recipientKind, id: actor.id });
+    const categoryOf = (name) => options.categories.find((category) => category.name === name);
+    const modeFor = (category, channel, preferences) => {
+        const saved = preferences.find((p) => p.category === category.name && p.channel === channel);
+        if (channel === "inapp")
+            return "immediate";
+        if (category.mandatory)
+            return category.defaultChannels.includes(channel) ||
+                (saved !== undefined && saved.mode !== "off")
+                ? "immediate"
+                : "off";
+        return (saved?.mode ??
+            (category.defaultChannels.includes(channel) ? "immediate" : "off"));
+    };
+    const refresh = Effect.fn("Notifications.refresh")(function* (recipient) {
+        const at = yield* now;
+        const preferences = yield* store.preferences(recipient);
+        const hours = yield* store.quietHours(recipient);
+        const timeZone = (yield* store.timeZone(recipient)) ?? "UTC";
+        for (const { delivery, notification } of yield* store.deliveries(recipient, {
+            unsettledOnly: true,
+        })) {
+            const category = categoryOf(notification.category);
+            if (category === undefined ||
+                category.mandatory ||
+                delivery.channel === "inapp" ||
+                (delivery.state !== "pending" && delivery.state !== "held"))
+                continue;
+            const mode = modeFor(category, delivery.channel, preferences);
+            if (mode === "off") {
+                yield* store.reschedule(delivery.id, { ...delivery, state: "cancelled" });
+                continue;
+            }
+            // Keep elapsed digest times due, and never shorten an outstanding retry backoff.
+            const base = Math.max(at, digestAt(notification.createdAt, mode, timeZone, options.dailyDigestTime ?? "08:00"), delivery.retryAt ?? 0);
+            const dueAt = hours === null ? base : releaseAt(base, hours, timeZone);
+            yield* store.reschedule(delivery.id, {
+                mode,
+                dueAt,
+                state: dueAt > base ? "held" : "pending",
+            });
+        }
+    });
+    return {
+        notify: Effect.fn("Notifications.notify")(function* (input) {
+            yield* UnitOfWork.required;
+            const decoded = yield* decode(NotifyInput)(input);
+            const category = categoryOf(decoded.category);
+            if (category === undefined)
+                return yield* invalid();
+            const at = yield* now;
+            const notifications = [];
+            const events = [];
+            const seen = new Set();
+            for (const recipient of decoded.recipients) {
+                const key = JSON.stringify([recipient.kind, recipient.id]);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const preferences = yield* store.preferences(recipient);
+                const hours = yield* store.quietHours(recipient);
+                const timeZone = (yield* store.timeZone(recipient)) ?? "UTC";
+                const notification = {
+                    id: yield* newId,
+                    recipient,
+                    category: category.name,
+                    title: decoded.title,
+                    body: decoded.body,
+                    data: decoded.data,
+                    createdAt: at,
+                    readAt: null,
+                };
+                const deliveries = [];
+                const channels = [];
+                for (const channel of options.channels) {
+                    const mode = modeFor(category, channel, preferences);
+                    if (mode === "off")
+                        continue;
+                    channels.push(channel);
+                    // The inbox row is the in-app delivery, not unsettled work for a sender.
+                    if (channel === "inapp")
+                        continue;
+                    const base = digestAt(at, mode, timeZone, options.dailyDigestTime ?? "08:00");
+                    const dueAt = !category.mandatory && hours !== null ? releaseAt(base, hours, timeZone) : base;
+                    deliveries.push({
+                        id: yield* newId,
+                        notificationId: notification.id,
+                        recipient,
+                        channel,
+                        mode,
+                        state: dueAt > base ? "held" : "pending",
+                        dueAt,
+                        retryAt: null,
+                        sentAt: null,
+                        attempts: 0,
+                        lastError: null,
+                    });
+                }
+                yield* store.insert(notification, deliveries);
+                notifications.push(notification);
+                events.push({
+                    kind: "NotificationCreated",
+                    notificationId: notification.id,
+                    recipient,
+                    channels,
+                });
+            }
+            return { notifications, events };
+        }),
+        listMine: Effect.fn("Notifications.listMine")(function* (actor, page) {
+            const decoded = yield* decode(NotificationPage)(page ?? {});
+            const size = Math.min(decoded.size ?? options.maxPageSize, options.maxPageSize);
+            const rows = yield* store.list(mine(actor), {
+                size: size + 1,
+                ...(decoded.cursor === undefined ? {} : { after: decoded.cursor }),
+            });
+            const notifications = rows.slice(0, size);
+            const last = notifications[notifications.length - 1];
+            return rows.length > size && last !== undefined
+                ? { notifications, next: { createdAt: last.createdAt, id: last.id } }
+                : { notifications };
+        }),
+        unreadCount: (actor) => store.unreadCount(mine(actor)),
+        markRead: Effect.fn("Notifications.markRead")(function* (actor, notificationId) {
+            yield* UnitOfWork.required;
+            const id = yield* decode(Schema.NonEmptyString)(notificationId);
+            return readResult(yield* store.markRead(mine(actor), yield* now, id));
+        }),
+        markAllRead: Effect.fn("Notifications.markAllRead")(function* (actor) {
+            yield* UnitOfWork.required;
+            return readResult(yield* store.markRead(mine(actor), yield* now));
+        }),
+        getMyPreferences: Effect.fn("Notifications.getMyPreferences")(function* (actor) {
+            const saved = yield* store.preferences(mine(actor));
+            return {
+                preferences: options.categories.flatMap((category) => options.channels.map((channel) => ({
+                    category: category.name,
+                    channel,
+                    mode: modeFor(category, channel, saved),
+                }))),
+                quietHours: yield* store.quietHours(mine(actor)),
+                timeZone: yield* store.timeZone(mine(actor)),
+            };
+        }),
+        setMyPreference: Effect.fn("Notifications.setMyPreference")(function* (actor, preference) {
+            yield* UnitOfWork.required;
+            const decoded = yield* decode(Preference)(preference);
+            const category = categoryOf(decoded.category);
+            if (category === undefined || !options.channels.includes(decoded.channel))
+                return yield* invalid();
+            if ((decoded.channel === "inapp" || category.mandatory) && decoded.mode !== "immediate")
+                return yield* invalid();
+            yield* store.setPreference(mine(actor), decoded);
+            yield* refresh(mine(actor));
+        }),
+        setMyQuietHours: Effect.fn("Notifications.setMyQuietHours")(function* (actor, hours) {
+            yield* UnitOfWork.required;
+            const decoded = yield* decode(Schema.NullOr(QuietHours))(hours);
+            yield* store.setQuietHours(mine(actor), decoded);
+            yield* refresh(mine(actor));
+        }),
+        setMyTimeZone: Effect.fn("Notifications.setMyTimeZone")(function* (actor, timeZone) {
+            yield* UnitOfWork.required;
+            yield* store.setTimeZone(mine(actor), yield* decode(Schema.NullOr(TimeZone))(timeZone));
+            yield* refresh(mine(actor));
+        }),
+        dueDeliveries: Effect.fn("Notifications.dueDeliveries")(function* () {
+            const at = yield* now;
+            const rows = yield* store.due(at, options.maxDueBatch ?? 100);
+            const groups = new Map();
+            for (const row of rows) {
+                const { delivery } = row;
+                const recipientKey = JSON.stringify([delivery.recipient.kind, delivery.recipient.id]);
+                const key = delivery.mode === "immediate"
+                    ? delivery.id
+                    : JSON.stringify([recipientKey, delivery.channel, delivery.mode]);
+                const group = groups.get(key);
+                groups.set(key, {
+                    recipient: delivery.recipient,
+                    channel: delivery.channel,
+                    mode: group?.mode ?? delivery.mode,
+                    deliveries: [...(group?.deliveries ?? []), row],
+                });
+            }
+            return [...groups.values()];
+        }),
+        markSent: Effect.fn("Notifications.markSent")(function* (deliveryIds) {
+            yield* UnitOfWork.required;
+            const ids = yield* decode(Schema.Array(Schema.NonEmptyString))(deliveryIds);
+            yield* store.markSent(ids, yield* now);
+        }),
+        markFailed: Effect.fn("Notifications.markFailed")(function* (deliveryId, error) {
+            yield* UnitOfWork.required;
+            const id = yield* decode(Schema.NonEmptyString)(deliveryId);
+            const detail = yield* decode(Schema.String)(error);
+            yield* store.markFailed(id, detail, yield* now, {
+                maxAttempts: options.maxAttempts ?? 5,
+                baseMs: options.retryBaseMs ?? 1000,
+                capMs: options.retryCapMs ?? 3_600_000,
+            });
+        }),
+        erase: Effect.fn("Notifications.erase")(function* (recipient) {
+            yield* UnitOfWork.required;
+            yield* store.erase(yield* decode(Recipient)(recipient));
+        }),
+    };
+};

package/dist/notification/operations.d.ts

@@ -0,0 +1,185 @@
+import { Schema } from "effect";
+import { NotificationForbidden, NotificationInputInvalid, NotificationStoreUnavailable } from "./notification.js";
+export declare const NotificationsOperations: {
+    readonly notify: import("@house-rules/domain/contract").Operation<"Notifications.notify", Schema.Struct<{
+        readonly recipients: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+        readonly category: Schema.NonEmptyString;
+        readonly title: Schema.NonEmptyString;
+        readonly body: Schema.String;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly notifications: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly category: Schema.NonEmptyString;
+            readonly title: Schema.NonEmptyString;
+            readonly body: Schema.String;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly createdAt: Schema.Int;
+            readonly readAt: Schema.NullOr<Schema.Int>;
+        }>>;
+        readonly events: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literal<"NotificationCreated">;
+            readonly notificationId: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly channels: Schema.$Array<Schema.Literals<readonly ["inapp", "push", "email"]>>;
+        }>>;
+    }>, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly listMine: import("@house-rules/domain/contract").Operation<"Notifications.listMine", Schema.Struct<{
+        readonly page: Schema.optionalKey<Schema.Struct<{
+            readonly size: Schema.optionalKey<Schema.Int>;
+            readonly cursor: Schema.optionalKey<Schema.Struct<{
+                readonly createdAt: Schema.Int;
+                readonly id: Schema.NonEmptyString;
+            }>>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly notifications: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly category: Schema.NonEmptyString;
+            readonly title: Schema.NonEmptyString;
+            readonly body: Schema.String;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly createdAt: Schema.Int;
+            readonly readAt: Schema.NullOr<Schema.Int>;
+        }>>;
+        readonly next: Schema.optionalKey<Schema.Struct<{
+            readonly createdAt: Schema.Int;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+    }>, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly unreadCount: import("@house-rules/domain/contract").Operation<"Notifications.unreadCount", Schema.$Record<Schema.String, Schema.Never>, Schema.Int, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly markRead: import("@house-rules/domain/contract").Operation<"Notifications.markRead", Schema.Struct<{
+        readonly notificationId: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly notifications: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly category: Schema.NonEmptyString;
+            readonly title: Schema.NonEmptyString;
+            readonly body: Schema.String;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly createdAt: Schema.Int;
+            readonly readAt: Schema.NullOr<Schema.Int>;
+        }>>;
+        readonly events: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literal<"NotificationRead">;
+            readonly notificationId: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+        }>>;
+    }>, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly markAllRead: import("@house-rules/domain/contract").Operation<"Notifications.markAllRead", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+        readonly notifications: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly category: Schema.NonEmptyString;
+            readonly title: Schema.NonEmptyString;
+            readonly body: Schema.String;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly createdAt: Schema.Int;
+            readonly readAt: Schema.NullOr<Schema.Int>;
+        }>>;
+        readonly events: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literal<"NotificationRead">;
+            readonly notificationId: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+        }>>;
+    }>, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly getMyPreferences: import("@house-rules/domain/contract").Operation<"Notifications.getMyPreferences", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+        readonly preferences: Schema.$Array<Schema.Struct<{
+            readonly category: Schema.NonEmptyString;
+            readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+            readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+        }>>;
+        readonly quietHours: Schema.NullOr<Schema.Struct<{
+            readonly start: Schema.String;
+            readonly end: Schema.String;
+        }>>;
+        readonly timeZone: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly setMyPreference: import("@house-rules/domain/contract").Operation<"Notifications.setMyPreference", Schema.Struct<{
+        readonly category: Schema.NonEmptyString;
+        readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+        readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+    }>, Schema.Void, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly setMyQuietHours: import("@house-rules/domain/contract").Operation<"Notifications.setMyQuietHours", Schema.Struct<{
+        readonly quietHours: Schema.NullOr<Schema.Struct<{
+            readonly start: Schema.String;
+            readonly end: Schema.String;
+        }>>;
+    }>, Schema.Void, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly setMyTimeZone: import("@house-rules/domain/contract").Operation<"Notifications.setMyTimeZone", Schema.Struct<{
+        readonly timeZone: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Void, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly dueDeliveries: import("@house-rules/domain/contract").Operation<"Notifications.dueDeliveries", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+        readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily"]>;
+        readonly deliveries: Schema.$Array<Schema.Struct<{
+            readonly delivery: Schema.Struct<{
+                readonly id: Schema.NonEmptyString;
+                readonly notificationId: Schema.NonEmptyString;
+                readonly recipient: Schema.Struct<{
+                    readonly kind: Schema.NonEmptyString;
+                    readonly id: Schema.NonEmptyString;
+                }>;
+                readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+                readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily"]>;
+                readonly state: Schema.Literals<readonly ["pending", "held", "sent", "failed", "cancelled"]>;
+                readonly dueAt: Schema.Int;
+                readonly retryAt: Schema.NullOr<Schema.Int>;
+                readonly sentAt: Schema.NullOr<Schema.Int>;
+                readonly attempts: Schema.Int;
+                readonly lastError: Schema.NullOr<Schema.String>;
+            }>;
+            readonly notification: Schema.Struct<{
+                readonly id: Schema.NonEmptyString;
+                readonly recipient: Schema.Struct<{
+                    readonly kind: Schema.NonEmptyString;
+                    readonly id: Schema.NonEmptyString;
+                }>;
+                readonly category: Schema.NonEmptyString;
+                readonly title: Schema.NonEmptyString;
+                readonly body: Schema.String;
+                readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly createdAt: Schema.Int;
+                readonly readAt: Schema.NullOr<Schema.Int>;
+            }>;
+        }>>;
+    }>>, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly markSent: import("@house-rules/domain/contract").Operation<"Notifications.markSent", Schema.Struct<{
+        readonly deliveryIds: Schema.$Array<Schema.NonEmptyString>;
+    }>, Schema.Void, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly markFailed: import("@house-rules/domain/contract").Operation<"Notifications.markFailed", Schema.Struct<{
+        readonly deliveryId: Schema.NonEmptyString;
+        readonly error: Schema.String;
+    }>, Schema.Void, Schema.Union<readonly [typeof NotificationForbidden, typeof NotificationInputInvalid, typeof NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+};