okengine 0.6.0 → 0.6.1

package/src/drivers/channel-wa-cloud.ts

@@ -1,7 +1,9 @@
 /**
- * `wa-cloud` channel driver — WhatsApp Cloud API (Meta).
+ * `wa-cloud` channel driver — WhatsApp Cloud API via sently.
  */
 
+import { WhatsAppCloudTransport } from "sently/transports/whatsapp-cloud";
+import { mapSentlySendError, mapSentlySendResult } from "./channel-sently-map.ts";
 import type {
   ChannelDriver,
   ChannelMessage,
@@ -13,64 +15,48 @@ import type {
 /**
  * Open a WhatsApp Cloud API driver.
  *
- * @param options - `token` (access token) + `from` (phone number id)
+ * @param options - `token`/`apiKey` (access token) + `from` (phone number id)
  */
 export function openWaCloudChannel(options: ChannelOpenOptions = {}): ChannelDriver {
-  const token = options.token ?? options.apiKey;
+  const accessToken = options.token ?? options.apiKey;
   const phoneNumberId = options.from;
-  const fetchFn = options.fetch ?? globalThis.fetch;
-  const base = options.url ?? "https://graph.facebook.com/v19.0";
+  if (!accessToken || !phoneNumberId) {
+    throw new Error("wa-cloud: token and from (phone number id) are required");
+  }
+
+  const transport = new WhatsAppCloudTransport({ accessToken, phoneNumberId });
 
   const channel: ChannelTransport = {
     provider: "wa-cloud",
     mediums: ["whatsapp"],
     async send(message: ChannelMessage): Promise<ChannelSendResult> {
-      if (!token || !phoneNumberId) {
-        throw new Error("wa-cloud: token and from (phone number id) are required");
-      }
-      const res = await fetchFn(`${base}/${phoneNumberId}/messages`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          messaging_product: "whatsapp",
-          to: message.to,
-          type: "text",
-          text: { body: message.text ?? "" },
-        }),
-      });
-      const body = (await res.json().catch(() => ({}))) as {
-        messages?: Array<{ id?: string }>;
-        error?: { message?: string };
-      };
-      const id = body.messages?.[0]?.id ?? crypto.randomUUID();
-      if (!res.ok) {
-        return {
-          ok: false,
-          messageId: id,
-          driverId: "wa-cloud",
-          attempts: [
-            {
-              driverId: "wa-cloud",
-              ok: false,
-              error: body.error?.message ?? `HTTP ${res.status}`,
-              at: Date.now(),
-            },
-          ],
-        };
+      try {
+        const templateName =
+          message.template ??
+          (typeof message.data?.template === "string" ? message.data.template : undefined);
+        const language =
+          message.locale ??
+          (typeof message.data?.language === "string" ? message.data.language : "en_US");
+
+        const result = templateName
+          ? await transport.send({
+              to: message.to,
+              template: { name: templateName, language },
+            })
+          : await transport.send({
+              to: message.to,
+              text: message.text ?? "",
+            });
+
+        return mapSentlySendResult("wa-cloud", result);
+      } catch (err) {
+        return mapSentlySendError("wa-cloud", err);
       }
-      return {
-        ok: true,
-        messageId: id,
-        driverId: "wa-cloud",
-        attempts: [{ driverId: "wa-cloud", ok: true, at: Date.now(), messageId: id }],
-      };
     },
+    verify: () => transport.verify(),
   };
 
-  return { id: "wa-cloud", channel };
+  return { id: "wa-cloud", channel, whatsappTransport: transport };
 }
 
 /** WhatsApp Cloud driver factory. */

package/src/drivers/channel-webpush.ts

@@ -1,9 +1,12 @@
 /**
- * `webpush` channel driver — RFC 8030 (Web Push) + VAPID (RFC 8292).
+ * `webpush` channel driver — RFC 8030 + VAPID via sently.
  *
- * Implemented natively with Web Crypto. No third-party push library.
+ * Call path: ChannelTransport.send → createPushSender → WebPushTransport.
  */
 
+import { createPushSender } from "sently/push";
+import { WebPushTransport } from "sently/transports/webpush";
+import { mapSentlySendError, mapSentlySendResult } from "./channel-sently-map.ts";
 import type {
   ChannelDriver,
   ChannelMessage,
@@ -12,263 +15,60 @@ import type {
   ChannelTransport,
 } from "./channel-types.ts";
 
-/**
- * Decode a URL-safe base64 string.
- *
- * @param input - Base64url text
- */
-function b64urlDecode(input: string): Uint8Array<ArrayBuffer> {
-  const pad = "=".repeat((4 - (input.length % 4)) % 4);
-  const b64 = (input + pad).replace(/-/g, "+").replace(/_/g, "/");
-  const bin = atob(b64);
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
-}
-
-/** Fresh buffer for Web Crypto `BufferSource` typing. */
-function asBufferSource(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
-  return new Uint8Array(bytes);
-}
-
-/**
- * Encode bytes as base64url (no padding).
- *
- * @param bytes - Input
- */
-function b64urlEncode(bytes: Uint8Array): string {
-  let s = "";
-  for (const b of bytes) s += String.fromCharCode(b);
-  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-/**
- * Import a VAPID ECDSA P-256 private key from base64url raw or PKCS8.
- *
- * @param privateKeyB64 - Base64url private key
- */
-async function importVapidPrivateKey(privateKeyB64: string): Promise<CryptoKey> {
-  const raw = b64urlDecode(privateKeyB64);
-  // Prefer PKCS8; fall back to raw JWK construction for 32-byte seeds.
-  if (raw.length > 32) {
-    return crypto.subtle.importKey(
-      "pkcs8",
-      asBufferSource(raw),
-      { name: "ECDSA", namedCurve: "P-256" },
-      false,
-      ["sign"],
-    );
-  }
-  // Build a minimal JWK from d (and a synthetic public x/y via derive is hard);
-  // tests inject fetch and only need Authorization header shape — use ECDSA
-  // with a generated key when raw seed is provided without full PKCS8.
-  const pair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, [
-    "sign",
-    "verify",
-  ]);
-  return pair.privateKey;
-}
-
-/**
- * Build a VAPID JWT (RFC 8292) for the push audience.
- *
- * @param audience - Origin of the push service
- * @param subject - `mailto:` or HTTPS contact
- * @param privateKey - ECDSA P-256 key
- */
-async function buildVapidJwt(
-  audience: string,
-  subject: string,
-  privateKey: CryptoKey,
-): Promise<string> {
-  const header = b64urlEncode(
-    new TextEncoder().encode(JSON.stringify({ typ: "JWT", alg: "ES256" })),
-  );
-  const exp = Math.floor(Date.now() / 1000) + 12 * 60 * 60;
-  const payload = b64urlEncode(
-    new TextEncoder().encode(JSON.stringify({ aud: audience, exp, sub: subject })),
-  );
-  const data = new TextEncoder().encode(`${header}.${payload}`);
-  const sig = new Uint8Array(
-    await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, privateKey, data),
-  );
-  // Convert DER → raw r||s if needed; Web Crypto in Bun returns raw P-1363.
-  return `${header}.${payload}.${b64urlEncode(sig)}`;
-}
-
-/**
- * Minimal RFC 8030 encrypted body: salt + rs + server public + ciphertext.
- * For tests with injected fetch we send a well-formed envelope; production
- * should use full ece (aes128gcm). Here we implement aes128gcm content-coding
- * with Web Crypto ECDH + HKDF as specified.
- *
- * @param plaintext - Push payload bytes
- * @param p256dh - Subscriber public key (base64url)
- * @param auth - Subscriber auth secret (base64url)
- */
-async function encryptPushBody(
-  plaintext: Uint8Array,
-  p256dh: string,
-  auth: string,
-): Promise<{ body: Uint8Array; salt: Uint8Array; localPublic: Uint8Array }> {
-  const userPublic = await crypto.subtle.importKey(
-    "raw",
-    asBufferSource(b64urlDecode(p256dh)),
-    { name: "ECDH", namedCurve: "P-256" },
-    true,
-    [],
-  );
-  const local = await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, [
-    "deriveBits",
-  ]);
-  const shared = new Uint8Array(
-    await crypto.subtle.deriveBits({ name: "ECDH", public: userPublic }, local.privateKey, 256),
-  );
-  const salt = crypto.getRandomValues(new Uint8Array(16));
-  const authSecret = b64urlDecode(auth);
-
-  // HKDF-SHA-256 as in RFC 8291
-  const ikmKey = await crypto.subtle.importKey("raw", asBufferSource(shared), "HKDF", false, [
-    "deriveBits",
-  ]);
-  const prk = new Uint8Array(
-    await crypto.subtle.deriveBits(
-      {
-        name: "HKDF",
-        hash: "SHA-256",
-        salt: asBufferSource(authSecret),
-        info: new TextEncoder().encode("WebPush: info\0"),
-      },
-      ikmKey,
-      256,
-    ),
-  );
-  // Simplified content encryption key / nonce derivation for aes128gcm
-  const prkKey = await crypto.subtle.importKey("raw", prk, "HKDF", false, ["deriveBits"]);
-  const cek = new Uint8Array(
-    await crypto.subtle.deriveBits(
-      {
-        name: "HKDF",
-        hash: "SHA-256",
-        salt,
-        info: new TextEncoder().encode("Content-Encoding: aes128gcm\0"),
-      },
-      prkKey,
-      128,
-    ),
-  );
-  const nonce = new Uint8Array(
-    await crypto.subtle.deriveBits(
-      {
-        name: "HKDF",
-        hash: "SHA-256",
-        salt,
-        info: new TextEncoder().encode("Content-Encoding: nonce\0"),
-      },
-      prkKey,
-      96,
-    ),
-  );
-  const aes = await crypto.subtle.importKey("raw", cek, { name: "AES-GCM" }, false, ["encrypt"]);
-  // Add RFC 8188 padding delimiter (0x02) then encrypt
-  const padded = new Uint8Array(plaintext.length + 1);
-  padded.set(plaintext, 0);
-  padded[plaintext.length] = 2;
-  const ciphertext = new Uint8Array(
-    await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, aes, padded),
-  );
-  const localPublic = new Uint8Array(await crypto.subtle.exportKey("raw", local.publicKey));
-
-  // Body = salt (16) || rs (4) || idlen (1) || keyid || ciphertext
-  const rs = new Uint8Array(4);
-  new DataView(rs.buffer).setUint32(0, 4096);
-  const idlen = new Uint8Array([localPublic.length]);
-  const body = new Uint8Array(16 + 4 + 1 + localPublic.length + ciphertext.length);
-  body.set(salt, 0);
-  body.set(rs, 16);
-  body.set(idlen, 20);
-  body.set(localPublic, 21);
-  body.set(ciphertext, 21 + localPublic.length);
-  return { body, salt, localPublic };
-}
-
 /**
  * Open a Web Push driver (RFC 8030 + VAPID).
  *
  * @param options - VAPID keys + subject
  */
 export function openWebPushChannel(options: ChannelOpenOptions = {}): ChannelDriver {
-  const vapidPublic = options.vapidPublicKey;
-  const vapidPrivate = options.vapidPrivateKey;
+  const vapidPublicKey = options.vapidPublicKey;
+  const vapidPrivateKey = options.vapidPrivateKey;
   const subject = options.vapidSubject ?? "mailto:ops@oke.local";
-  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (!vapidPublicKey || !vapidPrivateKey) {
+    throw new Error("webpush: vapidPublicKey and vapidPrivateKey are required");
+  }
+
+  const transport = new WebPushTransport({
+    vapidPublicKey,
+    vapidPrivateKey,
+    subject,
+  });
+  const sender = createPushSender({ transport });
 
   const channel: ChannelTransport = {
     provider: "webpush",
     mediums: ["push"],
     async send(message: ChannelMessage): Promise<ChannelSendResult> {
-      if (!vapidPrivate || !vapidPublic) {
-        throw new Error("webpush: vapidPublicKey and vapidPrivateKey are required");
-      }
       const sub = message.pushSubscription;
       const endpoint = sub?.endpoint ?? message.to;
-      if (!endpoint.startsWith("http")) {
-        throw new Error("webpush: pushSubscription.endpoint (or https to) required");
-      }
-      const audience = new URL(endpoint).origin;
-      const privateKey = await importVapidPrivateKey(vapidPrivate);
-      const jwt = await buildVapidJwt(audience, subject, privateKey);
-
-      const plaintext = new TextEncoder().encode(
-        message.text ?? JSON.stringify(message.data ?? {}),
-      );
-      let body: Uint8Array = plaintext;
-      const headers: Record<string, string> = {
-        Authorization: `vapid t=${jwt}, k=${vapidPublic}`,
-        TTL: "86400",
-        Urgency: "normal",
-      };
-
-      if (sub?.keys?.p256dh && sub.keys.auth) {
-        const enc = await encryptPushBody(plaintext, sub.keys.p256dh, sub.keys.auth);
-        body = enc.body;
-        headers["Content-Encoding"] = "aes128gcm";
-        headers["Content-Type"] = "application/octet-stream";
-      } else {
-        headers["Content-Type"] = "text/plain;charset=utf-8";
+      if (!endpoint.startsWith("http") || !sub?.keys?.p256dh || !sub.keys.auth) {
+        throw new Error("webpush: pushSubscription with endpoint + keys is required");
       }
 
-      const res = await fetchFn(endpoint, {
-        method: "POST",
-        headers,
-        body: body as unknown as ArrayBuffer,
-      });
-      const id = res.headers.get("location") ?? crypto.randomUUID();
-      if (!res.ok && res.status !== 201) {
-        return {
-          ok: false,
-          messageId: id,
-          driverId: "webpush",
-          attempts: [
-            {
-              driverId: "webpush",
-              ok: false,
-              error: `HTTP ${res.status}`,
-              at: Date.now(),
-            },
-          ],
-        };
+      try {
+        const title =
+          message.subject ??
+          (typeof message.data?.title === "string" ? message.data.title : "Notification");
+        const body = message.text ?? JSON.stringify(message.data ?? {});
+        const result = await sender.send({
+          subscription: {
+            endpoint,
+            keys: { p256dh: sub.keys.p256dh, auth: sub.keys.auth },
+          },
+          title,
+          body,
+          ...(message.data ? { data: { ...message.data } } : {}),
+        });
+        return mapSentlySendResult("webpush", result);
+      } catch (err) {
+        return mapSentlySendError("webpush", err);
       }
-      return {
-        ok: true,
-        messageId: id,
-        driverId: "webpush",
-        attempts: [{ driverId: "webpush", ok: true, at: Date.now(), messageId: id }],
-      };
     },
+    verify: () => sender.verify(),
+    close: () => sender.close(),
   };
 
-  return { id: "webpush", channel };
+  return { id: "webpush", channel, pushTransport: transport };
 }
 
 /** Web Push driver factory. */

package/src/drivers/index.ts

@@ -139,10 +139,14 @@ export { createChannelInbox } from "./channel-types.ts";
 export { consoleChannelDriver, openConsoleChannel } from "./channel-console.ts";
 export { smtpChannelDriver, openSmtpChannel } from "./channel-smtp.ts";
 export { resendChannelDriver, openResendChannel } from "./channel-resend.ts";
+export { sndrChannelDriver, openSndrChannel } from "./channel-sndr.ts";
+export { taqnyatChannelDriver, openTaqnyatChannel } from "./channel-taqnyat.ts";
+export { msegatChannelDriver, openMsegatChannel } from "./channel-msegat.ts";
 export { unifonicChannelDriver, openUnifonicChannel } from "./channel-unifonic.ts";
 export { waCloudChannelDriver, openWaCloudChannel } from "./channel-wa-cloud.ts";
 export { fcmChannelDriver, openFcmChannel } from "./channel-fcm.ts";
 export { webpushChannelDriver, openWebPushChannel } from "./channel-webpush.ts";
+export { mapSentlySendResult, mapSentlySendError } from "./channel-sently-map.ts";
 
 export type {
   AiDriverId,

package/src/elements/channel/costs.test.ts

@@ -18,7 +18,7 @@ describe("fallbackWeeklyCostDelta", () => {
         status: "fallback",
         attempts: [
           { driverId: "wa-cloud", ok: false, at: weekStart + 1 },
-          { driverId: "unifonic", ok: true, at: weekStart + 2 },
+          { driverId: "taqnyat", ok: true, at: weekStart + 2 },
         ],
         at: weekStart + 3,
       },
@@ -39,7 +39,7 @@ describe("fallbackWeeklyCostDelta", () => {
         status: "fallback",
         attempts: [
           { driverId: "wa-cloud", ok: false, at: weekStart + 6 },
-          { driverId: "unifonic", ok: true, at: weekStart + 7 },
+          { driverId: "msegat", ok: true, at: weekStart + 7 },
         ],
         at: weekStart + 8,
       },

package/src/elements/channel/costs.ts

@@ -106,13 +106,25 @@ export function fallbackWeeklyCostDelta(
 function mediumFromDriver(driverId: string, receiptMedium: string): string {
   const id = driverId.toLowerCase();
   if (id.includes("wa") || id.includes("whatsapp")) return "whatsapp";
-  if (id.includes("sms") || id.includes("unifonic") || id.includes("twilio")) {
+  if (
+    id.includes("sms") ||
+    id.includes("taqnyat") ||
+    id.includes("msegat") ||
+    id.includes("unifonic") ||
+    id.includes("twilio")
+  ) {
     return "sms";
   }
   if (id.includes("push") || id.includes("fcm") || id.includes("webpush")) {
     return "push";
   }
-  if (id.includes("smtp") || id.includes("resend") || id.includes("ses") || id.includes("email")) {
+  if (
+    id.includes("smtp") ||
+    id.includes("resend") ||
+    id.includes("sndr") ||
+    id.includes("ses") ||
+    id.includes("email")
+  ) {
     return "email";
   }
   return receiptMedium === "any" ? "email" : receiptMedium;

package/src/elements/channel/mime.ts

@@ -11,3 +11,14 @@ export type { Attachment, MailOptions, SendResult, Transport, RetryConfig } from
 export { SentlyError } from "sently/errors";
 export { RetryTransport } from "sently/transports/retry";
 export { FallbackTransport, FallbackError, type FallbackAttempt } from "sently/transports/fallback";
+export {
+  toChannelSendResult,
+  type AnySendResult,
+  type ChannelSendResult as SentlyChannelSendResult,
+} from "sently/channel-result";
+export {
+  parse as parseSndrWebhook,
+  verifySignature as verifySndrSignature,
+} from "sently/webhooks/sndr";
+export { parse as parseUnifonicWebhook } from "sently/webhooks/unifonic";
+export { toDeliveryEvent, type EmailEvent, type DeliveryEvent } from "sently/webhooks";

package/src/elements/channel/runtime.ts

@@ -246,10 +246,104 @@ export function createChannelRuntime(options: CreateChannelRuntimeOptions = {}):
     }
   }
 
+  async function sendViaSmsFallback(
+    chain: ChannelDriver[],
+    message: ChannelMessage,
+  ): Promise<{ result: ChannelSendResult; attempts: ChannelAttempt[] } | undefined> {
+    const sms = chain
+      .map((d) => (d.smsTransport ? { driver: d, transport: d.smsTransport } : undefined))
+      .filter(
+        (
+          x,
+        ): x is { driver: ChannelDriver; transport: NonNullable<ChannelDriver["smsTransport"]> } =>
+          !!x,
+      );
+    if (sms.length === 0) return undefined;
+
+    const attempts: ChannelAttempt[] = [];
+    const transports = sms.map(({ transport }) =>
+      options.retry ? new RetryTransport(transport) : transport,
+    );
+    const fallback = new FallbackTransport(transports, {
+      onFallback(failedIndex, error) {
+        const provider =
+          transports[failedIndex]?.provider ?? sms[failedIndex]?.driver.id ?? `sms-${failedIndex}`;
+        attempts.push({
+          driverId: provider,
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+          at: now(),
+        });
+      },
+    });
+
+    const body = {
+      to: message.to,
+      body: message.text ?? String(message.data?.code ?? ""),
+      ...(message.from ? { from: message.from } : {}),
+    };
+
+    try {
+      const sendResult = await fallback.send(body);
+      const driverId =
+        sendResult.provider ??
+        transports[sendResult.providerIndex ?? 0]?.provider ??
+        sms[0]?.driver.id ??
+        "sms";
+      attempts.push({
+        driverId,
+        ok: true,
+        at: now(),
+        messageId: sendResult.messageId,
+      });
+      return {
+        result: {
+          ok: true,
+          messageId: sendResult.messageId,
+          driverId,
+          attempts,
+        },
+        attempts,
+      };
+    } catch (err) {
+      const fbAttempts =
+        err &&
+        typeof err === "object" &&
+        "attempts" in err &&
+        Array.isArray((err as { attempts: FallbackAttempt[] }).attempts)
+          ? (err as { attempts: FallbackAttempt[] }).attempts
+          : [];
+      for (const a of fbAttempts) {
+        if (!attempts.some((x) => x.driverId === a.provider && !x.ok)) {
+          attempts.push({
+            driverId: a.provider,
+            ok: false,
+            error: a.error instanceof Error ? a.error.message : String(a.error),
+            at: now(),
+          });
+        }
+      }
+      return {
+        result: {
+          ok: false,
+          messageId: crypto.randomUUID(),
+          driverId: "fallback",
+          attempts,
+        },
+        attempts,
+      };
+    }
+  }
+
   async function sendViaChannelChain(
     chain: ChannelDriver[],
     message: ChannelMessage,
   ): Promise<{ result: ChannelSendResult; attempts: ChannelAttempt[] }> {
+    if (message.medium === "sms") {
+      const viaSms = await sendViaSmsFallback(chain, message);
+      if (viaSms) return viaSms;
+    }
+
     const attempts: ChannelAttempt[] = [];
     for (const d of chain) {
       if (!d.channel) continue;

package/src/elements/channel/sndr-webhooks.test.ts

@@ -0,0 +1,26 @@
+/**
+ * SNDR webhook helpers re-exported from sently.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { parseSndrWebhook } from "./mime.ts";
+
+describe("parseSndrWebhook", () => {
+  test("normalizes a delivery event payload", () => {
+    const events = parseSndrWebhook({
+      type: "email.delivered",
+      data: {
+        email_id: "em_test",
+        to: ["user@example.com"],
+      },
+    });
+    expect(events).toEqual([
+      expect.objectContaining({
+        provider: "sndr",
+        type: "delivered",
+        messageId: "em_test",
+        recipient: "user@example.com",
+      }),
+    ]);
+  });
+});

package/src/elements/channel.ts

@@ -2,7 +2,7 @@
  * Channel element — reaching humans.
  *
  * Physics: email · SMS · WhatsApp · push.
- * Drivers: `console` · `smtp` · `resend` · `unifonic` · `wa-cloud` · `fcm` · `webpush`.
+ * Drivers: `console` · `smtp` · `resend` · `sndr` · `taqnyat` · `msegat` · `unifonic` · `wa-cloud` · `fcm` · `webpush`.
  *
  * Transport interface is identical to sently's so its transports run unchanged.
  * MIME, attachments, retry, and the unified error hierarchy come from sently.
@@ -91,9 +91,18 @@ export {
   RetryTransport,
   FallbackTransport,
   FallbackError,
+  toChannelSendResult,
+  toDeliveryEvent,
+  parseSndrWebhook,
+  verifySndrSignature,
+  parseUnifonicWebhook,
   type Attachment,
   type MailOptions,
   type SendResult,
   type Transport,
   type FallbackAttempt,
+  type EmailEvent,
+  type DeliveryEvent,
+  type AnySendResult,
+  type SentlyChannelSendResult,
 } from "./channel/mime.ts";

package/src/elements/index.ts

@@ -132,6 +132,11 @@ export {
   RetryTransport,
   FallbackTransport,
   FallbackError,
+  parseSndrWebhook,
+  verifySndrSignature,
+  parseUnifonicWebhook,
+  toChannelSendResult,
+  toDeliveryEvent,
 } from "./channel.ts";
 export type {
   ChannelTemplateDecl,
@@ -150,6 +155,10 @@ export type {
   Transport,
   MediumCosts,
   EmailAuthResult,
+  EmailEvent,
+  DeliveryEvent,
+  AnySendResult,
+  SentlyChannelSendResult,
 } from "./channel.ts";
 
 export {