@timothyw/pat-common 1.0.101 → 1.0.102

package/dist/types/api/people/create-person-note-types.d.ts

@@ -5,13 +5,13 @@ export declare const createPersonNoteRequestSchema: z.ZodObject<{
     personId: z.ZodEffects<z.ZodString, import("../../id-types").PersonId, string>;
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    content: string;
     personId: string & {
         readonly __brand: "PersonId";
     };
-    content: string;
 }, {
-    personId: string;
     content: string;
+    personId: string;
 }>;
 export type CreatePersonNoteRequest = z.infer<typeof createPersonNoteRequestSchema>;
 export interface CreatePersonNoteResponse {

package/dist/types/id-types.d.ts

@@ -39,3 +39,11 @@ export declare const habitEntryIdSchema: z.ZodEffects<z.ZodString, TaskListId, s
 export type HabitEntryId = string & {
     readonly __brand: "HabitEntryId";
 };
+export declare const notificationTemplateIdSchema: z.ZodEffects<z.ZodString, NotificationTemplateId, string>;
+export type NotificationTemplateId = string & {
+    readonly __brand: "NotificationTemplateId";
+};
+export declare const notificationInstanceIdSchema: z.ZodEffects<z.ZodString, NotificationInstanceId, string>;
+export type NotificationInstanceId = string & {
+    readonly __brand: "NotificationInstanceId";
+};

package/dist/types/id-types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.habitEntryIdSchema = exports.habitIdSchema = exports.taskIdSchema = exports.taskListIdSchema = exports.thoughtIdSchema = exports.personNoteIdSchema = exports.personIdSchema = exports.itemIdSchema = exports.authIdSchema = exports.userIdSchema = void 0;
+exports.notificationInstanceIdSchema = exports.notificationTemplateIdSchema = exports.habitEntryIdSchema = exports.habitIdSchema = exports.taskIdSchema = exports.taskListIdSchema = exports.thoughtIdSchema = exports.personNoteIdSchema = exports.personIdSchema = exports.itemIdSchema = exports.authIdSchema = exports.userIdSchema = void 0;
 const zod_1 = require("zod");
 exports.userIdSchema = zod_1.z.string().transform((val) => val);
 exports.authIdSchema = zod_1.z.string().transform((val) => val);
@@ -12,3 +12,5 @@ exports.taskListIdSchema = zod_1.z.string().transform((val) => val);
 exports.taskIdSchema = zod_1.z.string().transform((val) => val);
 exports.habitIdSchema = zod_1.z.string().transform((val) => val);
 exports.habitEntryIdSchema = zod_1.z.string().transform((val) => val);
+exports.notificationTemplateIdSchema = zod_1.z.string().transform((val) => val);
+exports.notificationInstanceIdSchema = zod_1.z.string().transform((val) => val);

package/dist/types/models/index.d.ts

@@ -1,6 +1,9 @@
 export * from './auth-data';
 export * from './habit-data';
 export * from './item-data';
+export * from './notification-template-data';
+export * from './notification-instance-data';
+export * from './notifiable';
 export * from './person-data';
 export * from './program-config';
 export * from './task-data';

package/dist/types/models/index.js

@@ -17,6 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth-data"), exports);
 __exportStar(require("./habit-data"), exports);
 __exportStar(require("./item-data"), exports);
+__exportStar(require("./notification-template-data"), exports);
+__exportStar(require("./notification-instance-data"), exports);
+__exportStar(require("./notifiable"), exports);
 __exportStar(require("./person-data"), exports);
 __exportStar(require("./program-config"), exports);
 __exportStar(require("./task-data"), exports);

package/dist/types/models/notifiable.d.ts

@@ -0,0 +1,42 @@
+import { NotificationTemplateData, NotificationEntityType } from "./notification-template-data";
+export interface NotificationContext<T = any> {
+    entityId: string;
+    entityType: NotificationEntityType;
+    entityData: T;
+    userId: string;
+    variables: Record<string, any>;
+}
+export interface INotifiable<T = any> {
+    /**
+     * Get the ID of this notifiable entity
+     */
+    getId(): string;
+    /**
+     * Get the entity type for notification purposes
+     */
+    getNotificationEntityType(): NotificationEntityType;
+    /**
+     * Get context data for notification template variables
+     */
+    getNotificationContext(): NotificationContext<T>;
+    /**
+     * Get inherited notification templates from parent entities
+     */
+    getInheritedNotificationTemplates(): Promise<NotificationTemplateData[]>;
+    /**
+     * Get custom notification templates specific to this entity
+     */
+    getCustomNotificationTemplates(): Promise<NotificationTemplateData[]>;
+    /**
+     * Get all effective notification templates (inherited + custom)
+     */
+    getAllNotificationTemplates(): Promise<NotificationTemplateData[]>;
+    /**
+     * Register notification triggers when entity is created/updated
+     */
+    registerNotificationTriggers(): Promise<void>;
+    /**
+     * Remove notification triggers when entity is deleted
+     */
+    removeNotificationTriggers(): Promise<void>;
+}

package/dist/types/models/notifiable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/models/notification-instance-data.d.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { NotificationInstanceId, NotificationTemplateId, UserId } from "../id-types";
+export declare const notificationStatusSchema: z.ZodEnum<["scheduled", "sent", "failed", "cancelled"]>;
+export type NotificationStatus = z.infer<typeof notificationStatusSchema>;
+export declare const notificationInstanceDataSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, NotificationInstanceId, string>;
+    templateId: z.ZodEffects<z.ZodString, NotificationTemplateId, string>;
+    userId: z.ZodEffects<z.ZodString, UserId, string>;
+    entityId: z.ZodString;
+    scheduledFor: z.ZodDate;
+    status: z.ZodEnum<["scheduled", "sent", "failed", "cancelled"]>;
+    sentAt: z.ZodOptional<z.ZodDate>;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    }, {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    }>;
+    redisId: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "NotificationInstanceId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    status: "scheduled" | "sent" | "failed" | "cancelled";
+    entityId: string;
+    content: {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    };
+    templateId: string & {
+        readonly __brand: "NotificationTemplateId";
+    };
+    scheduledFor: Date;
+    redisId: string;
+    sentAt?: Date | undefined;
+    error?: string | undefined;
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    status: "scheduled" | "sent" | "failed" | "cancelled";
+    entityId: string;
+    content: {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    };
+    templateId: string;
+    scheduledFor: Date;
+    redisId: string;
+    sentAt?: Date | undefined;
+    error?: string | undefined;
+}>;
+export type NotificationInstanceData = z.infer<typeof notificationInstanceDataSchema>;
+export declare const createNotificationInstanceSchema: z.ZodObject<Omit<{
+    _id: z.ZodEffects<z.ZodString, NotificationInstanceId, string>;
+    templateId: z.ZodEffects<z.ZodString, NotificationTemplateId, string>;
+    userId: z.ZodEffects<z.ZodString, UserId, string>;
+    entityId: z.ZodString;
+    scheduledFor: z.ZodDate;
+    status: z.ZodEnum<["scheduled", "sent", "failed", "cancelled"]>;
+    sentAt: z.ZodOptional<z.ZodDate>;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    }, {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    }>;
+    redisId: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "_id" | "createdAt" | "updatedAt" | "status" | "sentAt" | "error"> & {
+    status: z.ZodDefault<z.ZodEnum<["scheduled", "sent", "failed", "cancelled"]>>;
+}, "strip", z.ZodTypeAny, {
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    status: "scheduled" | "sent" | "failed" | "cancelled";
+    entityId: string;
+    content: {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    };
+    templateId: string & {
+        readonly __brand: "NotificationTemplateId";
+    };
+    scheduledFor: Date;
+    redisId: string;
+}, {
+    userId: string;
+    entityId: string;
+    content: {
+        title: string;
+        body: string;
+        data?: Record<string, any> | undefined;
+    };
+    templateId: string;
+    scheduledFor: Date;
+    redisId: string;
+    status?: "scheduled" | "sent" | "failed" | "cancelled" | undefined;
+}>;
+export type CreateNotificationInstanceData = z.infer<typeof createNotificationInstanceSchema>;

package/dist/types/models/notification-instance-data.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotificationInstanceSchema = exports.notificationInstanceDataSchema = exports.notificationStatusSchema = void 0;
+const zod_1 = require("zod");
+exports.notificationStatusSchema = zod_1.z.enum(['scheduled', 'sent', 'failed', 'cancelled']);
+exports.notificationInstanceDataSchema = zod_1.z.object({
+    _id: zod_1.z.string().transform((val) => val),
+    templateId: zod_1.z.string().transform((val) => val),
+    userId: zod_1.z.string().transform((val) => val),
+    entityId: zod_1.z.string(), // ID of the specific entity this notification is for
+    scheduledFor: zod_1.z.date(),
+    status: exports.notificationStatusSchema,
+    sentAt: zod_1.z.date().optional(),
+    content: zod_1.z.object({
+        title: zod_1.z.string(),
+        body: zod_1.z.string(),
+        data: zod_1.z.record(zod_1.z.any()).optional() // additional data for the notification
+    }),
+    redisId: zod_1.z.string(), // link to Redis scheduled notification for coordination
+    error: zod_1.z.string().optional(), // error message if status is 'failed'
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date()
+});
+// Helper type for creating new instances (without _id, dates, status)
+exports.createNotificationInstanceSchema = exports.notificationInstanceDataSchema.omit({
+    _id: true,
+    status: true,
+    sentAt: true,
+    error: true,
+    createdAt: true,
+    updatedAt: true
+}).extend({
+    status: exports.notificationStatusSchema.default('scheduled')
+});

package/dist/types/models/notification-template-data.d.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+import { NotificationTemplateId, UserId } from "../id-types";
+export declare const notificationEntityTypeSchema: z.ZodEnum<["agenda", "tasks", "habits", "agenda_item", "task_list", "task", "habit"]>;
+export type NotificationEntityType = z.infer<typeof notificationEntityTypeSchema>;
+export declare const notificationTriggerTypeSchema: z.ZodEnum<["time_based", "event_based", "recurring"]>;
+export type NotificationTriggerType = z.infer<typeof notificationTriggerTypeSchema>;
+export declare const notificationTriggerSchema: z.ZodObject<{
+    type: z.ZodEnum<["time_based", "event_based", "recurring"]>;
+    conditions: z.ZodRecord<z.ZodString, z.ZodAny>;
+    timing: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type: "time_based" | "event_based" | "recurring";
+    conditions: Record<string, any>;
+    timing: Record<string, any>;
+}, {
+    type: "time_based" | "event_based" | "recurring";
+    conditions: Record<string, any>;
+    timing: Record<string, any>;
+}>;
+export type NotificationTrigger = z.infer<typeof notificationTriggerSchema>;
+export declare const notificationContentSchema: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    body: string;
+    variables?: Record<string, string> | undefined;
+}, {
+    title: string;
+    body: string;
+    variables?: Record<string, string> | undefined;
+}>;
+export type NotificationContent = z.infer<typeof notificationContentSchema>;
+export declare const notificationTemplateDataSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, NotificationTemplateId, string>;
+    userId: z.ZodEffects<z.ZodString, UserId, string>;
+    entityType: z.ZodEnum<["agenda", "tasks", "habits", "agenda_item", "task_list", "task", "habit"]>;
+    entityId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodObject<{
+        type: z.ZodEnum<["time_based", "event_based", "recurring"]>;
+        conditions: z.ZodRecord<z.ZodString, z.ZodAny>;
+        timing: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    }, {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    }>;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    }, {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    }>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    inheritedFrom: z.ZodOptional<z.ZodEffects<z.ZodString, NotificationTemplateId, string>>;
+    customized: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "NotificationTemplateId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    entityType: "agenda" | "tasks" | "habits" | "agenda_item" | "task_list" | "task" | "habit";
+    name: string;
+    trigger: {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    };
+    content: {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    };
+    active: boolean;
+    customized: boolean;
+    entityId?: string | undefined;
+    description?: string | undefined;
+    inheritedFrom?: NotificationTemplateId | undefined;
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    entityType: "agenda" | "tasks" | "habits" | "agenda_item" | "task_list" | "task" | "habit";
+    name: string;
+    trigger: {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    };
+    content: {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    };
+    entityId?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    inheritedFrom?: string | undefined;
+    customized?: boolean | undefined;
+}>;
+export type NotificationTemplateData = z.infer<typeof notificationTemplateDataSchema>;
+export declare const createNotificationTemplateSchema: z.ZodObject<Omit<{
+    _id: z.ZodEffects<z.ZodString, NotificationTemplateId, string>;
+    userId: z.ZodEffects<z.ZodString, UserId, string>;
+    entityType: z.ZodEnum<["agenda", "tasks", "habits", "agenda_item", "task_list", "task", "habit"]>;
+    entityId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodObject<{
+        type: z.ZodEnum<["time_based", "event_based", "recurring"]>;
+        conditions: z.ZodRecord<z.ZodString, z.ZodAny>;
+        timing: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    }, {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    }>;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    }, {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    }>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    inheritedFrom: z.ZodOptional<z.ZodEffects<z.ZodString, NotificationTemplateId, string>>;
+    customized: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "_id" | "createdAt" | "updatedAt">, "strip", z.ZodTypeAny, {
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    entityType: "agenda" | "tasks" | "habits" | "agenda_item" | "task_list" | "task" | "habit";
+    name: string;
+    trigger: {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    };
+    content: {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    };
+    active: boolean;
+    customized: boolean;
+    entityId?: string | undefined;
+    description?: string | undefined;
+    inheritedFrom?: NotificationTemplateId | undefined;
+}, {
+    userId: string;
+    entityType: "agenda" | "tasks" | "habits" | "agenda_item" | "task_list" | "task" | "habit";
+    name: string;
+    trigger: {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    };
+    content: {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    };
+    entityId?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    inheritedFrom?: string | undefined;
+    customized?: boolean | undefined;
+}>;
+export type CreateNotificationTemplateData = z.infer<typeof createNotificationTemplateSchema>;

package/dist/types/models/notification-template-data.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotificationTemplateSchema = exports.notificationTemplateDataSchema = exports.notificationContentSchema = exports.notificationTriggerSchema = exports.notificationTriggerTypeSchema = exports.notificationEntityTypeSchema = void 0;
+const zod_1 = require("zod");
+exports.notificationEntityTypeSchema = zod_1.z.enum(['agenda', 'tasks', 'habits', 'agenda_item', 'task_list', 'task', 'habit']);
+exports.notificationTriggerTypeSchema = zod_1.z.enum(['time_based', 'event_based', 'recurring']);
+exports.notificationTriggerSchema = zod_1.z.object({
+    type: exports.notificationTriggerTypeSchema,
+    conditions: zod_1.z.record(zod_1.z.any()), // flexible conditions object
+    timing: zod_1.z.record(zod_1.z.any()) // timing configuration like "5 minutes before due"
+});
+exports.notificationContentSchema = zod_1.z.object({
+    title: zod_1.z.string(),
+    body: zod_1.z.string(),
+    // Support for template variables like {{entity.name}}
+    variables: zod_1.z.record(zod_1.z.string()).optional()
+});
+exports.notificationTemplateDataSchema = zod_1.z.object({
+    _id: zod_1.z.string().transform((val) => val),
+    userId: zod_1.z.string().transform((val) => val),
+    entityType: exports.notificationEntityTypeSchema,
+    entityId: zod_1.z.string().optional(), // null/undefined for panel-level templates
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    trigger: exports.notificationTriggerSchema,
+    content: exports.notificationContentSchema,
+    active: zod_1.z.boolean().default(true),
+    inheritedFrom: zod_1.z.string().transform((val) => val).optional(),
+    customized: zod_1.z.boolean().default(false), // true if user modified inherited template
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date()
+});
+// Helper type for creating new templates (without _id, dates)
+exports.createNotificationTemplateSchema = exports.notificationTemplateDataSchema.omit({
+    _id: true,
+    createdAt: true,
+    updatedAt: true
+});

package/dist/types/models/user-data.d.ts

@@ -95,13 +95,13 @@ export declare const userDataSchema: z.ZodObject<{
     };
     createdAt: Date;
     updatedAt: Date;
+    name: string;
     sandbox: {
         devices: {
             pushToken: string;
         }[];
         discordId?: string | undefined;
     };
-    name: string;
     timezone: string;
     config: {
         agenda: {
@@ -120,13 +120,13 @@ export declare const userDataSchema: z.ZodObject<{
     _id: string;
     createdAt: Date;
     updatedAt: Date;
+    name: string;
     sandbox: {
         devices: {
             pushToken: string;
         }[];
         discordId?: string | undefined;
     };
-    name: string;
     timezone: string;
     config: {
         agenda: {

package/dist/utils/serializing-utils.d.ts

@@ -1,4 +1,4 @@
-import { Habit, HabitData, HabitEntry, HabitEntryData, ItemData, Person, PersonData, PersonNoteData, TaskData, TaskListData, ThoughtData, UserData } from "../types";
+import { Habit, HabitData, HabitEntry, HabitEntryData, ItemData, Person, PersonData, PersonNoteData, NotificationTemplateData, NotificationInstanceData, TaskData, TaskListData, ThoughtData, UserData } from "../types";
 export type Serialized<T> = T extends Date ? string : T extends Date | undefined ? string | undefined : T extends Date | null ? string | null : T extends (infer U)[] ? Serialized<U>[] : T extends object ? {
     [K in keyof T]: Serialized<T[K]>;
 } : T;
@@ -29,4 +29,8 @@ export declare class Serializer {
     static deserializeThoughtData(data: Serialized<ThoughtData>): ThoughtData;
     static serializeUserData(data: UserData): Serialized<UserData>;
     static deserializeUserData(data: Serialized<UserData>): UserData;
+    static serializeNotificationTemplateData(data: NotificationTemplateData): Serialized<NotificationTemplateData>;
+    static deserializeNotificationTemplateData(data: Serialized<NotificationTemplateData>): NotificationTemplateData;
+    static serializeNotificationInstanceData(data: NotificationInstanceData): Serialized<NotificationInstanceData>;
+    static deserializeNotificationInstanceData(data: Serialized<NotificationInstanceData>): NotificationInstanceData;
 }

package/dist/utils/serializing-utils.js

@@ -80,6 +80,18 @@ class Serializer {
     static deserializeUserData(data) {
         return this.deserialize(data);
     }
+    static serializeNotificationTemplateData(data) {
+        return this.serialize(data);
+    }
+    static deserializeNotificationTemplateData(data) {
+        return this.deserialize(data);
+    }
+    static serializeNotificationInstanceData(data) {
+        return this.serialize(data);
+    }
+    static deserializeNotificationInstanceData(data) {
+        return this.deserialize(data);
+    }
 }
 exports.Serializer = Serializer;
 function serializeRecursive(obj) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@timothyw/pat-common",
   "description": "",
   "author": "Timothy Washburn",
-  "version": "1.0.101",
+  "version": "1.0.102",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/enums/module-type.ts

@@ -5,5 +5,6 @@ export enum ModuleType {
     HABITS = 'habits',
     PEOPLE = 'people',
     SETTINGS = 'settings',
+    NOTIFICATIONS = 'notifications',
     DEV = 'dev'
 }

package/src/types/api/auth/create-account-types.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { UserId } from "../../id-types";
 
 export const createAccountRequestSchema = z.object({
     name: z.string().trim().min(1),
@@ -10,7 +11,7 @@ export const createAccountRequestSchema = z.object({
 export type CreateAccountRequest = z.infer<typeof createAccountRequestSchema>;
 
 export interface CreateAccountResponse {
-    id: string;
+    id: UserId;
     name: string;
     email: string;
 }

package/src/types/api/index.ts

@@ -3,6 +3,7 @@ export * from './auth'
 export * from './habits'
 export * from './items'
 export * from './misc'
+export * from './notifications'
 export * from './people'
 export * from './tasks'
 export * from './thoughts'

package/src/types/api/notifications/create-notification-template-types.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData, CreateNotificationTemplateData, notificationEntityTypeSchema, notificationTriggerTypeSchema } from "../../models/notification-template-data";
+
+// Request schema
+export const createNotificationTemplateRequestSchema = z.object({
+    entityType: notificationEntityTypeSchema,
+    entityId: z.string().optional(),
+    name: z.string().min(1).max(100),
+    description: z.string().max(500).optional(),
+    trigger: z.object({
+        type: notificationTriggerTypeSchema,
+        conditions: z.record(z.any()),
+        timing: z.record(z.any())
+    }),
+    content: z.object({
+        title: z.string().min(1).max(200),
+        body: z.string().min(1).max(1000),
+        variables: z.record(z.string()).optional()
+    }),
+    active: z.boolean().default(true),
+    inheritedFrom: z.string().optional(),
+    customized: z.boolean().default(false)
+});
+
+export type CreateNotificationTemplateRequest = z.infer<typeof createNotificationTemplateRequestSchema>;
+
+// Response schema
+export const createNotificationTemplateResponseSchema = z.object({
+    success: z.boolean(),
+    template: z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: z.string().optional()
+});
+
+export type CreateNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};