@mantiq/notify 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/notify",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Multi-channel notifications — mail, database, broadcast, SMS, Slack, webhook",
   "type": "module",
   "license": "MIT",

package/src/NotificationManager.ts

@@ -10,6 +10,12 @@ import { BroadcastChannel } from './channels/BroadcastChannel.ts'
 import { SmsChannel } from './channels/SmsChannel.ts'
 import { SlackChannel } from './channels/SlackChannel.ts'
 import { WebhookChannel } from './channels/WebhookChannel.ts'
+import { DiscordChannel } from './channels/DiscordChannel.ts'
+import { TelegramChannel } from './channels/TelegramChannel.ts'
+import { WhatsAppChannel } from './channels/WhatsAppChannel.ts'
+import { IMessageChannel } from './channels/IMessageChannel.ts'
+import { RcsChannel } from './channels/RcsChannel.ts'
+import { FirebaseChannel } from './channels/FirebaseChannel.ts'
 
 /**
  * NotificationManager — routes notifications through channels.
@@ -101,18 +107,22 @@ export class NotificationManager {
   // ── Private ───────────────────────────────────────────────────────────────
 
   private registerBuiltInChannels(): void {
+    // Zero-config channels (no credentials needed)
     this._channels.set('mail', new MailChannel())
     this._channels.set('database', new DatabaseChannel())
     this._channels.set('broadcast', new BroadcastChannel())
     this._channels.set('webhook', new WebhookChannel())
-
-    // Lazy-load SMS and Slack (need config)
-    if (this.config.channels?.sms) {
-      this._factories.set('sms', () => new SmsChannel(this.config.channels!.sms!))
-    }
-    if (this.config.channels?.slack) {
-      this._factories.set('slack', () => new SlackChannel(this.config.channels!.slack!))
-    }
+    this._channels.set('discord', new DiscordChannel())
+
+    // Config-based channels (lazy-loaded when config present)
+    const ch = this.config.channels
+    if (ch?.sms) this._factories.set('sms', () => new SmsChannel(ch.sms!))
+    if (ch?.slack) this._factories.set('slack', () => new SlackChannel(ch.slack!))
+    if (ch?.telegram) this._factories.set('telegram', () => new TelegramChannel(ch.telegram!))
+    if (ch?.whatsapp) this._factories.set('whatsapp', () => new WhatsAppChannel(ch.whatsapp!))
+    if (ch?.imessage) this._factories.set('imessage', () => new IMessageChannel(ch.imessage!))
+    if (ch?.rcs) this._factories.set('rcs', () => new RcsChannel(ch.rcs!))
+    if (ch?.firebase) this._factories.set('firebase', () => new FirebaseChannel(ch.firebase!))
   }
 
   private async queueNotification(notifiable: Notifiable, notification: Notification): Promise<void> {

package/src/channels/DiscordChannel.ts

@@ -0,0 +1,70 @@
+import type { NotificationChannel } from '../contracts/Channel.ts'
+import type { Notifiable } from '../contracts/Notifiable.ts'
+import type { Notification } from '../Notification.ts'
+import { NotifyError } from '../errors/NotifyError.ts'
+
+export interface DiscordEmbed {
+  title?: string
+  description?: string
+  url?: string
+  color?: number
+  fields?: Array<{ name: string; value: string; inline?: boolean }>
+  footer?: { text: string; icon_url?: string }
+  thumbnail?: { url: string }
+  image?: { url: string }
+  author?: { name: string; url?: string; icon_url?: string }
+  timestamp?: string
+}
+
+export interface DiscordPayload {
+  webhookUrl: string
+  content?: string
+  embeds?: DiscordEmbed[]
+  username?: string
+  avatarUrl?: string
+}
+
+/**
+ * Sends notifications to Discord via webhook URL.
+ *
+ * The notification's `toDiscord(notifiable)` method should return a `DiscordPayload`
+ * with at minimum a `webhookUrl` and either `content` or `embeds`.
+ *
+ * Uses native `fetch()` — no Discord SDK required.
+ */
+export class DiscordChannel implements NotificationChannel {
+  readonly name = 'discord'
+
+  async send(notifiable: Notifiable, notification: Notification): Promise<void> {
+    const payload = notification.getPayloadFor('discord', notifiable) as DiscordPayload | undefined
+    if (!payload) return
+
+    if (!payload.webhookUrl) {
+      throw new NotifyError('Discord payload is missing required webhookUrl', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    const body: Record<string, any> = {}
+    if (payload.content) body.content = payload.content
+    if (payload.embeds) body.embeds = payload.embeds
+    if (payload.username) body.username = payload.username
+    if (payload.avatarUrl) body.avatar_url = payload.avatarUrl
+
+    const response = await fetch(payload.webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`Discord webhook error (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        statusCode: response.status,
+      })
+    }
+  }
+}

package/src/channels/FirebaseChannel.ts

@@ -0,0 +1,237 @@
+import type { NotificationChannel } from '../contracts/Channel.ts'
+import type { Notifiable } from '../contracts/Notifiable.ts'
+import type { Notification } from '../Notification.ts'
+import { NotifyError } from '../errors/NotifyError.ts'
+
+export interface FirebaseConfig {
+  projectId: string
+  accessToken?: string
+  serviceAccountKey?: string
+}
+
+export interface FirebasePayload {
+  token?: string
+  topic?: string
+  title: string
+  body: string
+  data?: Record<string, string>
+  imageUrl?: string
+}
+
+/**
+ * Sends push notifications via Firebase Cloud Messaging (FCM) v1 API.
+ *
+ * The notification's `toFirebase(notifiable)` method should return a `FirebasePayload`
+ * with at minimum `title` and `body`. Target is resolved from `token`, `topic`, or
+ * `notifiable.routeNotificationFor('firebase')` (for the device FCM token).
+ *
+ * Two authentication modes:
+ *   1. **Access Token** — provide `accessToken` directly in config
+ *   2. **Service Account Key** — provide `serviceAccountKey` JSON string; the channel
+ *      will mint an OAuth2 token via Google's token endpoint using JWT assertion
+ *
+ * Uses native `fetch()` — no Firebase Admin SDK required.
+ */
+export class FirebaseChannel implements NotificationChannel {
+  readonly name = 'firebase'
+
+  private cachedAccessToken: string | undefined
+  private tokenExpiresAt = 0
+
+  constructor(private readonly config: FirebaseConfig) {}
+
+  async send(notifiable: Notifiable, notification: Notification): Promise<void> {
+    const payload = notification.getPayloadFor('firebase', notifiable) as FirebasePayload | undefined
+    if (!payload) return
+
+    // Resolve target: payload.token > payload.topic > notifiable route
+    const token = payload.token ?? notifiable.routeNotificationFor('firebase')
+    const topic = payload.topic
+
+    if (!token && !topic) {
+      throw new NotifyError('No FCM target: payload.token and payload.topic are empty and notifiable returned null for firebase route', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    const accessToken = await this.resolveAccessToken()
+
+    const message: Record<string, any> = {
+      notification: {
+        title: payload.title,
+        body: payload.body,
+        ...(payload.imageUrl ? { image: payload.imageUrl } : {}),
+      },
+    }
+
+    if (token) {
+      message.token = token
+    } else if (topic) {
+      message.topic = topic
+    }
+
+    if (payload.data) {
+      message.data = payload.data
+    }
+
+    const url = `https://fcm.googleapis.com/v1/projects/${this.config.projectId}/messages:send`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ message }),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`FCM API error (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        statusCode: response.status,
+      })
+    }
+  }
+
+  /**
+   * Resolve the OAuth2 access token for FCM API calls.
+   * If a static `accessToken` was provided, use it directly.
+   * Otherwise, mint a token from the service account key via JWT assertion.
+   */
+  private async resolveAccessToken(): Promise<string> {
+    if (this.config.accessToken) {
+      return this.config.accessToken
+    }
+
+    // Return cached token if still valid (with 60s safety margin)
+    if (this.cachedAccessToken && Date.now() < this.tokenExpiresAt - 60_000) {
+      return this.cachedAccessToken
+    }
+
+    if (!this.config.serviceAccountKey) {
+      throw new NotifyError('Firebase configuration requires either accessToken or serviceAccountKey', {
+        channel: this.name,
+      })
+    }
+
+    let serviceAccount: {
+      client_email: string
+      private_key: string
+      token_uri?: string
+    }
+
+    try {
+      serviceAccount = JSON.parse(this.config.serviceAccountKey)
+    } catch {
+      throw new NotifyError('Firebase serviceAccountKey is not valid JSON', {
+        channel: this.name,
+      })
+    }
+
+    const tokenUri = serviceAccount.token_uri ?? 'https://oauth2.googleapis.com/token'
+    const now = Math.floor(Date.now() / 1000)
+    const expiry = now + 3600
+
+    const jwt = await this.createJwt(
+      {
+        iss: serviceAccount.client_email,
+        sub: serviceAccount.client_email,
+        aud: tokenUri,
+        iat: now,
+        exp: expiry,
+        scope: 'https://www.googleapis.com/auth/firebase.messaging',
+      },
+      serviceAccount.private_key,
+    )
+
+    const response = await fetch(tokenUri, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+        assertion: jwt,
+      }),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`Failed to obtain FCM access token (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        statusCode: response.status,
+      })
+    }
+
+    const result = await response.json()
+    this.cachedAccessToken = result.access_token
+    this.tokenExpiresAt = Date.now() + (result.expires_in ?? 3600) * 1000
+
+    return this.cachedAccessToken!
+  }
+
+  /**
+   * Create a signed JWT using the Web Crypto API (RS256).
+   * Parses a PEM-encoded RSA private key and signs with RSASSA-PKCS1-v1_5.
+   */
+  private async createJwt(claims: Record<string, any>, privateKeyPem: string): Promise<string> {
+    const header = { alg: 'RS256', typ: 'JWT' }
+
+    const encodedHeader = this.base64UrlEncode(JSON.stringify(header))
+    const encodedClaims = this.base64UrlEncode(JSON.stringify(claims))
+    const signingInput = `${encodedHeader}.${encodedClaims}`
+
+    // Import the PEM private key
+    const keyData = this.pemToArrayBuffer(privateKeyPem)
+    const cryptoKey = await crypto.subtle.importKey(
+      'pkcs8',
+      keyData,
+      { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
+      false,
+      ['sign'],
+    )
+
+    // Sign
+    const signatureBuffer = await crypto.subtle.sign(
+      'RSASSA-PKCS1-v1_5',
+      cryptoKey,
+      new TextEncoder().encode(signingInput),
+    )
+
+    const encodedSignature = this.base64UrlEncodeBuffer(new Uint8Array(signatureBuffer))
+
+    return `${signingInput}.${encodedSignature}`
+  }
+
+  /** Convert a PEM-encoded key to an ArrayBuffer */
+  private pemToArrayBuffer(pem: string): ArrayBuffer {
+    const base64 = pem
+      .replace(/-----BEGIN [A-Z ]+-----/g, '')
+      .replace(/-----END [A-Z ]+-----/g, '')
+      .replace(/\s/g, '')
+
+    const binary = atob(base64)
+    const bytes = new Uint8Array(binary.length)
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i)
+    }
+    return bytes.buffer
+  }
+
+  /** Base64url-encode a UTF-8 string */
+  private base64UrlEncode(str: string): string {
+    const base64 = btoa(str)
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+  }
+
+  /** Base64url-encode a Uint8Array */
+  private base64UrlEncodeBuffer(buffer: Uint8Array): string {
+    let binary = ''
+    for (const byte of buffer) {
+      binary += String.fromCharCode(byte)
+    }
+    const base64 = btoa(binary)
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+  }
+}

package/src/channels/IMessageChannel.ts

@@ -0,0 +1,69 @@
+import type { NotificationChannel } from '../contracts/Channel.ts'
+import type { Notifiable } from '../contracts/Notifiable.ts'
+import type { Notification } from '../Notification.ts'
+import { NotifyError } from '../errors/NotifyError.ts'
+
+export interface IMessageConfig {
+  serviceUrl: string
+  authToken: string
+}
+
+export interface IMessagePayload {
+  to?: string
+  text: string
+  interactiveData?: any
+}
+
+/**
+ * Sends notifications via Apple Business Messages (Messages for Business API).
+ *
+ * The notification's `toImessage(notifiable)` method should return an `IMessagePayload`
+ * with at minimum `text`. If `to` is not provided in the payload, the channel
+ * falls back to `notifiable.routeNotificationFor('imessage')`.
+ *
+ * Uses native `fetch()` — no Apple SDK required.
+ */
+export class IMessageChannel implements NotificationChannel {
+  readonly name = 'imessage'
+
+  constructor(private readonly config: IMessageConfig) {}
+
+  async send(notifiable: Notifiable, notification: Notification): Promise<void> {
+    const payload = notification.getPayloadFor('imessage', notifiable) as IMessagePayload | undefined
+    if (!payload) return
+
+    const to = payload.to ?? notifiable.routeNotificationFor('imessage')
+    if (!to) {
+      throw new NotifyError('No iMessage recipient: payload.to is empty and notifiable returned null for imessage route', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    const body: Record<string, any> = {
+      to,
+      text: payload.text,
+    }
+    if (payload.interactiveData) body.interactiveData = payload.interactiveData
+
+    const url = `${this.config.serviceUrl}/messages`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.authToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`iMessage API error (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        statusCode: response.status,
+      })
+    }
+  }
+}

package/src/channels/RcsChannel.ts

@@ -0,0 +1,83 @@
+import type { NotificationChannel } from '../contracts/Channel.ts'
+import type { Notifiable } from '../contracts/Notifiable.ts'
+import type { Notification } from '../Notification.ts'
+import { NotifyError } from '../errors/NotifyError.ts'
+
+export interface RcsConfig {
+  agentId: string
+  accessToken: string
+}
+
+export interface RcsPayload {
+  to?: string
+  text?: string
+  richCard?: any
+  suggestions?: any[]
+}
+
+/**
+ * Sends notifications via Google RCS Business Messaging (RBM) Agent API.
+ *
+ * The notification's `toRcs(notifiable)` method should return an `RcsPayload`
+ * with either `text` or `richCard`. If `to` is not provided in the payload,
+ * the channel falls back to `notifiable.routeNotificationFor('rcs')`.
+ *
+ * Uses native `fetch()` — no Google SDK required.
+ */
+export class RcsChannel implements NotificationChannel {
+  readonly name = 'rcs'
+
+  constructor(private readonly config: RcsConfig) {}
+
+  async send(notifiable: Notifiable, notification: Notification): Promise<void> {
+    const payload = notification.getPayloadFor('rcs', notifiable) as RcsPayload | undefined
+    if (!payload) return
+
+    const to = payload.to ?? notifiable.routeNotificationFor('rcs')
+    if (!to) {
+      throw new NotifyError('No RCS recipient: payload.to is empty and notifiable returned null for rcs route', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    const contentMessage: Record<string, any> = {}
+
+    if (payload.richCard) {
+      contentMessage.richCard = payload.richCard
+    } else if (payload.text) {
+      contentMessage.text = payload.text
+    } else {
+      throw new NotifyError('RCS payload must contain either text or richCard', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    if (payload.suggestions) {
+      contentMessage.suggestions = payload.suggestions
+    }
+
+    const body: Record<string, any> = { contentMessage }
+
+    const url = `https://rcsbusinessmessaging.googleapis.com/v1/phones/${encodeURIComponent(String(to))}/agentMessages`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`RCS API error (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        statusCode: response.status,
+      })
+    }
+  }
+}

package/src/channels/TelegramChannel.ts

@@ -0,0 +1,76 @@
+import type { NotificationChannel } from '../contracts/Channel.ts'
+import type { Notifiable } from '../contracts/Notifiable.ts'
+import type { Notification } from '../Notification.ts'
+import { NotifyError } from '../errors/NotifyError.ts'
+
+export interface TelegramConfig {
+  botToken: string
+}
+
+export interface TelegramPayload {
+  chatId?: string | number
+  text: string
+  parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2'
+  replyMarkup?: any
+}
+
+/**
+ * Sends notifications via the Telegram Bot API.
+ *
+ * The notification's `toTelegram(notifiable)` method should return a `TelegramPayload`
+ * with at minimum `text`. If `chatId` is not provided in the payload, the channel
+ * falls back to `notifiable.routeNotificationFor('telegram')`.
+ *
+ * Uses native `fetch()` — no Telegram SDK required.
+ */
+export class TelegramChannel implements NotificationChannel {
+  readonly name = 'telegram'
+
+  constructor(private readonly config: TelegramConfig) {}
+
+  async send(notifiable: Notifiable, notification: Notification): Promise<void> {
+    const payload = notification.getPayloadFor('telegram', notifiable) as TelegramPayload | undefined
+    if (!payload) return
+
+    const chatId = payload.chatId ?? notifiable.routeNotificationFor('telegram')
+    if (!chatId) {
+      throw new NotifyError('No Telegram chat ID: payload.chatId is empty and notifiable returned null for telegram route', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    const body: Record<string, any> = {
+      chat_id: chatId,
+      text: payload.text,
+    }
+    if (payload.parseMode) body.parse_mode = payload.parseMode
+    if (payload.replyMarkup) body.reply_markup = payload.replyMarkup
+
+    const url = `https://api.telegram.org/bot${this.config.botToken}/sendMessage`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`Telegram API error (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        statusCode: response.status,
+      })
+    }
+
+    const result = await response.json().catch(() => null)
+    if (result && !result.ok) {
+      throw new NotifyError(`Telegram API error: ${result.description ?? 'unknown error'}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        errorCode: result.error_code,
+      })
+    }
+  }
+}

package/src/channels/WhatsAppChannel.ts

@@ -0,0 +1,103 @@
+import type { NotificationChannel } from '../contracts/Channel.ts'
+import type { Notifiable } from '../contracts/Notifiable.ts'
+import type { Notification } from '../Notification.ts'
+import { NotifyError } from '../errors/NotifyError.ts'
+
+export interface WhatsAppConfig {
+  accessToken: string
+  phoneNumberId: string
+}
+
+export interface WhatsAppPayload {
+  to?: string
+  template?: {
+    name: string
+    languageCode: string
+    components?: any[]
+  }
+  text?: string
+}
+
+/**
+ * Sends notifications via the Meta Cloud API for WhatsApp Business.
+ *
+ * The notification's `toWhatsapp(notifiable)` method should return a `WhatsAppPayload`
+ * with either a `template` or `text` message. If `to` is not provided in the payload,
+ * the channel falls back to `notifiable.routeNotificationFor('whatsapp')`.
+ *
+ * Uses native `fetch()` — no WhatsApp SDK required.
+ */
+export class WhatsAppChannel implements NotificationChannel {
+  readonly name = 'whatsapp'
+
+  constructor(private readonly config: WhatsAppConfig) {}
+
+  async send(notifiable: Notifiable, notification: Notification): Promise<void> {
+    const payload = notification.getPayloadFor('whatsapp', notifiable) as WhatsAppPayload | undefined
+    if (!payload) return
+
+    const to = payload.to ?? notifiable.routeNotificationFor('whatsapp')
+    if (!to) {
+      throw new NotifyError('No WhatsApp recipient: payload.to is empty and notifiable returned null for whatsapp route', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    let body: Record<string, any>
+
+    if (payload.template) {
+      body = {
+        messaging_product: 'whatsapp',
+        to,
+        type: 'template',
+        template: {
+          name: payload.template.name,
+          language: { code: payload.template.languageCode },
+          ...(payload.template.components ? { components: payload.template.components } : {}),
+        },
+      }
+    } else if (payload.text) {
+      body = {
+        messaging_product: 'whatsapp',
+        to,
+        type: 'text',
+        text: { body: payload.text },
+      }
+    } else {
+      throw new NotifyError('WhatsApp payload must contain either template or text', {
+        channel: this.name,
+        notificationType: notification.type,
+      })
+    }
+
+    const url = `https://graph.facebook.com/v21.0/${this.config.phoneNumberId}/messages`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => 'unknown error')
+      throw new NotifyError(`WhatsApp API error (${response.status}): ${errorBody}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        statusCode: response.status,
+      })
+    }
+
+    const result = await response.json().catch(() => null)
+    if (result?.error) {
+      throw new NotifyError(`WhatsApp API error: ${result.error.message ?? 'unknown error'}`, {
+        channel: this.name,
+        notificationType: notification.type,
+        errorCode: result.error.code,
+      })
+    }
+  }
+}

package/src/contracts/NotifyConfig.ts

@@ -9,10 +9,40 @@ export interface SlackConfig {
   token?: string
 }
 
+export interface TelegramConfig {
+  botToken: string
+}
+
+export interface WhatsAppConfig {
+  accessToken: string
+  phoneNumberId: string
+}
+
+export interface IMessageConfig {
+  serviceUrl: string
+  authToken: string
+}
+
+export interface RcsConfig {
+  agentId: string
+  accessToken: string
+}
+
+export interface FirebaseConfig {
+  projectId: string
+  accessToken?: string
+  serviceAccountKey?: string
+}
+
 export interface NotifyConfig {
   channels?: {
     sms?: SmsConfig
     slack?: SlackConfig
+    telegram?: TelegramConfig
+    whatsapp?: WhatsAppConfig
+    imessage?: IMessageConfig
+    rcs?: RcsConfig
+    firebase?: FirebaseConfig
   }
 }
 

package/src/index.ts

@@ -1,7 +1,7 @@
 // ── Contracts ────────────────────────────────────────────────────────────────
 export type { NotificationChannel } from './contracts/Channel.ts'
 export type { Notifiable } from './contracts/Notifiable.ts'
-export type { NotifyConfig, SmsConfig, SlackConfig } from './contracts/NotifyConfig.ts'
+export type { NotifyConfig, SmsConfig, SlackConfig, TelegramConfig, WhatsAppConfig, IMessageConfig, RcsConfig, FirebaseConfig } from './contracts/NotifyConfig.ts'
 
 // ── Core ─────────────────────────────────────────────────────────────────────
 export { Notification } from './Notification.ts'
@@ -15,6 +15,12 @@ export { BroadcastChannel } from './channels/BroadcastChannel.ts'
 export { SmsChannel } from './channels/SmsChannel.ts'
 export { SlackChannel } from './channels/SlackChannel.ts'
 export { WebhookChannel } from './channels/WebhookChannel.ts'
+export { DiscordChannel } from './channels/DiscordChannel.ts'
+export { TelegramChannel } from './channels/TelegramChannel.ts'
+export { WhatsAppChannel } from './channels/WhatsAppChannel.ts'
+export { IMessageChannel } from './channels/IMessageChannel.ts'
+export { RcsChannel } from './channels/RcsChannel.ts'
+export { FirebaseChannel } from './channels/FirebaseChannel.ts'
 
 // ── Models ───────────────────────────────────────────────────────────────────
 export { DatabaseNotification } from './models/DatabaseNotification.ts'