@timothyw/pat-common 1.0.121 → 1.0.122

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './enums';
 export * from './types';
 export * from './utils';
+export * from './notification-entity-registry';

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./enums"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./notification-entity-registry"), exports);

package/dist/notification-entity-registry.d.ts

@@ -0,0 +1,77 @@
+import { NotificationEntityConfig, ParentResolutionResult } from './types/notification-entity-config';
+/**
+ * Registry for managing notification entity configurations and parent resolution
+ */
+export declare class NotificationEntityRegistry {
+    private static instance;
+    private entityConfigs;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): NotificationEntityRegistry;
+    /**
+     * Register a new entity configuration
+     */
+    registerEntity(config: NotificationEntityConfig): void;
+    /**
+     * Get configuration for an entity type
+     */
+    getEntityConfig(entityType: string): NotificationEntityConfig | null;
+    /**
+     * Get all registered entity types
+     */
+    getEntityTypes(): string[];
+    /**
+     * Get all entity configurations
+     */
+    getAllConfigs(): NotificationEntityConfig[];
+    /**
+     * Resolve the parent type for a specific entity instance
+     */
+    resolveParent(entityType: string, entityData: any): ParentResolutionResult | null;
+    /**
+     * Check if an entity type supports dynamic parent resolution
+     */
+    isDynamicParentType(entityType: string): boolean;
+    /**
+     * Get the parent property name for dynamic resolution
+     */
+    getParentProperty(entityType: string): string | null;
+    /**
+     * Get display name for an entity type
+     */
+    getDisplayName(entityType: string): string;
+    /**
+     * Get icon for an entity type
+     */
+    getIcon(entityType: string): string | null;
+    /**
+     * Check if entity type exists
+     */
+    hasEntityType(entityType: string): boolean;
+    /**
+     * Remove an entity configuration
+     */
+    unregisterEntity(entityType: string): boolean;
+    /**
+     * Clear all configurations
+     */
+    clear(): void;
+    /**
+     * Resolve static parent type
+     */
+    private resolveStaticParent;
+    /**
+     * Resolve dynamic parent type based on entity data
+     */
+    private resolveDynamicParent;
+    /**
+     * Register default entity configurations
+     */
+    private registerDefaultEntities;
+}
+/**
+ * Convenience function to get the singleton instance
+ */
+export declare function getNotificationEntityRegistry(): NotificationEntityRegistry;

package/dist/notification-entity-registry.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationEntityRegistry = void 0;
+exports.getNotificationEntityRegistry = getNotificationEntityRegistry;
+/**
+ * Registry for managing notification entity configurations and parent resolution
+ */
+class NotificationEntityRegistry {
+    constructor() {
+        this.entityConfigs = new Map();
+        // Initialize with default configurations
+        this.registerDefaultEntities();
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!NotificationEntityRegistry.instance) {
+            NotificationEntityRegistry.instance = new NotificationEntityRegistry();
+        }
+        return NotificationEntityRegistry.instance;
+    }
+    /**
+     * Register a new entity configuration
+     */
+    registerEntity(config) {
+        this.entityConfigs.set(config.entityType, config);
+    }
+    /**
+     * Get configuration for an entity type
+     */
+    getEntityConfig(entityType) {
+        return this.entityConfigs.get(entityType) || null;
+    }
+    /**
+     * Get all registered entity types
+     */
+    getEntityTypes() {
+        return Array.from(this.entityConfigs.keys());
+    }
+    /**
+     * Get all entity configurations
+     */
+    getAllConfigs() {
+        return Array.from(this.entityConfigs.values());
+    }
+    /**
+     * Resolve the parent type for a specific entity instance
+     */
+    resolveParent(entityType, entityData) {
+        const config = this.entityConfigs.get(entityType);
+        if (!config) {
+            return null;
+        }
+        const resolver = config.parentResolver;
+        if (resolver.type === 'static') {
+            return this.resolveStaticParent(resolver);
+        }
+        else {
+            return this.resolveDynamicParent(resolver, entityData);
+        }
+    }
+    /**
+     * Check if an entity type supports dynamic parent resolution
+     */
+    isDynamicParentType(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        return config?.parentResolver.type === 'dynamic' || false;
+    }
+    /**
+     * Get the parent property name for dynamic resolution
+     */
+    getParentProperty(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        if (config?.parentResolver.type === 'dynamic') {
+            return config.parentResolver.parentProperty;
+        }
+        return null;
+    }
+    /**
+     * Get display name for an entity type
+     */
+    getDisplayName(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        return config?.displayName || entityType;
+    }
+    /**
+     * Get icon for an entity type
+     */
+    getIcon(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        return config?.icon || null;
+    }
+    /**
+     * Check if entity type exists
+     */
+    hasEntityType(entityType) {
+        return this.entityConfigs.has(entityType);
+    }
+    /**
+     * Remove an entity configuration
+     */
+    unregisterEntity(entityType) {
+        return this.entityConfigs.delete(entityType);
+    }
+    /**
+     * Clear all configurations
+     */
+    clear() {
+        this.entityConfigs.clear();
+    }
+    /**
+     * Resolve static parent type
+     */
+    resolveStaticParent(resolver) {
+        return {
+            parentType: resolver.parentType,
+            isDynamic: false
+        };
+    }
+    /**
+     * Resolve dynamic parent type based on entity data
+     */
+    resolveDynamicParent(resolver, entityData) {
+        const propertyValue = entityData?.[resolver.parentProperty];
+        if (propertyValue && typeof propertyValue === 'string' && propertyValue.trim()) {
+            // Use the property value to construct the parent type
+            const parentType = resolver.parentTypePrefix + propertyValue.trim();
+            return {
+                parentType,
+                isDynamic: true,
+                resolvedProperty: propertyValue.trim(),
+                usedFallback: false
+            };
+        }
+        // Fall back to default parent
+        return {
+            parentType: resolver.fallbackParent,
+            isDynamic: true,
+            usedFallback: true
+        };
+    }
+    /**
+     * Register default entity configurations
+     */
+    registerDefaultEntities() {
+        // Agenda Panel (static parent of agenda items)
+        this.registerEntity({
+            entityType: 'agenda_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: 'agenda_panel' // Self-referencing for panel level
+            },
+            displayName: 'Agenda Panel',
+            icon: 'calendar',
+            description: 'Default notification templates for all agenda items'
+        });
+        // Agenda Item (can have dynamic parent based on category)
+        this.registerEntity({
+            entityType: 'agenda_item',
+            parentResolver: {
+                type: 'dynamic',
+                parentProperty: 'category',
+                parentTypePrefix: 'agenda_category_',
+                fallbackParent: 'agenda_panel'
+            },
+            displayName: 'Agenda Item',
+            icon: 'calendar',
+            description: 'Individual agenda item notifications'
+        });
+        // Inbox Panel
+        this.registerEntity({
+            entityType: 'inbox_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: 'inbox_panel' // Self-referencing for panel level
+            },
+            displayName: 'Inbox Panel',
+            icon: 'mail',
+            description: 'Inbox notification templates'
+        });
+    }
+}
+exports.NotificationEntityRegistry = NotificationEntityRegistry;
+/**
+ * Convenience function to get the singleton instance
+ */
+function getNotificationEntityRegistry() {
+    return NotificationEntityRegistry.getInstance();
+}

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export * from './id-types';
 export * from './people-types';
 export * from './lists-types';
 export * from './notifications-types';
+export * from './notification-entity-config';
 export * from './auth-types';
 export * from './user-types';
 export * from './program-config-types';
-export * from './misc';

package/dist/types/index.js

@@ -22,7 +22,7 @@ __exportStar(require("./id-types"), exports);
 __exportStar(require("./people-types"), exports);
 __exportStar(require("./lists-types"), exports);
 __exportStar(require("./notifications-types"), exports);
+__exportStar(require("./notification-entity-config"), exports);
 __exportStar(require("./auth-types"), exports);
 __exportStar(require("./user-types"), exports);
 __exportStar(require("./program-config-types"), exports);
-__exportStar(require("./misc"), exports);

package/dist/types/notification-entity-config.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+/**
+ * Static parent resolver - entity always inherits from the same parent type
+ */
+export interface StaticParentResolver {
+    type: 'static';
+    parentType: string;
+}
+/**
+ * Dynamic parent resolver - parent determined by entity properties
+ */
+export interface DynamicParentResolver {
+    type: 'dynamic';
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}
+export type ParentResolver = StaticParentResolver | DynamicParentResolver;
+/**
+ * Configuration for a notification entity type
+ */
+export interface NotificationEntityConfig {
+    entityType: string;
+    parentResolver: ParentResolver;
+    displayName: string;
+    icon?: string;
+    description?: string;
+}
+/**
+ * Result of parent resolution for a specific entity instance
+ */
+export interface ParentResolutionResult {
+    parentType: string;
+    isDynamic: boolean;
+    resolvedProperty?: string;
+    usedFallback?: boolean;
+}
+/**
+ * Zod schemas for validation
+ */
+export declare const staticParentResolverSchema: z.ZodObject<{
+    type: z.ZodLiteral<"static">;
+    parentType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "static";
+    parentType: string;
+}, {
+    type: "static";
+    parentType: string;
+}>;
+export declare const dynamicParentResolverSchema: z.ZodObject<{
+    type: z.ZodLiteral<"dynamic">;
+    parentProperty: z.ZodString;
+    parentTypePrefix: z.ZodString;
+    fallbackParent: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}>;
+export declare const parentResolverSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"static">;
+    parentType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "static";
+    parentType: string;
+}, {
+    type: "static";
+    parentType: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"dynamic">;
+    parentProperty: z.ZodString;
+    parentTypePrefix: z.ZodString;
+    fallbackParent: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}>]>;
+export declare const notificationEntityConfigSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    parentResolver: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"static">;
+        parentType: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "static";
+        parentType: string;
+    }, {
+        type: "static";
+        parentType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"dynamic">;
+        parentProperty: z.ZodString;
+        parentTypePrefix: z.ZodString;
+        fallbackParent: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    }, {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    }>]>;
+    displayName: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    entityType: string;
+    parentResolver: {
+        type: "static";
+        parentType: string;
+    } | {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    };
+    displayName: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+}, {
+    entityType: string;
+    parentResolver: {
+        type: "static";
+        parentType: string;
+    } | {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    };
+    displayName: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+}>;
+/**
+ * Type exports
+ */
+export type StaticParentResolverData = z.infer<typeof staticParentResolverSchema>;
+export type DynamicParentResolverData = z.infer<typeof dynamicParentResolverSchema>;
+export type ParentResolverData = z.infer<typeof parentResolverSchema>;
+export type NotificationEntityConfigData = z.infer<typeof notificationEntityConfigSchema>;

package/dist/types/notification-entity-config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationEntityConfigSchema = exports.parentResolverSchema = exports.dynamicParentResolverSchema = exports.staticParentResolverSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Zod schemas for validation
+ */
+exports.staticParentResolverSchema = zod_1.z.object({
+    type: zod_1.z.literal('static'),
+    parentType: zod_1.z.string()
+});
+exports.dynamicParentResolverSchema = zod_1.z.object({
+    type: zod_1.z.literal('dynamic'),
+    parentProperty: zod_1.z.string(),
+    parentTypePrefix: zod_1.z.string(),
+    fallbackParent: zod_1.z.string()
+});
+exports.parentResolverSchema = zod_1.z.union([
+    exports.staticParentResolverSchema,
+    exports.dynamicParentResolverSchema
+]);
+exports.notificationEntityConfigSchema = zod_1.z.object({
+    entityType: zod_1.z.string(),
+    parentResolver: exports.parentResolverSchema,
+    displayName: zod_1.z.string(),
+    icon: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional()
+});

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

@@ -2,20 +2,28 @@ import { z } from 'zod';
 import { Serialized } from '../utils';
 export interface NotificationContext<T = any> {
     entityId: string;
-    entityType: NotificationEntityType;
+    entityType: string;
     entityData: T;
     userId: string;
     variables: Record<string, any>;
 }
+/**
+ * @deprecated Use string types with NotificationEntityRegistry instead
+ * These enums are kept for backward compatibility during migration
+ */
 export declare enum NotificationParentType {
     AGENDA_PANEL = "agenda_panel"
 }
+/**
+ * @deprecated Use string types with NotificationEntityRegistry instead
+ * These enums are kept for backward compatibility during migration
+ */
 export declare enum NotificationEntityType {
     INBOX_PANEL = "inbox_panel",
-    AGENDA_PANEL = "agenda_item",
+    AGENDA_PANEL = "agenda_panel",
     AGENDA_ITEM = "agenda_item"
 }
-export declare const notificationEntityTypeSchema: z.ZodNativeEnum<typeof NotificationEntityType>;
+export declare const notificationEntityTypeSchema: z.ZodString;
 export declare enum NotificationStatus {
     SCHEDULED = "scheduled",
     SENT = "sent",
@@ -58,7 +66,7 @@ export declare const notificationContentSchema: z.ZodObject<{
 export declare const notificationTemplateSchema: z.ZodObject<{
     _id: z.ZodEffects<z.ZodString, import("./id-types").NotificationTemplateId, string>;
     userId: z.ZodEffects<z.ZodString, import("./id-types").UserId, string>;
-    entityType: z.ZodNativeEnum<typeof NotificationEntityType>;
+    entityType: z.ZodString;
     entityId: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -108,7 +116,7 @@ export declare const notificationTemplateSchema: z.ZodObject<{
         body: string;
         variables?: Record<string, string> | undefined;
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     trigger: {
         type: NotificationTriggerType;
         conditions: Record<string, any>;
@@ -130,7 +138,7 @@ export declare const notificationTemplateSchema: z.ZodObject<{
         body: string;
         variables?: Record<string, string> | undefined;
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     trigger: {
         type: NotificationTriggerType;
         conditions: Record<string, any>;
@@ -145,7 +153,7 @@ export declare const notificationTemplateSchema: z.ZodObject<{
 export declare const createNotificationTemplateSchema: z.ZodObject<Omit<{
     _id: z.ZodEffects<z.ZodString, import("./id-types").NotificationTemplateId, string>;
     userId: z.ZodEffects<z.ZodString, import("./id-types").UserId, string>;
-    entityType: z.ZodNativeEnum<typeof NotificationEntityType>;
+    entityType: z.ZodString;
     entityId: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -190,7 +198,7 @@ export declare const createNotificationTemplateSchema: z.ZodObject<Omit<{
         body: string;
         variables?: Record<string, string> | undefined;
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     trigger: {
         type: NotificationTriggerType;
         conditions: Record<string, any>;
@@ -209,7 +217,7 @@ export declare const createNotificationTemplateSchema: z.ZodObject<Omit<{
         body: string;
         variables?: Record<string, string> | undefined;
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     trigger: {
         type: NotificationTriggerType;
         conditions: Record<string, any>;
@@ -223,7 +231,7 @@ export declare const createNotificationTemplateSchema: z.ZodObject<Omit<{
 }>;
 export declare const entitySyncStateSchema: z.ZodObject<{
     userId: z.ZodEffects<z.ZodString, import("./id-types").UserId, string>;
-    entityType: z.ZodNativeEnum<typeof NotificationEntityType>;
+    entityType: z.ZodString;
     entityId: z.ZodString;
     synced: z.ZodBoolean;
     updatedAt: z.ZodDate;
@@ -232,13 +240,13 @@ export declare const entitySyncStateSchema: z.ZodObject<{
     userId: string & {
         readonly __brand: "UserId";
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     entityId: string;
     synced: boolean;
 }, {
     updatedAt: Date;
     userId: string;
-    entityType: NotificationEntityType;
+    entityType: string;
     entityId: string;
     synced: boolean;
 }>;
@@ -309,7 +317,7 @@ export declare const notificationInstanceSchema: z.ZodObject<{
     error?: string | undefined;
 }>;
 export declare const createNotificationTemplateRequestSchema: z.ZodObject<{
-    entityType: z.ZodNativeEnum<typeof NotificationEntityType>;
+    entityType: z.ZodString;
     entityId: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -349,7 +357,7 @@ export declare const createNotificationTemplateRequestSchema: z.ZodObject<{
         body: string;
         variables?: Record<string, string> | undefined;
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     trigger: {
         type: NotificationTriggerType;
         conditions: Record<string, any>;
@@ -367,7 +375,7 @@ export declare const createNotificationTemplateRequestSchema: z.ZodObject<{
         body: string;
         variables?: Record<string, string> | undefined;
     };
-    entityType: NotificationEntityType;
+    entityType: string;
     trigger: {
         type: NotificationTriggerType;
         conditions: Record<string, any>;

package/dist/types/notifications-types.js

@@ -3,17 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEntitySyncRequestSchema = exports.entitySyncRequestSchema = exports.getNotificationInstancesRequestSchema = exports.previewNotificationTemplateRequestSchema = exports.syncNotificationTemplateRequestSchema = exports.updateNotificationTemplateRequestSchema = exports.createNotificationTemplateRequestSchema = exports.notificationInstanceSchema = exports.entitySyncStateSchema = exports.createNotificationTemplateSchema = exports.notificationTemplateSchema = exports.notificationContentSchema = exports.notificationTriggerSchema = exports.notificationTriggerTypeSchema = exports.notificationStatusSchema = exports.NotificationTriggerType = exports.NotificationStatus = exports.notificationEntityTypeSchema = exports.NotificationEntityType = exports.NotificationParentType = void 0;
 const zod_1 = require("zod");
 const id_types_1 = require("./id-types");
+/**
+ * @deprecated Use string types with NotificationEntityRegistry instead
+ * These enums are kept for backward compatibility during migration
+ */
 var NotificationParentType;
 (function (NotificationParentType) {
     NotificationParentType["AGENDA_PANEL"] = "agenda_panel";
 })(NotificationParentType || (exports.NotificationParentType = NotificationParentType = {}));
+/**
+ * @deprecated Use string types with NotificationEntityRegistry instead
+ * These enums are kept for backward compatibility during migration
+ */
 var NotificationEntityType;
 (function (NotificationEntityType) {
     NotificationEntityType["INBOX_PANEL"] = "inbox_panel";
-    NotificationEntityType["AGENDA_PANEL"] = "agenda_item";
+    NotificationEntityType["AGENDA_PANEL"] = "agenda_panel";
     NotificationEntityType["AGENDA_ITEM"] = "agenda_item";
 })(NotificationEntityType || (exports.NotificationEntityType = NotificationEntityType = {}));
-exports.notificationEntityTypeSchema = zod_1.z.nativeEnum(NotificationEntityType);
+// Updated to use string instead of enum
+exports.notificationEntityTypeSchema = zod_1.z.string();
 var NotificationStatus;
 (function (NotificationStatus) {
     NotificationStatus["SCHEDULED"] = "scheduled";

package/package.json

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

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './enums'
 export * from './types'
-export * from './utils'
+export * from './utils'
+export * from './notification-entity-registry'

package/src/notification-entity-registry.ts

@@ -0,0 +1,217 @@
+import {
+    NotificationEntityConfig,
+    ParentResolver,
+    ParentResolutionResult,
+    StaticParentResolver,
+    DynamicParentResolver
+} from './types/notification-entity-config';
+
+/**
+ * Registry for managing notification entity configurations and parent resolution
+ */
+export class NotificationEntityRegistry {
+    private static instance: NotificationEntityRegistry;
+    private entityConfigs: Map<string, NotificationEntityConfig> = new Map();
+
+    private constructor() {
+        // Initialize with default configurations
+        this.registerDefaultEntities();
+    }
+
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): NotificationEntityRegistry {
+        if (!NotificationEntityRegistry.instance) {
+            NotificationEntityRegistry.instance = new NotificationEntityRegistry();
+        }
+        return NotificationEntityRegistry.instance;
+    }
+
+    /**
+     * Register a new entity configuration
+     */
+    registerEntity(config: NotificationEntityConfig): void {
+        this.entityConfigs.set(config.entityType, config);
+    }
+
+    /**
+     * Get configuration for an entity type
+     */
+    getEntityConfig(entityType: string): NotificationEntityConfig | null {
+        return this.entityConfigs.get(entityType) || null;
+    }
+
+    /**
+     * Get all registered entity types
+     */
+    getEntityTypes(): string[] {
+        return Array.from(this.entityConfigs.keys());
+    }
+
+    /**
+     * Get all entity configurations
+     */
+    getAllConfigs(): NotificationEntityConfig[] {
+        return Array.from(this.entityConfigs.values());
+    }
+
+    /**
+     * Resolve the parent type for a specific entity instance
+     */
+    resolveParent(entityType: string, entityData: any): ParentResolutionResult | null {
+        const config = this.entityConfigs.get(entityType);
+        if (!config) {
+            return null;
+        }
+
+        const resolver = config.parentResolver;
+
+        if (resolver.type === 'static') {
+            return this.resolveStaticParent(resolver);
+        } else {
+            return this.resolveDynamicParent(resolver, entityData);
+        }
+    }
+
+    /**
+     * Check if an entity type supports dynamic parent resolution
+     */
+    isDynamicParentType(entityType: string): boolean {
+        const config = this.entityConfigs.get(entityType);
+        return config?.parentResolver.type === 'dynamic' || false;
+    }
+
+    /**
+     * Get the parent property name for dynamic resolution
+     */
+    getParentProperty(entityType: string): string | null {
+        const config = this.entityConfigs.get(entityType);
+        if (config?.parentResolver.type === 'dynamic') {
+            return config.parentResolver.parentProperty;
+        }
+        return null;
+    }
+
+    /**
+     * Get display name for an entity type
+     */
+    getDisplayName(entityType: string): string {
+        const config = this.entityConfigs.get(entityType);
+        return config?.displayName || entityType;
+    }
+
+    /**
+     * Get icon for an entity type
+     */
+    getIcon(entityType: string): string | null {
+        const config = this.entityConfigs.get(entityType);
+        return config?.icon || null;
+    }
+
+    /**
+     * Check if entity type exists
+     */
+    hasEntityType(entityType: string): boolean {
+        return this.entityConfigs.has(entityType);
+    }
+
+    /**
+     * Remove an entity configuration
+     */
+    unregisterEntity(entityType: string): boolean {
+        return this.entityConfigs.delete(entityType);
+    }
+
+    /**
+     * Clear all configurations
+     */
+    clear(): void {
+        this.entityConfigs.clear();
+    }
+
+    /**
+     * Resolve static parent type
+     */
+    private resolveStaticParent(resolver: StaticParentResolver): ParentResolutionResult {
+        return {
+            parentType: resolver.parentType,
+            isDynamic: false
+        };
+    }
+
+    /**
+     * Resolve dynamic parent type based on entity data
+     */
+    private resolveDynamicParent(resolver: DynamicParentResolver, entityData: any): ParentResolutionResult {
+        const propertyValue = entityData?.[resolver.parentProperty];
+        
+        if (propertyValue && typeof propertyValue === 'string' && propertyValue.trim()) {
+            // Use the property value to construct the parent type
+            const parentType = resolver.parentTypePrefix + propertyValue.trim();
+            return {
+                parentType,
+                isDynamic: true,
+                resolvedProperty: propertyValue.trim(),
+                usedFallback: false
+            };
+        }
+
+        // Fall back to default parent
+        return {
+            parentType: resolver.fallbackParent,
+            isDynamic: true,
+            usedFallback: true
+        };
+    }
+
+    /**
+     * Register default entity configurations
+     */
+    private registerDefaultEntities(): void {
+        // Agenda Panel (static parent of agenda items)
+        this.registerEntity({
+            entityType: 'agenda_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: 'agenda_panel' // Self-referencing for panel level
+            },
+            displayName: 'Agenda Panel',
+            icon: 'calendar',
+            description: 'Default notification templates for all agenda items'
+        });
+
+        // Agenda Item (can have dynamic parent based on category)
+        this.registerEntity({
+            entityType: 'agenda_item',
+            parentResolver: {
+                type: 'dynamic',
+                parentProperty: 'category',
+                parentTypePrefix: 'agenda_category_',
+                fallbackParent: 'agenda_panel'
+            },
+            displayName: 'Agenda Item',
+            icon: 'calendar',
+            description: 'Individual agenda item notifications'
+        });
+
+        // Inbox Panel
+        this.registerEntity({
+            entityType: 'inbox_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: 'inbox_panel' // Self-referencing for panel level
+            },
+            displayName: 'Inbox Panel',
+            icon: 'mail',
+            description: 'Inbox notification templates'
+        });
+    }
+}
+
+/**
+ * Convenience function to get the singleton instance
+ */
+export function getNotificationEntityRegistry(): NotificationEntityRegistry {
+    return NotificationEntityRegistry.getInstance();
+}

package/src/types/index.ts

@@ -6,7 +6,7 @@ export * from './id-types';
 export * from './people-types';
 export * from './lists-types';
 export * from './notifications-types';
+export * from './notification-entity-config';
 export * from './auth-types';
 export * from './user-types';
-export * from './program-config-types';
-export * from './misc';
+export * from './program-config-types';

package/src/types/notification-entity-config.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+
+/**
+ * Static parent resolver - entity always inherits from the same parent type
+ */
+export interface StaticParentResolver {
+    type: 'static';
+    parentType: string;
+}
+
+/**
+ * Dynamic parent resolver - parent determined by entity properties
+ */
+export interface DynamicParentResolver {
+    type: 'dynamic';
+    parentProperty: string; // Property name on entity (e.g., 'category')
+    parentTypePrefix: string; // Prefix for parent type (e.g., 'agenda_category_')
+    fallbackParent: string; // Default parent if property is missing/empty
+}
+
+export type ParentResolver = StaticParentResolver | DynamicParentResolver;
+
+/**
+ * Configuration for a notification entity type
+ */
+export interface NotificationEntityConfig {
+    entityType: string;
+    parentResolver: ParentResolver;
+    displayName: string;
+    icon?: string;
+    description?: string;
+}
+
+/**
+ * Result of parent resolution for a specific entity instance
+ */
+export interface ParentResolutionResult {
+    parentType: string;
+    isDynamic: boolean;
+    resolvedProperty?: string;
+    usedFallback?: boolean;
+}
+
+/**
+ * Zod schemas for validation
+ */
+export const staticParentResolverSchema = z.object({
+    type: z.literal('static'),
+    parentType: z.string()
+});
+
+export const dynamicParentResolverSchema = z.object({
+    type: z.literal('dynamic'),
+    parentProperty: z.string(),
+    parentTypePrefix: z.string(),
+    fallbackParent: z.string()
+});
+
+export const parentResolverSchema = z.union([
+    staticParentResolverSchema,
+    dynamicParentResolverSchema
+]);
+
+export const notificationEntityConfigSchema = z.object({
+    entityType: z.string(),
+    parentResolver: parentResolverSchema,
+    displayName: z.string(),
+    icon: z.string().optional(),
+    description: z.string().optional()
+});
+
+/**
+ * Type exports
+ */
+export type StaticParentResolverData = z.infer<typeof staticParentResolverSchema>;
+export type DynamicParentResolverData = z.infer<typeof dynamicParentResolverSchema>;
+export type ParentResolverData = z.infer<typeof parentResolverSchema>;
+export type NotificationEntityConfigData = z.infer<typeof notificationEntityConfigSchema>;

package/src/types/notifications-types.ts

@@ -4,23 +4,32 @@ import { Serialized } from '../utils';
 
 export interface NotificationContext<T = any> {
     entityId: string;
-    entityType: NotificationEntityType;
+    entityType: string;
     entityData: T;
     userId: string;
     variables: Record<string, any>;
 }
 
+/**
+ * @deprecated Use string types with NotificationEntityRegistry instead
+ * These enums are kept for backward compatibility during migration
+ */
 export enum NotificationParentType {
     AGENDA_PANEL = 'agenda_panel',
 }
 
+/**
+ * @deprecated Use string types with NotificationEntityRegistry instead
+ * These enums are kept for backward compatibility during migration
+ */
 export enum NotificationEntityType {
     INBOX_PANEL = 'inbox_panel',
-    AGENDA_PANEL = 'agenda_item',
+    AGENDA_PANEL = 'agenda_panel',
     AGENDA_ITEM = 'agenda_item',
 }
 
-export const notificationEntityTypeSchema = z.nativeEnum(NotificationEntityType);
+// Updated to use string instead of enum
+export const notificationEntityTypeSchema = z.string();
 
 export enum NotificationStatus {
     SCHEDULED = 'scheduled',