@burdenoff/be-sdk 2026.510.79

package/dist/chunk-XC2YD6CF.js

@@ -0,0 +1,913 @@
+import { ValidationError } from './chunk-SAG6ZYWQ.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+
+// src/notifications/tenant-notifications.ts
+var tenant_notifications_exports = {};
+__export(tenant_notifications_exports, {
+  NotificationChannel: () => NotificationChannel,
+  NotificationPriority: () => NotificationPriority,
+  NotificationType: () => NotificationType,
+  TenantNotificationsModule: () => TenantNotificationsModule
+});
+var NotificationChannel = /* @__PURE__ */ (function(NotificationChannel3) {
+  NotificationChannel3["EMAIL"] = "EMAIL";
+  NotificationChannel3["SMS"] = "SMS";
+  NotificationChannel3["PUSH"] = "PUSH";
+  NotificationChannel3["IN_APP"] = "IN_APP";
+  NotificationChannel3["WEBHOOK"] = "WEBHOOK";
+  NotificationChannel3["WHATSAPP"] = "WHATSAPP";
+  NotificationChannel3["TEAMS"] = "TEAMS";
+  NotificationChannel3["SLACK"] = "SLACK";
+  NotificationChannel3["TELEGRAM"] = "TELEGRAM";
+  NotificationChannel3["DISCORD"] = "DISCORD";
+  return NotificationChannel3;
+})({});
+var NotificationPriority = /* @__PURE__ */ (function(NotificationPriority2) {
+  NotificationPriority2["LOW"] = "LOW";
+  NotificationPriority2["MEDIUM"] = "MEDIUM";
+  NotificationPriority2["HIGH"] = "HIGH";
+  NotificationPriority2["URGENT"] = "URGENT";
+  return NotificationPriority2;
+})({});
+var NotificationType = /* @__PURE__ */ (function(NotificationType3) {
+  NotificationType3["TRANSACTIONAL"] = "TRANSACTIONAL";
+  NotificationType3["MARKETING"] = "MARKETING";
+  NotificationType3["SYSTEM"] = "SYSTEM";
+  NotificationType3["ALERT"] = "ALERT";
+  return NotificationType3;
+})({});
+var TenantNotificationsModule = class {
+  static {
+    __name(this, "TenantNotificationsModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Send a single notification
+  */
+  async send(input) {
+    this.validateSendInput(input);
+    logger.info("[TenantNotifications] Sending notification", {
+      channel: input.channel,
+      type: input.type || "TRANSACTIONAL",
+      priority: input.priority || "MEDIUM"
+    });
+    const mutation = `
+      mutation SendNotification($input: SendNotificationInput!) {
+        sendNotification(input: $input)
+      }
+    `;
+    const variables = {
+      input: {
+        recipient: input.recipient,
+        channel: input.channel,
+        type: input.type || "TRANSACTIONAL",
+        priority: input.priority || "MEDIUM",
+        subject: input.subject,
+        body: input.body,
+        htmlBody: input.htmlBody,
+        data: input.data,
+        metadata: input.metadata,
+        scheduledFor: input.scheduledFor?.toISOString(),
+        expiresAt: input.expiresAt?.toISOString(),
+        trackOpens: input.trackOpens,
+        trackClicks: input.trackClicks
+      }
+    };
+    const response = await this.client.tenantQuery(mutation, variables, this.context);
+    logger.info("[TenantNotifications] Notification sent", {
+      notificationId: response.sendNotification
+    });
+    return response.sendNotification;
+  }
+  /**
+  * Send notification using a template
+  */
+  async sendWithTemplate(input) {
+    if (!input.templateSlug || input.templateSlug.trim().length === 0) {
+      throw new ValidationError("Template slug is required");
+    }
+    if (!input.variables || Object.keys(input.variables).length === 0) {
+      throw new ValidationError("Template variables are required");
+    }
+    if (!input.recipient || !input.recipient.email && !input.recipient.userId) {
+      throw new ValidationError("Recipient email or userId is required");
+    }
+    logger.info("[TenantNotifications] Sending notification with template", {
+      templateSlug: input.templateSlug,
+      priority: input.priority || "MEDIUM"
+    });
+    const mutation = `
+      mutation TriggerNotificationWithTemplate($input: TriggerNotificationWithTemplateInput!) {
+        triggerNotificationWithTemplate(input: $input) {
+          id
+          status
+          deliveryStatus
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        templateSlug: input.templateSlug,
+        variables: input.variables,
+        recipient: input.recipient,
+        priority: input.priority || "MEDIUM",
+        scheduledFor: input.scheduledFor?.toISOString(),
+        expiresAt: input.expiresAt?.toISOString(),
+        trackOpens: input.trackOpens,
+        trackClicks: input.trackClicks,
+        // Platform is required for notification delivery routing
+        // If channelId is specified, it takes precedence; otherwise platform determines delivery
+        channelId: input.channelId,
+        platform: input.platform || "EMAIL",
+        timezone: input.timezone
+      }
+    };
+    const response = await this.client.tenantQuery(mutation, variables, this.context);
+    logger.info("[TenantNotifications] Notification sent with template", {
+      notificationId: response.triggerNotificationWithTemplate.id,
+      status: response.triggerNotificationWithTemplate.status
+    });
+    return response.triggerNotificationWithTemplate.id;
+  }
+  /**
+  * Send batch notifications
+  */
+  async sendBatch(input) {
+    if (!input.notifications || input.notifications.length === 0) {
+      throw new ValidationError("At least one notification is required");
+    }
+    logger.info("[TenantNotifications] Sending batch notifications", {
+      count: input.notifications.length,
+      batchSize: input.batchSize
+    });
+    const mutation = `
+      mutation SendBatchNotifications($input: BatchNotificationInput!) {
+        sendBatchNotifications(input: $input) {
+          totalRequested
+          totalQueued
+          totalFailed
+          batchId
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        notifications: input.notifications.map((n) => ({
+          recipient: n.recipient,
+          channel: n.channel,
+          type: n.type || "TRANSACTIONAL",
+          priority: n.priority || "MEDIUM",
+          subject: n.subject,
+          body: n.body,
+          htmlBody: n.htmlBody,
+          data: n.data,
+          metadata: n.metadata,
+          scheduledFor: n.scheduledFor?.toISOString(),
+          expiresAt: n.expiresAt?.toISOString(),
+          trackOpens: n.trackOpens,
+          trackClicks: n.trackClicks
+        })),
+        batchSize: input.batchSize,
+        delayBetweenBatches: input.delayBetweenBatches,
+        priority: input.priority
+      }
+    };
+    const response = await this.client.tenantQuery(mutation, variables, this.context);
+    logger.info("[TenantNotifications] Batch notifications sent", {
+      batchId: response.sendBatchNotifications.batchId,
+      queued: response.sendBatchNotifications.totalQueued,
+      failed: response.sendBatchNotifications.totalFailed
+    });
+    return response.sendBatchNotifications;
+  }
+  /**
+  * Get a notification by ID
+  */
+  async getNotification(id) {
+    const query = `
+      query GetNotification($id: ID!) {
+        notification(id: $id) {
+          id
+          userId
+          channel
+          type
+          priority
+          status
+          deliveryStatus
+          title
+          message
+          htmlMessage
+          subject
+          recipientEmail
+          recipientPhone
+          trackOpens
+          trackClicks
+          openedAt
+          clickedAt
+          sentAt
+          deliveredAt
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.tenantQuery(query, {
+      id
+    }, this.context);
+    return response.notification;
+  }
+  /**
+  * Get notifications with filters
+  */
+  async getNotifications(filter) {
+    const query = `
+      query GetNotifications($filter: NotificationFilterInput, $limit: Int, $offset: Int) {
+        notifications(filter: $filter, limit: $limit, offset: $offset) {
+          id
+          userId
+          channel
+          type
+          priority
+          status
+          deliveryStatus
+          title
+          message
+          subject
+          recipientEmail
+          trackOpens
+          trackClicks
+          openedAt
+          clickedAt
+          sentAt
+          deliveredAt
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const variables = {
+      filter: filter ? {
+        userId: filter.userId,
+        channel: filter.channel,
+        type: filter.type,
+        status: filter.status,
+        priority: filter.priority,
+        startDate: filter.startDate?.toISOString(),
+        endDate: filter.endDate?.toISOString()
+      } : void 0,
+      limit: filter?.limit || 50,
+      offset: filter?.offset || 0
+    };
+    const response = await this.client.tenantQuery(query, variables, this.context);
+    return response.notifications;
+  }
+  /**
+  * Get notification template
+  */
+  async getTemplate(slug, locale) {
+    const query = `
+      query GetNotificationTemplate($slug: String!, $locale: String) {
+        notificationTemplate(slug: $slug, locale: $locale) {
+          id
+          name
+          slug
+          description
+          channel
+          type
+          locale
+          subject
+          bodyTemplate
+          htmlTemplate
+          variables
+          enabled
+          version
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.tenantQuery(query, {
+      slug,
+      locale
+    }, this.context);
+    return response.notificationTemplate;
+  }
+  /**
+  * Get all notification templates
+  */
+  async getTemplates(filter) {
+    const query = `
+      query GetNotificationTemplates($filter: TemplateFilterInput) {
+        notificationTemplates(filter: $filter) {
+          id
+          name
+          slug
+          description
+          channel
+          type
+          locale
+          subject
+          bodyTemplate
+          htmlTemplate
+          variables
+          enabled
+          version
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.tenantQuery(query, {
+      filter
+    }, this.context);
+    return response.notificationTemplates;
+  }
+  /**
+  * Get notification statistics
+  */
+  async getStats(filter) {
+    const query = `
+      query GetNotificationStats($filter: NotificationFilterInput) {
+        notificationStats(filter: $filter) {
+          total
+          pending
+          queued
+          processing
+          sent
+          delivered
+          failed
+          byChannel
+          byType
+        }
+      }
+    `;
+    const variables = {
+      filter: filter ? {
+        userId: filter.userId,
+        startDate: filter.startDate?.toISOString(),
+        endDate: filter.endDate?.toISOString()
+      } : void 0
+    };
+    const response = await this.client.tenantQuery(query, variables, this.context);
+    return response.notificationStats;
+  }
+  /**
+  * Mark notifications as read
+  */
+  async markAsRead(notificationIds) {
+    const mutation = `
+      mutation MarkNotificationsAsRead($notificationIds: [ID!]!) {
+        markNotificationsAsRead(notificationIds: $notificationIds)
+      }
+    `;
+    await this.client.tenantQuery(mutation, {
+      notificationIds
+    }, this.context);
+    logger.info("[TenantNotifications] Notifications marked as read", {
+      count: notificationIds.length
+    });
+    return true;
+  }
+  /**
+  * Mark all notifications as read for the current user
+  */
+  async markAllAsRead() {
+    const mutation = `
+      mutation MarkAllMyNotificationsAsRead {
+        markAllMyNotificationsAsRead
+      }
+    `;
+    await this.client.tenantQuery(mutation, {}, this.context);
+    logger.info("[TenantNotifications] All notifications marked as read");
+    return true;
+  }
+  /**
+  * Delete notifications
+  */
+  async deleteNotifications(notificationIds) {
+    const mutation = `
+      mutation DeleteNotifications($notificationIds: [ID!]!) {
+        deleteNotifications(notificationIds: $notificationIds)
+      }
+    `;
+    await this.client.tenantQuery(mutation, {
+      notificationIds
+    }, this.context);
+    logger.info("[TenantNotifications] Notifications deleted", {
+      count: notificationIds.length
+    });
+    return true;
+  }
+  /**
+  * Delete all read notifications for the current user
+  */
+  async deleteAllReadNotifications() {
+    const mutation = `
+      mutation DeleteMyReadNotifications {
+        deleteMyReadNotifications
+      }
+    `;
+    await this.client.tenantQuery(mutation, {}, this.context);
+    logger.info("[TenantNotifications] All read notifications deleted");
+    return true;
+  }
+  /**
+  * Validate send notification input
+  */
+  validateSendInput(input) {
+    if (!input.recipient || !input.recipient.email && !input.recipient.userId && !input.recipient.phoneNumber) {
+      throw new ValidationError("Recipient email, userId, or phoneNumber is required");
+    }
+    if (!input.channel) {
+      throw new ValidationError("Notification channel is required");
+    }
+    if (!input.body || input.body.trim().length === 0) {
+      throw new ValidationError("Notification body is required");
+    }
+    if (input.channel === "EMAIL" && !input.recipient.email) {
+      throw new ValidationError("Recipient email is required for EMAIL channel");
+    }
+    if (input.channel === "SMS" && !input.recipient.phoneNumber) {
+      throw new ValidationError("Recipient phone number is required for SMS channel");
+    }
+    if (input.channel === "PUSH" && !input.recipient.pushToken && !input.recipient.userId) {
+      throw new ValidationError("Recipient push token or userId is required for PUSH channel");
+    }
+  }
+};
+
+// src/notifications/index.ts
+var NotificationType2 = /* @__PURE__ */ (function(NotificationType3) {
+  NotificationType3["INFO"] = "info";
+  NotificationType3["SUCCESS"] = "success";
+  NotificationType3["WARNING"] = "warning";
+  NotificationType3["ERROR"] = "error";
+  return NotificationType3;
+})({});
+var NotificationChannel2 = /* @__PURE__ */ (function(NotificationChannel3) {
+  NotificationChannel3["EMAIL"] = "EMAIL";
+  NotificationChannel3["SMS"] = "SMS";
+  NotificationChannel3["WHATSAPP"] = "WHATSAPP";
+  NotificationChannel3["PUSH"] = "PUSH";
+  NotificationChannel3["SLACK"] = "SLACK";
+  NotificationChannel3["TEAMS"] = "TEAMS";
+  NotificationChannel3["WEBHOOK"] = "WEBHOOK";
+  return NotificationChannel3;
+})({});
+var NotificationsModule = class {
+  static {
+    __name(this, "NotificationsModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Send notification to users
+  */
+  async send(options) {
+    if (!options.title || options.title.trim().length === 0) {
+      throw new ValidationError("Notification title is required");
+    }
+    if (!options.message || options.message.trim().length === 0) {
+      throw new ValidationError("Notification message is required");
+    }
+    if (!options.userIds || options.userIds.length === 0) {
+      throw new ValidationError("At least one user ID is required");
+    }
+    logger.info("[Notifications] Sending notification", {
+      title: options.title,
+      userCount: options.userIds.length,
+      type: options.type || "info"
+    });
+    const mutation = `
+      mutation CreateNotification($input: CreateNotificationInput!) {
+        createNotification(input: $input) {
+          successCount
+          failureCount
+          errors
+          notifications {
+            id
+          }
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        title: options.title,
+        message: options.message,
+        type: options.type || "info",
+        userIds: options.userIds,
+        redirectUrl: options.redirectUrl || "",
+        appName: options.appName,
+        email: options.email || false,
+        sms: options.sms || false
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    const result = {
+      successCount: response.createNotification.successCount,
+      failureCount: response.createNotification.failureCount,
+      errors: response.createNotification.errors,
+      notificationIds: response.createNotification.notifications.map((n) => n.id)
+    };
+    logger.info("[Notifications] Notification sent", {
+      successCount: result.successCount,
+      failureCount: result.failureCount
+    });
+    return result;
+  }
+  /**
+  * Send notification to a single user (convenience method)
+  */
+  async sendToUser(userId, title, message, options) {
+    return this.send({
+      title,
+      message,
+      userIds: [
+        userId
+      ],
+      ...options
+    });
+  }
+  /**
+  * Get notifications for a user
+  */
+  async getNotifications(options) {
+    logger.debug("[Notifications] Getting notifications", {
+      userId: options.userId
+    });
+    const query = `
+      query GetNotifications(
+        $userId: ID!
+        $status: NotificationStatus
+        $type: NotificationType
+        $appName: String
+        $search: String
+        $limit: Int
+        $offset: Int
+      ) {
+        getNotifications(
+          userId: $userId
+          status: $status
+          type: $type
+          appName: $appName
+          search: $search
+          limit: $limit
+          offset: $offset
+        ) {
+          notifications {
+            id
+            userId
+            title
+            message
+            type
+            status
+            redirectUrl
+            appName
+            createdAt
+            updatedAt
+          }
+          total
+          unreadCount
+        }
+      }
+    `;
+    const variables = {
+      userId: options.userId,
+      status: options.status,
+      type: options.type,
+      appName: options.appName,
+      search: options.search,
+      limit: options.limit || 20,
+      offset: options.offset || 0
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.getNotifications;
+  }
+  /**
+  * Mark notification as read
+  */
+  async markAsRead(notificationId) {
+    logger.debug("[Notifications] Marking notification as read", {
+      notificationId
+    });
+    const mutation = `
+      mutation MarkNotificationAsRead($notificationId: ID!) {
+        markNotificationAsRead(notificationId: $notificationId) {
+          id
+          status
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      notificationId
+    }, this.context);
+    logger.info("[Notifications] Notification marked as read", {
+      notificationId
+    });
+    return true;
+  }
+  /**
+  * Mark multiple notifications as read
+  */
+  async markMultipleAsRead(notificationIds) {
+    logger.debug("[Notifications] Marking multiple notifications as read", {
+      count: notificationIds.length
+    });
+    const mutation = `
+      mutation MarkNotificationsAsRead($notificationIds: [ID!]!) {
+        markNotificationsAsRead(notificationIds: $notificationIds) {
+          count
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      notificationIds
+    }, this.context);
+    logger.info("[Notifications] Notifications marked as read", {
+      count: response.markNotificationsAsRead.count
+    });
+    return response.markNotificationsAsRead.count;
+  }
+  /**
+  * Mark all notifications as read for the current user
+  */
+  async markAllAsRead() {
+    logger.debug("[Notifications] Marking all notifications as read");
+    const mutation = `
+      mutation MarkAllMyNotificationsAsRead {
+        markAllMyNotificationsAsRead {
+          count
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {}, this.context);
+    logger.info("[Notifications] All notifications marked as read", {
+      count: response.markAllMyNotificationsAsRead.count
+    });
+    return response.markAllMyNotificationsAsRead.count;
+  }
+  /**
+  * Delete notification
+  */
+  async deleteNotification(notificationId) {
+    logger.debug("[Notifications] Deleting notification", {
+      notificationId
+    });
+    const mutation = `
+      mutation DeleteNotification($notificationId: ID!) {
+        deleteNotification(notificationId: $notificationId) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      notificationId
+    }, this.context);
+    logger.info("[Notifications] Notification deleted", {
+      notificationId
+    });
+    return true;
+  }
+  /**
+  * Delete multiple notifications
+  */
+  async deleteMultiple(notificationIds) {
+    logger.debug("[Notifications] Deleting multiple notifications", {
+      count: notificationIds.length
+    });
+    const mutation = `
+      mutation DeleteNotifications($notificationIds: [ID!]!) {
+        deleteNotifications(notificationIds: $notificationIds) {
+          count
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      notificationIds
+    }, this.context);
+    logger.info("[Notifications] Notifications deleted", {
+      count: response.deleteNotifications.count
+    });
+    return response.deleteNotifications.count;
+  }
+  /**
+  * Get unread notification count for a user
+  */
+  async getUnreadCount(userId) {
+    const result = await this.getNotifications({
+      userId,
+      status: "unread",
+      limit: 0
+    });
+    return result.unreadCount;
+  }
+  /**
+  * Send notification via specific channel (EMAIL, SMS, WHATSAPP, etc.)
+  * with optional in-app notification
+  */
+  async sendChannelNotification(options) {
+    if (!options.body || options.body.trim().length === 0) {
+      throw new ValidationError("Notification body is required");
+    }
+    if (!options.recipient && !options.recipients) {
+      throw new ValidationError("At least one recipient is required");
+    }
+    if (options.includeInApp && (!options.userIds || options.userIds.length === 0)) {
+      throw new ValidationError("User IDs are required when includeInApp is true");
+    }
+    logger.info("[Notifications] Sending channel notification", {
+      platform: options.platform,
+      recipientCount: options.recipients ? options.recipients.length : 1,
+      includeInApp: options.includeInApp,
+      inAppUserCount: options.userIds ? options.userIds.length : 0
+    });
+    const mutation = `
+      mutation TriggerNotification($input: TriggerNotificationInput!) {
+        triggerNotification(input: $input) {
+          id
+          status
+          deliveryStatus
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        platform: options.platform,
+        channelId: options.channelId,
+        includeInApp: options.includeInApp || false,
+        userIds: options.userIds || [],
+        notification: {
+          subject: options.subject || "",
+          body: options.body,
+          htmlBody: options.htmlBody || "",
+          channel: options.platform,
+          type: options.type || "info",
+          recipient: options.recipient,
+          appName: options.appName,
+          redirectUrl: options.redirectUrl || "",
+          metadata: options.metadata || {},
+          trackOpens: options.trackOpens || false,
+          trackClicks: options.trackClicks || false,
+          expiresAt: options.expiresAt?.toISOString()
+        }
+      }
+    };
+    if (options.recipients && options.recipients.length > 1) {
+      const results = await Promise.allSettled(options.recipients.map((recipient) => this.client.query(mutation, {
+        input: {
+          ...variables.input,
+          notification: {
+            ...variables.input.notification,
+            recipient
+          }
+        }
+      }, this.context)));
+      let successCount = 0;
+      let failureCount = 0;
+      const errors = [];
+      const notificationIds = [];
+      results.forEach((result, index) => {
+        if (result.status === "fulfilled") {
+          successCount++;
+          const response2 = result.value;
+          notificationIds.push(response2.triggerNotification.id);
+        } else {
+          failureCount++;
+          errors.push(`Recipient ${index + 1}: ${result.reason instanceof Error ? result.reason.message : "Unknown error"}`);
+        }
+      });
+      const response = {
+        successCount,
+        failureCount,
+        errors,
+        notificationIds
+      };
+      logger.info("[Notifications] Channel notification sent (bulk)", {
+        successCount,
+        failureCount
+      });
+      return response;
+    } else {
+      try {
+        const response = await this.client.query(mutation, variables, this.context);
+        const result = {
+          successCount: 1,
+          failureCount: 0,
+          errors: [],
+          notificationIds: [
+            response.triggerNotification.id
+          ]
+        };
+        logger.info("[Notifications] Channel notification sent", {
+          notificationId: response.triggerNotification.id,
+          status: response.triggerNotification.status
+        });
+        return result;
+      } catch (error) {
+        logger.error("[Notifications] Failed to send channel notification", {
+          error
+        });
+        return {
+          successCount: 0,
+          failureCount: 1,
+          errors: [
+            error instanceof Error ? error.message : "Unknown error"
+          ],
+          notificationIds: []
+        };
+      }
+    }
+  }
+  /**
+  * Send notification using a template with optional in-app notification
+  */
+  async sendTemplateNotification(options) {
+    if (!options.templateSlug || options.templateSlug.trim().length === 0) {
+      throw new ValidationError("Template slug is required");
+    }
+    if (!options.variables || typeof options.variables !== "object") {
+      throw new ValidationError("Template variables are required");
+    }
+    if (!options.recipient && !options.recipients) {
+      throw new ValidationError("At least one recipient is required");
+    }
+    if (options.includeInApp && (!options.userIds || options.userIds.length === 0)) {
+      throw new ValidationError("User IDs are required when includeInApp is true");
+    }
+    logger.info("[Notifications] Sending template notification", {
+      templateSlug: options.templateSlug,
+      platform: options.platform,
+      recipientCount: options.recipients ? options.recipients.length : 1,
+      includeInApp: options.includeInApp,
+      inAppUserCount: options.userIds ? options.userIds.length : 0
+    });
+    const mutation = `
+      mutation TriggerNotificationWithTemplate($input: TriggerNotificationWithTemplateInput!) {
+        triggerNotificationWithTemplate(input: $input) {
+          id
+          status
+          deliveryStatus
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        platform: options.platform,
+        channelId: options.channelId,
+        includeInApp: options.includeInApp || false,
+        userIds: options.userIds || [],
+        templateSlug: options.templateSlug,
+        variables: options.variables,
+        recipient: options.recipient,
+        recipients: options.recipients,
+        trackOpens: options.trackOpens || false,
+        trackClicks: options.trackClicks || false,
+        expiresAt: options.expiresAt?.toISOString(),
+        scheduledFor: options.scheduledFor?.toISOString(),
+        timezone: options.timezone
+      }
+    };
+    try {
+      const response = await this.client.query(mutation, variables, this.context);
+      const result = {
+        successCount: 1,
+        failureCount: 0,
+        errors: [],
+        notificationIds: [
+          response.triggerNotificationWithTemplate.id
+        ]
+      };
+      logger.info("[Notifications] Template notification sent", {
+        notificationId: response.triggerNotificationWithTemplate.id,
+        status: response.triggerNotificationWithTemplate.status
+      });
+      return result;
+    } catch (error) {
+      logger.error("[Notifications] Failed to send template notification", {
+        error
+      });
+      return {
+        successCount: 0,
+        failureCount: 1,
+        errors: [
+          error instanceof Error ? error.message : "Unknown error"
+        ],
+        notificationIds: []
+      };
+    }
+  }
+};
+
+export { NotificationChannel2 as NotificationChannel, NotificationPriority, NotificationType2 as NotificationType, NotificationsModule, TenantNotificationsModule, tenant_notifications_exports };
+//# sourceMappingURL=chunk-XC2YD6CF.js.map
+//# sourceMappingURL=chunk-XC2YD6CF.js.map