@develit-services/notification 0.5.0 → 0.6.0

package/dist/export/worker.cjs

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const backendSdk = require('@develit-io/backend-sdk');
-const database_schema = require('../shared/notification.4b3eUEIG.cjs');
+const database_schema = require('../database/schema.cjs');
 require('drizzle-orm');
 require('drizzle-orm/sqlite-core');
-const slack_connector = require('../shared/notification.Dk_5TX9v.cjs');
+const webhook_connector = require('../shared/notification.BLPB8Ib2.cjs');
+require('@develit-io/backend-sdk/signature');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
 require('zod');
@@ -16,12 +17,13 @@ require('twilio');
 const tables = database_schema.schema;
 
 const initiateEmailConnector = async (provider, apiKey, smtpHost, senderEmail, senderName) => {
-  const connector = [slack_connector.EcomailConnector].find(
+  const connector = [webhook_connector.EcomailConnector].find(
     (conn) => conn.providerName === provider
   );
   if (!connector)
     throw backendSdk.createInternalError(null, {
       message: "Unsupported email provider",
+      code: "VALID-N-01",
       status: 404
     });
   return new connector({
@@ -32,39 +34,18 @@ const initiateEmailConnector = async (provider, apiKey, smtpHost, senderEmail, s
   });
 };
 
-const createAuditLogCommand = async ({
-  db,
-  auditLog: {
-    event,
-    description,
-    initiatorService,
-    initiatorUserId,
-    ip,
-    userAgent
-  }
-}) => {
-  const command = db.insert(tables.auditLog).values({
-    id: backendSdk.uuidv4(),
-    createdAt: /* @__PURE__ */ new Date(),
-    event,
-    description,
-    ip,
-    userAgent,
-    initiatorService,
-    initiatorUserId
-  });
-  return {
-    command
-  };
-};
+function generateEmailKVPattern(recipient) {
+  return `email:${recipient}:`;
+}
 
 const initiateSmsConnector = async (provider, accountId, authToken, serviceId) => {
-  const connector = [slack_connector.TwilioConnector].find(
+  const connector = [webhook_connector.TwilioConnector].find(
     (conn) => conn.providerName === provider
   );
   if (!connector)
     throw backendSdk.createInternalError(null, {
-      message: "Unsupported sms provider",
+      message: "Unsupported SMS provider",
+      code: "VALID-N-02",
       status: 404
     });
   return new connector({
@@ -89,7 +70,7 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
 ) {
   constructor(ctx, env) {
     super(ctx, env);
-    this.slackConnector = new slack_connector.SlackConnector(this.env.SLACK_WEBHOOK);
+    this.slackConnector = new webhook_connector.SlackConnector(this.env.SLACK_WEBHOOK);
     this.db = d1.drizzle(this.env.NOTIFICATION_D1, { schema: tables });
   }
   async queue(batch) {
@@ -119,6 +100,12 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
             metadata
           });
           break;
+        case "webhook":
+          notificationAction = async () => this._sendWebhook({
+            webhook: payload.webhook,
+            metadata
+          });
+          break;
         default:
           this.logError({ error: `Unknown notification type: ${type}` });
           message.retry();
@@ -135,7 +122,7 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
   }
   async _sendEmail(input) {
     return this.handleAction(
-      { data: input, schema: slack_connector.sendEmailInputSchema },
+      { data: input, schema: webhook_connector.sendEmailInputSchema },
       { successMessage: "Email sent." },
       async (params) => {
         const {
@@ -143,7 +130,7 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
           metadata: {
             ip,
             userAgent,
-            initiator: { service: service2, userId }
+            initiator: { userId }
           }
         } = params;
         if (!this.emailConnector) {
@@ -158,26 +145,31 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
           );
         }
         await this.emailConnector.sendEmail(email);
-        const { command } = await createAuditLogCommand({
-          db: this.db,
-          auditLog: {
-            id: backendSdk.uuidv4(),
-            event: "EMAIL",
-            ip,
-            initiatorService: service2,
-            initiatorUserId: userId,
-            userAgent,
-            description: JSON.stringify(input)
-          }
+        await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+          logType: "event",
+          service: "notification",
+          correlationId: backendSdk.uuidv4(),
+          eventType: "notification.email_sent",
+          actorUserId: userId,
+          actorEmail: userId || "SYSTEM",
+          targetType: "email",
+          targetId: email.to,
+          sourceIp: ip,
+          userAgent,
+          outcome: "success",
+          description: `Email sent to ${email.to}`,
+          details: JSON.stringify({
+            subject: email.subject,
+            templateId: email.templateId
+          })
         });
-        await this.db.batch([command]);
         return {};
       }
     );
   }
   async _sendSms(input) {
     return this.handleAction(
-      { data: input, schema: slack_connector.sendSmsInputSchema },
+      { data: input, schema: webhook_connector.sendSmsInputSchema },
       { successMessage: "Sms sent." },
       async (params) => {
         const {
@@ -185,7 +177,7 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
           metadata: {
             ip,
             userAgent,
-            initiator: { service: service2, userId }
+            initiator: { userId }
           }
         } = params;
         if (!this.smsConnector) {
@@ -203,26 +195,28 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
           );
         }
         await this.smsConnector.sendSms({ message, to });
-        const { command } = await createAuditLogCommand({
-          db: this.db,
-          auditLog: {
-            id: backendSdk.uuidv4(),
-            event: "SMS",
-            ip,
-            userAgent,
-            initiatorService: service2,
-            initiatorUserId: userId,
-            description: JSON.stringify(input)
-          }
+        await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+          logType: "event",
+          service: "notification",
+          correlationId: backendSdk.uuidv4(),
+          eventType: "notification.sms_sent",
+          actorUserId: userId,
+          actorEmail: userId || "SYSTEM",
+          targetType: "sms",
+          targetId: to,
+          sourceIp: ip,
+          userAgent,
+          outcome: "success",
+          description: `SMS sent to ${to}`,
+          details: JSON.stringify({ message })
         });
-        await this.db.batch([command]);
         return {};
       }
     );
   }
   async sendEmail(input) {
     return this.handleAction(
-      { data: input, schema: slack_connector.sendEmailInputSchema },
+      { data: input, schema: webhook_connector.sendEmailInputSchema },
       { successMessage: "Email sent." },
       async (params) => {
         const { email, metadata } = params;
@@ -242,7 +236,7 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
   }
   async sendEmailSync(input) {
     return this.handleAction(
-      { data: input, schema: slack_connector.sendEmailInputSchema },
+      { data: input, schema: webhook_connector.sendEmailInputSchema },
       { successMessage: "Email sent." },
       async (params) => {
         const { email, metadata } = params;
@@ -255,7 +249,7 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
   }
   async sendSms(input) {
     return this.handleAction(
-      { data: input, schema: slack_connector.sendSmsInputSchema },
+      { data: input, schema: webhook_connector.sendSmsInputSchema },
       { successMessage: "SMS sent." },
       async (params) => {
         const {
@@ -280,15 +274,19 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
     );
   }
   async _sendPushNotification() {
-    this.logInput({});
-    this.logError({ error: "Method not implemented." });
-    throw new Error("Method not implemented.");
+    return this.handleAction(null, { successMessage: "" }, async () => {
+      throw backendSdk.createInternalError(null, {
+        message: "Push notifications not implemented",
+        code: "SYS-N-01",
+        status: 501
+      });
+    });
   }
   async sendSlackNotification(input) {
     return this.handleAction(
       {
         data: input,
-        schema: slack_connector.sendSlackInputSchema
+        schema: webhook_connector.sendSlackInputSchema
       },
       { successMessage: "Slack sent." },
       async (params) => {
@@ -298,6 +296,194 @@ let NotificationServiceBase = class extends backendSdk.develitWorker(
       }
     );
   }
+  async sendWebhook(input) {
+    return this.handleAction(
+      { data: input, schema: webhook_connector.sendWebhookInputSchema },
+      { successMessage: "Webhook queued." },
+      async (params) => {
+        const { webhook, metadata } = params;
+        await this.pushToQueue(
+          this.env.NOTIFICATIONS_QUEUE,
+          {
+            type: "webhook",
+            payload: {
+              webhook
+            },
+            metadata
+          }
+        );
+        return {};
+      }
+    );
+  }
+  async _sendWebhook(input) {
+    return this.handleAction(
+      { data: input, schema: webhook_connector.sendWebhookInputSchema },
+      { successMessage: "Webhook sent." },
+      async (params) => {
+        const {
+          webhook,
+          metadata: {
+            ip,
+            userAgent,
+            initiator: { userId }
+          }
+        } = params;
+        if (!this.webhookConnector) {
+          const privateKey = (await this.env.SECRETS_STORE.get({
+            secretName: "NOTIFICATION_SERVICE_WEBHOOK_SIGNING_KEY"
+          })).data?.secretValue;
+          if (!privateKey) {
+            throw backendSdk.createInternalError(null, {
+              message: "NOTIFICATION_SERVICE_WEBHOOK_SIGNING_KEY is not configured",
+              code: "SYS-N-02",
+              status: 500
+            });
+          }
+          this.webhookConnector = new webhook_connector.WebhookConnector(privateKey);
+        }
+        await this.webhookConnector.sendWebhook(webhook);
+        await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+          logType: "event",
+          service: "notification",
+          correlationId: backendSdk.uuidv4(),
+          eventType: "notification.webhook_sent",
+          actorUserId: userId,
+          actorEmail: userId || "SYSTEM",
+          targetType: "webhook",
+          targetId: webhook.url,
+          sourceIp: ip,
+          userAgent,
+          outcome: "success",
+          description: `Webhook sent to ${webhook.url}`,
+          details: JSON.stringify({
+            url: webhook.url
+          })
+        });
+        return {};
+      }
+    );
+  }
+  async getReceivedEmails(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: webhook_connector.getReceivedEmailsInputSchema
+      },
+      { successMessage: "Emails retrieved." },
+      async (params) => {
+        const { recipient, limit, includeContent } = params;
+        if (!this.env.RECEIVED_EMAILS_KV) {
+          throw new Error("RECEIVED_EMAILS_KV binding is not configured");
+        }
+        const pattern = generateEmailKVPattern(recipient);
+        const list = await this.env.RECEIVED_EMAILS_KV.list({
+          prefix: pattern,
+          limit
+        });
+        const emails = [];
+        for (const key of list.keys) {
+          const emailData = await this.env.RECEIVED_EMAILS_KV.get(
+            key.name,
+            "json"
+          );
+          if (emailData) {
+            const email = emailData;
+            if (!includeContent) {
+              delete email.text;
+              delete email.html;
+              delete email.raw;
+            }
+            emails.push(email);
+          }
+        }
+        emails.sort(
+          (a, b) => new Date(b.receivedAt).getTime() - new Date(a.receivedAt).getTime()
+        );
+        return {
+          emails,
+          count: emails.length
+        };
+      }
+    );
+  }
+  async waitForEmail(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: webhook_connector.waitForEmailInputSchema
+      },
+      { successMessage: "Email check completed." },
+      async (params) => {
+        const { recipient, subject, timeout, pollInterval } = params;
+        if (!this.env.RECEIVED_EMAILS_KV) {
+          throw new Error("RECEIVED_EMAILS_KV binding is not configured");
+        }
+        const maxTimeout = Math.min(timeout || 5e3, 5e3);
+        const safeInterval = Math.max(pollInterval || 500, 100);
+        const startTime = Date.now();
+        const maxIterations = Math.ceil(maxTimeout / safeInterval);
+        let iterations = 0;
+        while (Date.now() - startTime < maxTimeout && iterations < maxIterations) {
+          const pattern = generateEmailKVPattern(recipient);
+          const list = await this.env.RECEIVED_EMAILS_KV.list({
+            prefix: pattern,
+            limit: 50
+          });
+          for (const key of list.keys) {
+            const emailData = await this.env.RECEIVED_EMAILS_KV.get(
+              key.name,
+              "json"
+            );
+            if (emailData) {
+              const email = emailData;
+              if (!subject || email.subject.includes(subject)) {
+                return {
+                  email,
+                  found: true
+                };
+              }
+            }
+          }
+          iterations++;
+          if (iterations < maxIterations && Date.now() - startTime < maxTimeout - safeInterval) {
+            await new Promise((resolve) => setTimeout(resolve, safeInterval));
+          }
+        }
+        return {
+          email: null,
+          found: false
+        };
+      }
+    );
+  }
+  async clearReceivedEmails(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: webhook_connector.clearReceivedEmailsInputSchema
+      },
+      { successMessage: "Emails cleared." },
+      async (params) => {
+        const { recipient } = params;
+        if (!this.env.RECEIVED_EMAILS_KV) {
+          throw new Error("RECEIVED_EMAILS_KV binding is not configured");
+        }
+        const pattern = generateEmailKVPattern(recipient);
+        const list = await this.env.RECEIVED_EMAILS_KV.list({
+          prefix: pattern
+        });
+        let deleted = 0;
+        for (const key of list.keys) {
+          await this.env.RECEIVED_EMAILS_KV.delete(key.name);
+          deleted++;
+        }
+        return {
+          deleted
+        };
+      }
+    );
+  }
 };
 __decorateClass([
   backendSdk.cloudflareQueue({ baseDelay: 60 })
@@ -309,13 +495,13 @@ __decorateClass([
   backendSdk.action("private-send-sms")
 ], NotificationServiceBase.prototype, "_sendSms", 1);
 __decorateClass([
-  backendSdk.action("public-send-email")
+  backendSdk.action("send-email")
 ], NotificationServiceBase.prototype, "sendEmail", 1);
 __decorateClass([
-  backendSdk.action("public-send-email-sync")
+  backendSdk.action("send-email-sync")
 ], NotificationServiceBase.prototype, "sendEmailSync", 1);
 __decorateClass([
-  backendSdk.action("public-send-sms")
+  backendSdk.action("send-sms")
 ], NotificationServiceBase.prototype, "sendSms", 1);
 __decorateClass([
   backendSdk.action("send-push-notification")
@@ -323,6 +509,21 @@ __decorateClass([
 __decorateClass([
   backendSdk.action("send-slack-notification")
 ], NotificationServiceBase.prototype, "sendSlackNotification", 1);
+__decorateClass([
+  backendSdk.action("send-webhook")
+], NotificationServiceBase.prototype, "sendWebhook", 1);
+__decorateClass([
+  backendSdk.action("private-send-webhook")
+], NotificationServiceBase.prototype, "_sendWebhook", 1);
+__decorateClass([
+  backendSdk.action("get-received-emails")
+], NotificationServiceBase.prototype, "getReceivedEmails", 1);
+__decorateClass([
+  backendSdk.action("wait-for-email")
+], NotificationServiceBase.prototype, "waitForEmail", 1);
+__decorateClass([
+  backendSdk.action("clear-received-emails")
+], NotificationServiceBase.prototype, "clearReceivedEmails", 1);
 NotificationServiceBase = __decorateClass([
   backendSdk.service("notification")
 ], NotificationServiceBase);

package/dist/export/worker.d.cts

@@ -1,16 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { S as SlackConnector, I as IEmailConnector, a as ISmsConnector, t as tables, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput } from '../shared/notification.2rSOcFrr.cjs';
+import { s as schema } from '../database/schema.cjs';
+import { S as SlackConnector, W as WebhookConnector, I as IEmailConnector, a as ISmsConnector, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput, h as SendWebhookInput, i as SendWebhookOutput, G as GetReceivedEmailsInput, j as GetReceivedEmailsOutput, k as WaitForEmailInput, l as WaitForEmailOutput, C as ClearReceivedEmailsInput, m as ClearReceivedEmailsOutput } from '../shared/notification.BiG4Q650.cjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import '../shared/notification.BWLPh6Gb.cjs';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
 import 'zod/v4';
 
+declare const tables: typeof schema;
+
 declare const NotificationServiceBase_base: (abstract new (ctx: ExecutionContext, env: NotificationEnv) => WorkerEntrypoint<NotificationEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class NotificationServiceBase extends NotificationServiceBase_base {
     readonly slackConnector: SlackConnector;
+    protected webhookConnector: WebhookConnector;
     protected emailConnector: IEmailConnector;
     protected smsConnector: ISmsConnector;
     readonly db: DrizzleD1Database<typeof tables>;
@@ -23,6 +25,23 @@ declare class NotificationServiceBase extends NotificationServiceBase_base {
     sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>>;
     protected _sendPushNotification(): Promise<IRPCResponse<{}>>;
     sendSlackNotification(input: SendSlackInput): Promise<IRPCResponse<SendSlackOutput>>;
+    sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    protected _sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    /**
+     * Get received emails from KV storage
+     * Used primarily for E2E testing
+     */
+    getReceivedEmails(input: GetReceivedEmailsInput): Promise<IRPCResponse<GetReceivedEmailsOutput>>;
+    /**
+     * Wait for an email to arrive (polling helper for E2E tests)
+     * NOTE: Limited to 5 second timeout to prevent blocking
+     */
+    waitForEmail(input: WaitForEmailInput): Promise<IRPCResponse<WaitForEmailOutput>>;
+    /**
+     * Clear received emails for a recipient (cleanup helper)
+     * Used primarily for E2E testing
+     */
+    clearReceivedEmails(input: ClearReceivedEmailsInput): Promise<IRPCResponse<ClearReceivedEmailsOutput>>;
 }
 declare function defineNotificationService(): new (ctx: ExecutionContext, env: NotificationEnv) => NotificationServiceBase;
 

package/dist/export/worker.d.mts

@@ -1,16 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { S as SlackConnector, I as IEmailConnector, a as ISmsConnector, t as tables, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput } from '../shared/notification.C1quYqlT.mjs';
+import { s as schema } from '../database/schema.mjs';
+import { S as SlackConnector, W as WebhookConnector, I as IEmailConnector, a as ISmsConnector, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput, h as SendWebhookInput, i as SendWebhookOutput, G as GetReceivedEmailsInput, j as GetReceivedEmailsOutput, k as WaitForEmailInput, l as WaitForEmailOutput, C as ClearReceivedEmailsInput, m as ClearReceivedEmailsOutput } from '../shared/notification.BiG4Q650.mjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import '../shared/notification.BWLPh6Gb.mjs';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
 import 'zod/v4';
 
+declare const tables: typeof schema;
+
 declare const NotificationServiceBase_base: (abstract new (ctx: ExecutionContext, env: NotificationEnv) => WorkerEntrypoint<NotificationEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class NotificationServiceBase extends NotificationServiceBase_base {
     readonly slackConnector: SlackConnector;
+    protected webhookConnector: WebhookConnector;
     protected emailConnector: IEmailConnector;
     protected smsConnector: ISmsConnector;
     readonly db: DrizzleD1Database<typeof tables>;
@@ -23,6 +25,23 @@ declare class NotificationServiceBase extends NotificationServiceBase_base {
     sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>>;
     protected _sendPushNotification(): Promise<IRPCResponse<{}>>;
     sendSlackNotification(input: SendSlackInput): Promise<IRPCResponse<SendSlackOutput>>;
+    sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    protected _sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    /**
+     * Get received emails from KV storage
+     * Used primarily for E2E testing
+     */
+    getReceivedEmails(input: GetReceivedEmailsInput): Promise<IRPCResponse<GetReceivedEmailsOutput>>;
+    /**
+     * Wait for an email to arrive (polling helper for E2E tests)
+     * NOTE: Limited to 5 second timeout to prevent blocking
+     */
+    waitForEmail(input: WaitForEmailInput): Promise<IRPCResponse<WaitForEmailOutput>>;
+    /**
+     * Clear received emails for a recipient (cleanup helper)
+     * Used primarily for E2E testing
+     */
+    clearReceivedEmails(input: ClearReceivedEmailsInput): Promise<IRPCResponse<ClearReceivedEmailsOutput>>;
 }
 declare function defineNotificationService(): new (ctx: ExecutionContext, env: NotificationEnv) => NotificationServiceBase;
 

package/dist/export/worker.d.ts

@@ -1,16 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { S as SlackConnector, I as IEmailConnector, a as ISmsConnector, t as tables, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput } from '../shared/notification.oEdhCsu_.js';
+import { s as schema } from '../database/schema.js';
+import { S as SlackConnector, W as WebhookConnector, I as IEmailConnector, a as ISmsConnector, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput, h as SendWebhookInput, i as SendWebhookOutput, G as GetReceivedEmailsInput, j as GetReceivedEmailsOutput, k as WaitForEmailInput, l as WaitForEmailOutput, C as ClearReceivedEmailsInput, m as ClearReceivedEmailsOutput } from '../shared/notification.BiG4Q650.js';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import '../shared/notification.BWLPh6Gb.js';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
 import 'zod/v4';
 
+declare const tables: typeof schema;
+
 declare const NotificationServiceBase_base: (abstract new (ctx: ExecutionContext, env: NotificationEnv) => WorkerEntrypoint<NotificationEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class NotificationServiceBase extends NotificationServiceBase_base {
     readonly slackConnector: SlackConnector;
+    protected webhookConnector: WebhookConnector;
     protected emailConnector: IEmailConnector;
     protected smsConnector: ISmsConnector;
     readonly db: DrizzleD1Database<typeof tables>;
@@ -23,6 +25,23 @@ declare class NotificationServiceBase extends NotificationServiceBase_base {
     sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>>;
     protected _sendPushNotification(): Promise<IRPCResponse<{}>>;
     sendSlackNotification(input: SendSlackInput): Promise<IRPCResponse<SendSlackOutput>>;
+    sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    protected _sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    /**
+     * Get received emails from KV storage
+     * Used primarily for E2E testing
+     */
+    getReceivedEmails(input: GetReceivedEmailsInput): Promise<IRPCResponse<GetReceivedEmailsOutput>>;
+    /**
+     * Wait for an email to arrive (polling helper for E2E tests)
+     * NOTE: Limited to 5 second timeout to prevent blocking
+     */
+    waitForEmail(input: WaitForEmailInput): Promise<IRPCResponse<WaitForEmailOutput>>;
+    /**
+     * Clear received emails for a recipient (cleanup helper)
+     * Used primarily for E2E testing
+     */
+    clearReceivedEmails(input: ClearReceivedEmailsInput): Promise<IRPCResponse<ClearReceivedEmailsOutput>>;
 }
 declare function defineNotificationService(): new (ctx: ExecutionContext, env: NotificationEnv) => NotificationServiceBase;