@timothyw/pat-common 1.0.100 → 1.0.102

package/dist/enums/module-type.d.ts

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

package/dist/enums/module-type.js

@@ -9,5 +9,6 @@ var ModuleType;
     ModuleType["HABITS"] = "habits";
     ModuleType["PEOPLE"] = "people";
     ModuleType["SETTINGS"] = "settings";
+    ModuleType["NOTIFICATIONS"] = "notifications";
     ModuleType["DEV"] = "dev";
 })(ModuleType || (exports.ModuleType = ModuleType = {}));

package/dist/types/api/account/update-user-types.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { UserData } from "../../models";
 import { Serialized } from "../../../utils";
 export declare const updateUserRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
     sandbox: z.ZodOptional<z.ZodObject<{
         discordId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         devices: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -22,7 +23,6 @@ export declare const updateUserRequestSchema: z.ZodObject<{
             pushToken?: string | undefined;
         }[] | undefined;
     }>>;
-    name: z.ZodOptional<z.ZodString>;
     timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     config: z.ZodOptional<z.ZodObject<{
         modules: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -78,13 +78,13 @@ export declare const updateUserRequestSchema: z.ZodObject<{
         }[] | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
+    name?: string | undefined;
     sandbox?: {
         discordId?: string | undefined;
         devices?: {
             pushToken?: string | undefined;
         }[] | undefined;
     } | undefined;
-    name?: string | undefined;
     timezone?: string | undefined;
     config?: {
         agenda?: {
@@ -100,13 +100,13 @@ export declare const updateUserRequestSchema: z.ZodObject<{
         }[] | undefined;
     } | undefined;
 }, {
+    name?: string | undefined;
     sandbox?: {
         discordId?: string | undefined;
         devices?: {
             pushToken?: string | undefined;
         }[] | undefined;
     } | undefined;
-    name?: string | undefined;
     timezone?: string | undefined;
     config?: {
         agenda?: {

package/dist/types/api/auth/create-account-types.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { UserId } from "../../id-types";
 export declare const createAccountRequestSchema: z.ZodObject<{
     name: z.ZodString;
     email: z.ZodString;
@@ -17,7 +18,7 @@ export declare const createAccountRequestSchema: z.ZodObject<{
 }>;
 export type CreateAccountRequest = z.infer<typeof createAccountRequestSchema>;
 export interface CreateAccountResponse {
-    id: string;
+    id: UserId;
     name: string;
     email: string;
 }

package/dist/types/api/habits/create-habit-types.d.ts

@@ -11,14 +11,14 @@ export declare const createHabitRequestSchema: z.ZodObject<{
     name: string;
     frequency: HabitFrequency;
     rolloverTime: string;
-    notes?: string | undefined;
     description?: string | undefined;
+    notes?: string | undefined;
 }, {
     name: string;
     frequency: HabitFrequency;
     rolloverTime: string;
-    notes?: string | undefined;
     description?: string | undefined;
+    notes?: string | undefined;
 }>;
 export type CreateHabitRequest = z.infer<typeof createHabitRequestSchema>;
 export interface CreateHabitResponse {

package/dist/types/api/habits/update-habit-types.d.ts

@@ -9,14 +9,14 @@ export declare const updateHabitRequestSchema: z.ZodObject<{
     rolloverTime: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
-    notes?: string | null | undefined;
     description?: string | null | undefined;
+    notes?: string | null | undefined;
     frequency?: HabitFrequency | undefined;
     rolloverTime?: string | undefined;
 }, {
     name?: string | undefined;
-    notes?: string | null | undefined;
     description?: string | null | undefined;
+    notes?: string | null | undefined;
     frequency?: HabitFrequency | undefined;
     rolloverTime?: string | undefined;
 }>;

package/dist/types/api/index.d.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/dist/types/api/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./auth"), exports);
 __exportStar(require("./habits"), exports);
 __exportStar(require("./items"), exports);
 __exportStar(require("./misc"), exports);
+__exportStar(require("./notifications"), exports);
 __exportStar(require("./people"), exports);
 __exportStar(require("./tasks"), exports);
 __exportStar(require("./thoughts"), exports);

package/dist/types/api/notifications/create-notification-template-types.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData } from "../../models/notification-template-data";
+export declare const createNotificationTemplateRequestSchema: z.ZodObject<{
+    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.ZodString>;
+    customized: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    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?: string | undefined;
+}, {
+    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 CreateNotificationTemplateRequest = z.infer<typeof createNotificationTemplateRequestSchema>;
+export declare const createNotificationTemplateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    template: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    template?: any;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    template?: any;
+}>;
+export type CreateNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};

package/dist/types/api/notifications/create-notification-template-types.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotificationTemplateResponseSchema = exports.createNotificationTemplateRequestSchema = void 0;
+const zod_1 = require("zod");
+const notification_template_data_1 = require("../../models/notification-template-data");
+// Request schema
+exports.createNotificationTemplateRequestSchema = zod_1.z.object({
+    entityType: notification_template_data_1.notificationEntityTypeSchema,
+    entityId: zod_1.z.string().optional(),
+    name: zod_1.z.string().min(1).max(100),
+    description: zod_1.z.string().max(500).optional(),
+    trigger: zod_1.z.object({
+        type: notification_template_data_1.notificationTriggerTypeSchema,
+        conditions: zod_1.z.record(zod_1.z.any()),
+        timing: zod_1.z.record(zod_1.z.any())
+    }),
+    content: zod_1.z.object({
+        title: zod_1.z.string().min(1).max(200),
+        body: zod_1.z.string().min(1).max(1000),
+        variables: zod_1.z.record(zod_1.z.string()).optional()
+    }),
+    active: zod_1.z.boolean().default(true),
+    inheritedFrom: zod_1.z.string().optional(),
+    customized: zod_1.z.boolean().default(false)
+});
+// Response schema
+exports.createNotificationTemplateResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    template: zod_1.z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: zod_1.z.string().optional()
+});

package/dist/types/api/notifications/delete-notification-template-types.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const deleteNotificationTemplateRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type DeleteNotificationTemplateRequest = z.infer<typeof deleteNotificationTemplateRequestSchema>;
+export declare const deleteNotificationTemplateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+}>;
+export type DeleteNotificationTemplateResponse = z.infer<typeof deleteNotificationTemplateResponseSchema>;

package/dist/types/api/notifications/delete-notification-template-types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteNotificationTemplateResponseSchema = exports.deleteNotificationTemplateRequestSchema = void 0;
+const zod_1 = require("zod");
+// Request schema - no body needed for DELETE
+exports.deleteNotificationTemplateRequestSchema = zod_1.z.object({});
+// Response schema
+exports.deleteNotificationTemplateResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    error: zod_1.z.string().optional()
+});

package/dist/types/api/notifications/get-notification-instances-types.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationInstanceData } from "../../models/notification-instance-data";
+export declare const getNotificationInstancesRequestSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    templateId: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status?: string | undefined;
+    entityId?: string | undefined;
+    templateId?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    status?: string | undefined;
+    entityId?: string | undefined;
+    templateId?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type GetNotificationInstancesRequest = z.infer<typeof getNotificationInstancesRequestSchema>;
+export declare const getNotificationInstancesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    instances: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    total: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    instances?: any[] | undefined;
+    total?: number | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    instances?: any[] | undefined;
+    total?: number | undefined;
+}>;
+export type GetNotificationInstancesResponse = {
+    success: boolean;
+    instances?: Serialized<NotificationInstanceData>[];
+    total?: number;
+    error?: string;
+};

package/dist/types/api/notifications/get-notification-instances-types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNotificationInstancesResponseSchema = exports.getNotificationInstancesRequestSchema = void 0;
+const zod_1 = require("zod");
+// Request schema - query parameters
+exports.getNotificationInstancesRequestSchema = zod_1.z.object({
+    status: zod_1.z.string().optional(), // filter by status
+    templateId: zod_1.z.string().optional(), // filter by template
+    entityId: zod_1.z.string().optional(), // filter by entity
+    limit: zod_1.z.number().optional(), // pagination
+    offset: zod_1.z.number().optional() // pagination
+});
+// Response schema
+exports.getNotificationInstancesResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    instances: zod_1.z.array(zod_1.z.any()).optional(), // Will be Serialized<NotificationInstanceData>[]
+    total: zod_1.z.number().optional(),
+    error: zod_1.z.string().optional()
+});

package/dist/types/api/notifications/get-notification-templates-types.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData } from "../../models/notification-template-data";
+export declare const getNotificationTemplatesRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type GetNotificationTemplatesRequest = z.infer<typeof getNotificationTemplatesRequestSchema>;
+export declare const getNotificationTemplatesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    templates: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    templates?: any[] | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    templates?: any[] | undefined;
+}>;
+export type GetNotificationTemplatesResponse = {
+    success: boolean;
+    templates?: Serialized<NotificationTemplateData>[];
+    error?: string;
+};

package/dist/types/api/notifications/get-notification-templates-types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNotificationTemplatesResponseSchema = exports.getNotificationTemplatesRequestSchema = void 0;
+const zod_1 = require("zod");
+// Request schema - no body needed for GET
+exports.getNotificationTemplatesRequestSchema = zod_1.z.object({});
+// Response schema
+exports.getNotificationTemplatesResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    templates: zod_1.z.array(zod_1.z.any()).optional(), // Will be Serialized<NotificationTemplateData>[]
+    error: zod_1.z.string().optional()
+});

package/dist/types/api/notifications/index.d.ts

@@ -0,0 +1,7 @@
+export * from './get-notification-templates-types';
+export * from './create-notification-template-types';
+export * from './update-notification-template-types';
+export * from './delete-notification-template-types';
+export * from './get-notification-instances-types';
+export * from './preview-notification-template-types';
+export * from './sync-notification-template-types';

package/dist/types/api/notifications/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-notification-templates-types"), exports);
+__exportStar(require("./create-notification-template-types"), exports);
+__exportStar(require("./update-notification-template-types"), exports);
+__exportStar(require("./delete-notification-template-types"), exports);
+__exportStar(require("./get-notification-instances-types"), exports);
+__exportStar(require("./preview-notification-template-types"), exports);
+__exportStar(require("./sync-notification-template-types"), exports);

package/dist/types/api/notifications/preview-notification-template-types.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const previewNotificationTemplateRequestSchema: z.ZodObject<{
+    templateTitle: z.ZodString;
+    templateBody: z.ZodString;
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    entityType: string;
+    entityId: string;
+    templateTitle: string;
+    templateBody: string;
+    variables?: Record<string, any> | undefined;
+}, {
+    entityType: string;
+    entityId: string;
+    templateTitle: string;
+    templateBody: string;
+    variables?: Record<string, any> | undefined;
+}>;
+export type PreviewNotificationTemplateRequest = z.infer<typeof previewNotificationTemplateRequestSchema>;
+export declare const previewNotificationTemplateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    preview: z.ZodOptional<z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        body: string;
+        variables: Record<string, any>;
+    }, {
+        title: string;
+        body: string;
+        variables: Record<string, any>;
+    }>>;
+    missingVariables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    preview?: {
+        title: string;
+        body: string;
+        variables: Record<string, any>;
+    } | undefined;
+    missingVariables?: string[] | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    preview?: {
+        title: string;
+        body: string;
+        variables: Record<string, any>;
+    } | undefined;
+    missingVariables?: string[] | undefined;
+}>;
+export type PreviewNotificationTemplateResponse = z.infer<typeof previewNotificationTemplateResponseSchema>;

package/dist/types/api/notifications/preview-notification-template-types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewNotificationTemplateResponseSchema = exports.previewNotificationTemplateRequestSchema = void 0;
+const zod_1 = require("zod");
+// Request schema
+exports.previewNotificationTemplateRequestSchema = zod_1.z.object({
+    templateTitle: zod_1.z.string(),
+    templateBody: zod_1.z.string(),
+    entityType: zod_1.z.string(),
+    entityId: zod_1.z.string(),
+    variables: zod_1.z.record(zod_1.z.any()).optional()
+});
+// Response schema
+exports.previewNotificationTemplateResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    preview: zod_1.z.object({
+        title: zod_1.z.string(),
+        body: zod_1.z.string(),
+        variables: zod_1.z.record(zod_1.z.any())
+    }).optional(),
+    missingVariables: zod_1.z.array(zod_1.z.string()).optional(),
+    error: zod_1.z.string().optional()
+});

package/dist/types/api/notifications/sync-notification-template-types.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData } from "../../models/notification-template-data";
+export declare const syncNotificationTemplateRequestSchema: z.ZodObject<{
+    sync: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    sync: boolean;
+}, {
+    sync: boolean;
+}>;
+export type SyncNotificationTemplateRequest = z.infer<typeof syncNotificationTemplateRequestSchema>;
+export declare const syncNotificationTemplateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    template: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    template?: any;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    template?: any;
+}>;
+export type SyncNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};

package/dist/types/api/notifications/sync-notification-template-types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncNotificationTemplateResponseSchema = exports.syncNotificationTemplateRequestSchema = void 0;
+const zod_1 = require("zod");
+// Request schema
+exports.syncNotificationTemplateRequestSchema = zod_1.z.object({
+    sync: zod_1.z.boolean() // true to sync with parent, false to unsync
+});
+// Response schema
+exports.syncNotificationTemplateResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    template: zod_1.z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: zod_1.z.string().optional()
+});

package/dist/types/api/notifications/update-notification-template-types.d.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData } from "../../models/notification-template-data";
+export declare const updateNotificationTemplateRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<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.ZodOptional<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.ZodOptional<z.ZodBoolean>;
+    customized: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    trigger?: {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    } | undefined;
+    content?: {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    } | undefined;
+    active?: boolean | undefined;
+    customized?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    trigger?: {
+        type: "time_based" | "event_based" | "recurring";
+        conditions: Record<string, any>;
+        timing: Record<string, any>;
+    } | undefined;
+    content?: {
+        title: string;
+        body: string;
+        variables?: Record<string, string> | undefined;
+    } | undefined;
+    active?: boolean | undefined;
+    customized?: boolean | undefined;
+}>;
+export type UpdateNotificationTemplateRequest = z.infer<typeof updateNotificationTemplateRequestSchema>;
+export declare const updateNotificationTemplateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    template: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    template?: any;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    template?: any;
+}>;
+export type UpdateNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};

package/dist/types/api/notifications/update-notification-template-types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNotificationTemplateResponseSchema = exports.updateNotificationTemplateRequestSchema = void 0;
+const zod_1 = require("zod");
+const notification_template_data_1 = require("../../models/notification-template-data");
+// Request schema
+exports.updateNotificationTemplateRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(100).optional(),
+    description: zod_1.z.string().max(500).optional(),
+    trigger: zod_1.z.object({
+        type: notification_template_data_1.notificationTriggerTypeSchema,
+        conditions: zod_1.z.record(zod_1.z.any()),
+        timing: zod_1.z.record(zod_1.z.any())
+    }).optional(),
+    content: zod_1.z.object({
+        title: zod_1.z.string().min(1).max(200),
+        body: zod_1.z.string().min(1).max(1000),
+        variables: zod_1.z.record(zod_1.z.string()).optional()
+    }).optional(),
+    active: zod_1.z.boolean().optional(),
+    customized: zod_1.z.boolean().optional()
+});
+// Response schema
+exports.updateNotificationTemplateResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    template: zod_1.z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: zod_1.z.string().optional()
+});