stratal 0.0.13 → 0.0.14

package/dist/cron/index.mjs

@@ -0,0 +1,4 @@
+import "../errors-BRJgVd5-.mjs";
+import "../logger-Bg-CuidS.mjs";
+import { n as CronExecutionError, t as CronManager } from "../cron-manager-CpS_hrDD.mjs";
+export { CronExecutionError, CronManager };

package/dist/cron-manager-CpS_hrDD.mjs

@@ -0,0 +1,107 @@
+import { S as ApplicationError, b as ERROR_CODES } from "./errors-BRJgVd5-.mjs";
+import { a as __decorate, d as Transient } from "./logger-Bg-CuidS.mjs";
+//#region src/cron/errors/cron-execution.error.ts
+/**
+* Error thrown when one or more cron jobs fail execution
+*
+* This error aggregates failures from multiple jobs that share the same schedule.
+*/
+var CronExecutionError = class extends ApplicationError {
+	constructor(schedule, failedJobsCount, jobNames) {
+		super("errors.cronExecutionFailed", ERROR_CODES.SYSTEM.CRON_EXECUTION_FAILED, {
+			schedule,
+			count: failedJobsCount,
+			jobs: jobNames
+		});
+	}
+};
+//#endregion
+//#region src/cron/cron-manager.ts
+let CronManager = class CronManager {
+	/**
+	* Map of cron expressions to jobs
+	* Key: Cron expression (e.g., '0 2 * * *')
+	* Value: Array of jobs matching that expression
+	*/
+	jobs = /* @__PURE__ */ new Map();
+	/**
+	* Register a cron job
+	*
+	* Jobs with the same schedule are grouped together and executed
+	* sequentially when the trigger fires.
+	*
+	* @param job - CronJob instance to register
+	*/
+	registerJob(job) {
+		const existing = this.jobs.get(job.schedule) ?? [];
+		existing.push(job);
+		this.jobs.set(job.schedule, existing);
+	}
+	/**
+	* Execute all jobs matching the triggered cron expression
+	*
+	* Jobs are executed sequentially. If a job fails:
+	* - Its onError() hook is called (if defined)
+	* - Execution continues with the next job
+	* - Errors are collected and logged
+	*
+	* @param controller - Cloudflare ScheduledController
+	*/
+	async executeScheduled(controller) {
+		const { cron } = controller;
+		const matchingJobs = this.jobs.get(cron) ?? [];
+		if (matchingJobs.length === 0) return;
+		const errors = [];
+		for (const job of matchingJobs) {
+			const jobName = job.constructor.name;
+			try {
+				await job.execute(controller);
+			} catch (error) {
+				const err = error;
+				errors.push({
+					job: jobName,
+					error: err
+				});
+				if (job.onError) try {
+					await job.onError(err, controller);
+				} catch {}
+			}
+		}
+		if (errors.length > 0) {
+			const jobNames = errors.map(({ job, error }) => `${job}: ${error.message}`).join("; ");
+			throw new CronExecutionError(cron, errors.length, jobNames);
+		}
+	}
+	/**
+	* Get all registered jobs for a specific cron expression
+	*
+	* @param schedule - Cron expression
+	* @returns Array of jobs for that schedule, or empty array if none
+	*/
+	getJobsForSchedule(schedule) {
+		return this.jobs.get(schedule) ?? [];
+	}
+	/**
+	* Get all registered cron expressions
+	*
+	* @returns Array of unique cron expressions
+	*/
+	getAllSchedules() {
+		return Array.from(this.jobs.keys());
+	}
+	/**
+	* Get total number of registered jobs across all schedules
+	*
+	* @returns Total job count
+	*/
+	getTotalJobCount() {
+		let count = 0;
+		for (const jobs of this.jobs.values()) count += jobs.length;
+		return count;
+	}
+};
+CronManager = __decorate([Transient()], CronManager);
+//#endregion
+export { CronExecutionError as n, CronManager as t };
+
+//# sourceMappingURL=cron-manager-CpS_hrDD.mjs.map

package/dist/cron-manager-CpS_hrDD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-manager-CpS_hrDD.mjs","names":[],"sources":["../src/cron/errors/cron-execution.error.ts","../src/cron/cron-manager.ts"],"sourcesContent":["import { ApplicationError } from '../../errors'\nimport { ERROR_CODES } from '../../errors'\n\n/**\n * Error thrown when one or more cron jobs fail execution\n *\n * This error aggregates failures from multiple jobs that share the same schedule.\n */\nexport class CronExecutionError extends ApplicationError {\n\tconstructor(\n\t\tschedule: string,\n\t\tfailedJobsCount: number,\n\t\tjobNames: string\n\t) {\n\t\tsuper(\n\t\t\t'errors.cronExecutionFailed',\n\t\t\tERROR_CODES.SYSTEM.CRON_EXECUTION_FAILED,\n\t\t\t{\n\t\t\t\tschedule,\n\t\t\t\tcount: failedJobsCount,\n\t\t\t\tjobs: jobNames\n\t\t\t}\n\t\t)\n\t}\n}\n","import { Transient } from '../di/decorators'\nimport type { CronJob } from './cron-job'\nimport { CronExecutionError } from './errors/cron-execution.error'\n\n/**\n * Manages cron job registration and execution\n *\n * CronManager is a singleton service that:\n * - Registers cron jobs from modules\n * - Routes scheduled events to matching jobs\n * - Handles errors during job execution\n *\n * Jobs are grouped by their cron expression, allowing multiple jobs\n * to run on the same schedule.\n */\n@Transient()\nexport class CronManager {\n\t/**\n\t * Map of cron expressions to jobs\n\t * Key: Cron expression (e.g., '0 2 * * *')\n\t * Value: Array of jobs matching that expression\n\t */\n\tprivate jobs = new Map<string, CronJob[]>()\n\n\t/**\n\t * Register a cron job\n\t *\n\t * Jobs with the same schedule are grouped together and executed\n\t * sequentially when the trigger fires.\n\t *\n\t * @param job - CronJob instance to register\n\t */\n\tregisterJob(job: CronJob): void {\n\t\tconst existing = this.jobs.get(job.schedule) ?? []\n\t\texisting.push(job)\n\t\tthis.jobs.set(job.schedule, existing)\n\t}\n\n\t/**\n\t * Execute all jobs matching the triggered cron expression\n\t *\n\t * Jobs are executed sequentially. If a job fails:\n\t * - Its onError() hook is called (if defined)\n\t * - Execution continues with the next job\n\t * - Errors are collected and logged\n\t *\n\t * @param controller - Cloudflare ScheduledController\n\t */\n\tasync executeScheduled(controller: ScheduledController): Promise<void> {\n\t\tconst { cron } = controller\n\t\tconst matchingJobs = this.jobs.get(cron) ?? []\n\n\t\tif (matchingJobs.length === 0) {\n\t\t\treturn\n\t\t}\n\n\t\tconst errors: { job: string; error: Error }[] = []\n\n\t\tfor (const job of matchingJobs) {\n\t\t\tconst jobName = job.constructor.name\n\n\t\t\ttry {\n\t\t\t\tawait job.execute(controller)\n\t\t\t} catch (error) {\n\t\t\t\tconst err = error as Error\n\t\t\t\terrors.push({ job: jobName, error: err })\n\n\t\t\t\t// Call job's error handler if defined\n\t\t\t\tif (job.onError) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait job.onError(err, controller)\n\t\t\t\t\t} catch {\n\t\t\t\t\t\t// If onError() itself fails, we just continue\n\t\t\t\t\t\t// The error will be logged by GlobalErrorHandler\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// If any jobs failed, throw an aggregate error\n\t\t// This ensures the error is logged by GlobalErrorHandler\n\t\tif (errors.length > 0) {\n\t\t\tconst jobNames = errors\n\t\t\t\t.map(({ job, error }) => `${job}: ${error.message}`)\n\t\t\t\t.join('; ')\n\n\t\t\tthrow new CronExecutionError(cron, errors.length, jobNames)\n\t\t}\n\t}\n\n\t/**\n\t * Get all registered jobs for a specific cron expression\n\t *\n\t * @param schedule - Cron expression\n\t * @returns Array of jobs for that schedule, or empty array if none\n\t */\n\tgetJobsForSchedule(schedule: string): CronJob[] {\n\t\treturn this.jobs.get(schedule) ?? []\n\t}\n\n\t/**\n\t * Get all registered cron expressions\n\t *\n\t * @returns Array of unique cron expressions\n\t */\n\tgetAllSchedules(): string[] {\n\t\treturn Array.from(this.jobs.keys())\n\t}\n\n\t/**\n\t * Get total number of registered jobs across all schedules\n\t *\n\t * @returns Total job count\n\t */\n\tgetTotalJobCount(): number {\n\t\tlet count = 0\n\t\tfor (const jobs of this.jobs.values()) {\n\t\t\tcount += jobs.length\n\t\t}\n\t\treturn count\n\t}\n}\n"],"mappings":";;;;;;;;AAQA,IAAa,qBAAb,cAAwC,iBAAiB;CACxD,YACC,UACA,iBACA,UACC;AACD,QACC,8BACA,YAAY,OAAO,uBACnB;GACC;GACA,OAAO;GACP,MAAM;GACN,CACD;;;;;ACNI,IAAA,cAAA,MAAM,YAAY;;;;;;CAMxB,uBAAe,IAAI,KAAwB;;;;;;;;;CAU3C,YAAY,KAAoB;EAC/B,MAAM,WAAW,KAAK,KAAK,IAAI,IAAI,SAAS,IAAI,EAAE;AAClD,WAAS,KAAK,IAAI;AAClB,OAAK,KAAK,IAAI,IAAI,UAAU,SAAS;;;;;;;;;;;;CAatC,MAAM,iBAAiB,YAAgD;EACtE,MAAM,EAAE,SAAS;EACjB,MAAM,eAAe,KAAK,KAAK,IAAI,KAAK,IAAI,EAAE;AAE9C,MAAI,aAAa,WAAW,EAC3B;EAGD,MAAM,SAA0C,EAAE;AAElD,OAAK,MAAM,OAAO,cAAc;GAC/B,MAAM,UAAU,IAAI,YAAY;AAEhC,OAAI;AACH,UAAM,IAAI,QAAQ,WAAW;YACrB,OAAO;IACf,MAAM,MAAM;AACZ,WAAO,KAAK;KAAE,KAAK;KAAS,OAAO;KAAK,CAAC;AAGzC,QAAI,IAAI,QACP,KAAI;AACH,WAAM,IAAI,QAAQ,KAAK,WAAW;YAC3B;;;AAUX,MAAI,OAAO,SAAS,GAAG;GACtB,MAAM,WAAW,OACf,KAAK,EAAE,KAAK,YAAY,GAAG,IAAI,IAAI,MAAM,UAAU,CACnD,KAAK,KAAK;AAEZ,SAAM,IAAI,mBAAmB,MAAM,OAAO,QAAQ,SAAS;;;;;;;;;CAU7D,mBAAmB,UAA6B;AAC/C,SAAO,KAAK,KAAK,IAAI,SAAS,IAAI,EAAE;;;;;;;CAQrC,kBAA4B;AAC3B,SAAO,MAAM,KAAK,KAAK,KAAK,MAAM,CAAC;;;;;;;CAQpC,mBAA2B;EAC1B,IAAI,QAAQ;AACZ,OAAK,MAAM,QAAQ,KAAK,KAAK,QAAQ,CACpC,UAAS,KAAK;AAEf,SAAO;;;0BAxGR,WAAW,CAAA,EAAA,YAAA"}

package/dist/di/index.d.mts

@@ -0,0 +1,2 @@
+import { $t as Container, Gt as Transient, Jt as ParamInjection, Kt as INJECT_PARAM_METADATA_KEY, Qt as DI_TOKENS, Ut as RequestScopeOperationNotAllowedError, Wt as ConditionalBindingFallbackError, Xt as CONTAINER_TOKEN, Yt as getMethodInjections, Zt as DIToken, an as injectable, cn as ConditionalBindingBuilder, dn as ConditionalBindingUse, en as ContainerOptions, fn as PredicateContainer, gn as WhenOptions, hn as Scope, in as inject, ln as ConditionalBindingBuilderImpl, mn as ExtensionDecorator, nn as container, on as instancePerContainerCachingFactory, pn as ContainerLike, qt as InjectParam, rn as delay, sn as singleton, tn as DependencyContainer, un as ConditionalBindingGive } from "../index-C9bIk5tt.mjs";
+export { CONTAINER_TOKEN, ConditionalBindingBuilder, ConditionalBindingBuilderImpl, ConditionalBindingFallbackError, ConditionalBindingGive, ConditionalBindingUse, Container, ContainerLike, ContainerOptions, DIToken, DI_TOKENS, DependencyContainer, ExtensionDecorator, INJECT_PARAM_METADATA_KEY, InjectParam, ParamInjection, PredicateContainer, RequestScopeOperationNotAllowedError, Scope, Transient, WhenOptions, container, delay, getMethodInjections, inject, injectable, instancePerContainerCachingFactory, singleton };

package/dist/di/index.mjs

@@ -0,0 +1,3 @@
+import { _ as ConditionalBindingFallbackError, c as Container, d as inject, f as injectable, g as RequestScopeOperationNotAllowedError, h as ConditionalBindingBuilderImpl, l as container, m as singleton, p as instancePerContainerCachingFactory, s as Scope, u as delay } from "../errors-BRJgVd5-.mjs";
+import { d as Transient, f as INJECT_PARAM_METADATA_KEY, g as DI_TOKENS, h as CONTAINER_TOKEN, m as getMethodInjections, p as InjectParam } from "../logger-Bg-CuidS.mjs";
+export { CONTAINER_TOKEN, ConditionalBindingBuilderImpl, ConditionalBindingFallbackError, Container, DI_TOKENS, INJECT_PARAM_METADATA_KEY, InjectParam, RequestScopeOperationNotAllowedError, Scope, Transient, container, delay, getMethodInjections, inject, injectable, instancePerContainerCachingFactory, singleton };

package/dist/email/index.d.mts

@@ -0,0 +1,532 @@
+import { it as DynamicModule, nt as AsyncModuleOptions, s as ApplicationError } from "../index-C9bIk5tt.mjs";
+import { o as z } from "../index-Dl4RvzNp.mjs";
+import { g as QueueName, h as IQueueSender } from "../index-zKURVFOC.mjs";
+import { ReactElement } from "react";
+
+//#region src/email/email.module.d.ts
+/**
+ * SMTP configuration options
+ */
+interface SmtpConfig {
+  /** SMTP server host */
+  host: string;
+  /** SMTP server port */
+  port: number;
+  /** Use TLS */
+  secure?: boolean;
+  /** SMTP username */
+  username?: string;
+  /** SMTP password */
+  password?: string;
+}
+/**
+ * Email module configuration options
+ */
+interface EmailModuleOptions {
+  /** Email provider type */
+  provider: 'resend' | 'smtp';
+  /** Default from address */
+  from: {
+    name: string;
+    email: string;
+  };
+  /** Resend API key (required for resend provider) */
+  apiKey?: string;
+  /** SMTP configuration (required for smtp provider) */
+  smtp?: SmtpConfig;
+  /** Default reply-to address */
+  replyTo?: string;
+  /**
+   * Queue name for email dispatch.
+   * The queue must be registered via QueueModule.registerQueue(name).
+   */
+  queue: QueueName;
+}
+declare class EmailModule {
+  /**
+   * Configure EmailModule with static options
+   *
+   * @param options - Email configuration options
+   * @returns Dynamic module with email infrastructure
+   *
+   * @example
+   * ```typescript
+   * EmailModule.forRoot({
+   *   provider: 'resend',
+   *   apiKey: env.RESEND_API_KEY,
+   *   from: { name: 'App', email: 'noreply@example.com' },
+   *   queue: 'notifications-queue',
+   * })
+   * ```
+   */
+  static forRoot(options: EmailModuleOptions): DynamicModule;
+  /**
+   * Configure EmailModule with async factory
+   *
+   * Use when configuration depends on other services.
+   *
+   * @param options - Async configuration with factory and inject tokens
+   * @returns Dynamic module with email infrastructure
+   *
+   * @example
+   * ```typescript
+   * EmailModule.forRootAsync({
+   *   inject: [emailConfig.KEY],
+   *   useFactory: (email) => ({
+   *     provider: email.provider,
+   *     apiKey: email.apiKey,
+   *     from: email.from,
+   *     smtp: email.smtp,
+   *     queue: email.queue,
+   *   })
+   * })
+   * ```
+   */
+  static forRootAsync(options: AsyncModuleOptions<EmailModuleOptions>): DynamicModule;
+}
+//#endregion
+//#region src/email/email.tokens.d.ts
+/**
+ * Dependency Injection Tokens for Email Module
+ *
+ * These Symbol-based tokens ensure type-safe dependency injection
+ * throughout the email module and prevent naming collisions.
+ */
+/**
+ * Email Module DI Tokens
+ */
+declare const EMAIL_TOKENS: {
+  /**
+   * Email module configuration options
+   */
+  readonly Options: symbol;
+  /**
+   * Main email service - facade for sending emails via queues
+   */
+  readonly EmailService: symbol;
+  /**
+   * Factory for creating email provider instances based on configuration
+   */
+  readonly EmailProviderFactory: symbol;
+  /**
+   * Email provider interface - abstracts provider implementation
+   */
+  readonly EmailProvider: symbol;
+  /**
+   * Queue sender for email dispatch.
+   * Bound via EmailModule.forRoot({ queue: 'queue-name' })
+   */
+  readonly EmailQueue: symbol;
+};
+//#endregion
+//#region src/email/contracts/email-attachment.d.ts
+/**
+ * Inline Email Attachment Schema
+ *
+ * Attachment with content embedded as base64 string.
+ * Use for small files that can fit in queue message.
+ */
+declare const inlineEmailAttachmentSchema: z.ZodObject<{
+  filename: z.ZodString;
+  content: z.ZodString;
+  contentType: z.ZodString;
+  size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Storage Email Attachment Schema
+ *
+ * Attachment stored in cloud storage.
+ * Content type and size are derived from storage metadata.
+ * Use for large files to avoid queue message size limits.
+ */
+declare const storageEmailAttachmentSchema: z.ZodObject<{
+  filename: z.ZodString;
+  storageKey: z.ZodString;
+  disk: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Email Attachment Schema
+ *
+ * Union type - type is inferred from presence of `content` vs `storageKey`.
+ * - If `content` is present: inline attachment
+ * - If `storageKey` is present: storage-based attachment
+ */
+declare const emailAttachmentSchema: z.ZodUnion<readonly [z.ZodObject<{
+  filename: z.ZodString;
+  content: z.ZodString;
+  contentType: z.ZodString;
+  size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  filename: z.ZodString;
+  storageKey: z.ZodString;
+  disk: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+/**
+ * Type definitions
+ */
+type InlineEmailAttachment = z.infer<typeof inlineEmailAttachmentSchema>;
+type StorageEmailAttachment = z.infer<typeof storageEmailAttachmentSchema>;
+type EmailAttachment = z.infer<typeof emailAttachmentSchema>;
+/**
+ * Resolved Email Attachment
+ *
+ * Attachment after resolution, ready for email provider.
+ * Content can be Buffer (for inline) or ReadableStream (for storage-based).
+ * Both nodemailer and Resend support these formats directly.
+ */
+interface ResolvedEmailAttachment {
+  filename: string;
+  content: Buffer | ReadableStream;
+  contentType: string;
+}
+//#endregion
+//#region src/email/contracts/email-message.contract.d.ts
+/**
+ * Email Address Schema
+ *
+ * Represents an email address with optional name
+ */
+declare const emailAddressSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  email: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Base Email Message Schema
+ *
+ * Defines the core structure for email messages.
+ * Ensures either html or text content is provided.
+ */
+declare const emailMessageSchema: z.ZodObject<{
+  to: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+  from: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodString;
+  }, z.core.$strip>>;
+  subject: z.ZodString;
+  html: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  replyTo: z.ZodOptional<z.ZodString>;
+  cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    filename: z.ZodString;
+    content: z.ZodString;
+    contentType: z.ZodString;
+    size: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    filename: z.ZodString;
+    storageKey: z.ZodString;
+    disk: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+/**
+ * Type definition for email message
+ */
+type EmailMessage = z.infer<typeof emailMessageSchema>;
+/**
+ * Type definition for email address
+ */
+type EmailAddress = z.infer<typeof emailAddressSchema>;
+/**
+ * Resolved Email Message
+ *
+ * Email message with attachments resolved to Buffer content.
+ * Used by providers after the consumer resolves storage-based attachments.
+ */
+type ResolvedEmailMessage = Omit<EmailMessage, 'attachments'> & {
+  attachments?: ResolvedEmailAttachment[];
+};
+//#endregion
+//#region src/email/contracts/send-email.input.d.ts
+/**
+ * Send Email Input Schema
+ *
+ * Input schema for sending emails through the EmailService.
+ * Extends the base email message with optional metadata.
+ * Uses safeExtend() because emailMessageSchema contains refinements.
+ */
+declare const sendEmailInputSchema: z.ZodObject<{
+  to: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+  from: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodString;
+  }, z.core.$strip>>;
+  subject: z.ZodString;
+  html: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  replyTo: z.ZodOptional<z.ZodString>;
+  cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    filename: z.ZodString;
+    content: z.ZodString;
+    contentType: z.ZodString;
+    size: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    filename: z.ZodString;
+    storageKey: z.ZodString;
+    disk: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Type definition for send email input
+ */
+type SendEmailInput = z.infer<typeof sendEmailInputSchema>;
+/**
+ * Send Batch Email Input Schema
+ *
+ * Schema for sending multiple emails in a batch
+ */
+declare const sendBatchEmailInputSchema: z.ZodObject<{
+  messages: z.ZodArray<z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    from: z.ZodOptional<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      email: z.ZodString;
+    }, z.core.$strip>>;
+    subject: z.ZodString;
+    html: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      filename: z.ZodString;
+      content: z.ZodString;
+      contentType: z.ZodString;
+      size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+      filename: z.ZodString;
+      storageKey: z.ZodString;
+      disk: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Type definition for send batch email input
+ */
+type SendBatchEmailInput = z.infer<typeof sendBatchEmailInputSchema>;
+//#endregion
+//#region src/email/services/email.service.d.ts
+type SendEmailInputWithTemplate = Omit<SendEmailInput, 'html' | 'text'> & {
+  template?: ReactElement;
+};
+type SendBatchEmailInputWithTemplate = Omit<SendBatchEmailInput, 'messages'> & {
+  messages: SendEmailInputWithTemplate[];
+};
+/**
+ * Email Service
+ *
+ * Main facade for sending emails. Routes emails to queues for async processing.
+ * The queue is injected via EMAIL_TOKENS.EmailQueue, configured by the application
+ * via EmailModule.forRoot({ queue: 'queue-name' }).
+ *
+ * @example Basic usage
+ * ```typescript
+ * @inject(EMAIL_TOKENS.EmailService)
+ * private readonly emailService: EmailService
+ *
+ * await this.emailService.send({
+ *   to: 'user@example.com',
+ *   subject: 'Welcome',
+ *   template: <WelcomeEmail name="John" />
+ * })
+ * ```
+ */
+declare class EmailService {
+  protected readonly queue: IQueueSender;
+  constructor(queue: IQueueSender);
+  /**
+   * Send a single email
+   *
+   * Dispatches the email to the queue for async processing.
+   * Supports optional React template rendering.
+   *
+   * @param input - Email message details
+   */
+  send({
+    template,
+    ...input
+  }: SendEmailInputWithTemplate): Promise<void>;
+  /**
+   * Send multiple emails in a batch
+   *
+   * Dispatches all emails to the queue for async processing.
+   * Supports React template rendering for each message.
+   *
+   * @param input - Batch email details
+   */
+  sendBatch(input: SendBatchEmailInputWithTemplate): Promise<void>;
+}
+//#endregion
+//#region src/email/providers/email-provider.interface.d.ts
+/**
+ * Email Send Result
+ *
+ * Standard result returned by email providers after sending
+ */
+interface EmailSendResult {
+  /**
+   * Unique message ID from the provider
+   */
+  messageId: string;
+  /**
+   * Whether the email was accepted for delivery
+   */
+  accepted: boolean;
+  /**
+   * Optional provider-specific metadata
+   */
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Batch Email Send Result
+ *
+ * Result for batch email operations
+ */
+interface EmailBatchSendResult {
+  /**
+   * Total number of emails sent
+   */
+  total: number;
+  /**
+   * Number of successfully sent emails
+   */
+  successful: number;
+  /**
+   * Number of failed emails
+   */
+  failed: number;
+  /**
+   * Individual results for each email
+   */
+  results: EmailSendResult[];
+}
+/**
+ * Email Provider Interface
+ *
+ * All email provider implementations (Resend, SMTP, etc.) must implement this interface.
+ * This allows the EmailService to work with any provider without knowing the implementation details.
+ */
+interface IEmailProvider {
+  /**
+   * Send a single email
+   *
+   * @param message - The resolved email message to send (attachments as Buffer)
+   * @returns Promise that resolves with send result
+   */
+  send(message: ResolvedEmailMessage): Promise<EmailSendResult>;
+  /**
+   * Send multiple emails in a batch
+   *
+   * @param messages - Array of resolved email messages to send
+   * @returns Promise that resolves with batch send result
+   */
+  sendBatch(messages: ResolvedEmailMessage[]): Promise<EmailBatchSendResult>;
+}
+//#endregion
+//#region src/email/services/email-provider-factory.d.ts
+/**
+ * Email Provider Factory
+ *
+ * Creates email provider instances based on configuration.
+ * Supports automatic provider selection from module options.
+ *
+ * Providers are loaded lazily via dynamic imports to avoid pulling in
+ * heavy Node.js-only dependencies (e.g. nodemailer) at module parse time,
+ * which would break Cloudflare Workers and vitest-pool-workers environments.
+ */
+declare class EmailProviderFactory {
+  private readonly options;
+  constructor(options: EmailModuleOptions);
+  /**
+   * Create email provider instance based on configuration
+   *
+   * @returns Email provider implementation
+   * @throws EmailProviderNotSupportedError if provider is not supported
+   */
+  create(): Promise<IEmailProvider>;
+}
+//#endregion
+//#region src/email/errors/resend-api-key-missing.error.d.ts
+/**
+ * ResendApiKeyMissingError
+ *
+ * Thrown when the Resend API key is not configured in environment variables.
+ * This prevents the Resend email provider from initializing.
+ *
+ * Resolution: Set the RESEND_EMAIL_API_KEY environment variable.
+ */
+declare class ResendApiKeyMissingError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/email/errors/smtp-configuration-missing.error.d.ts
+/**
+ * SmtpConfigurationMissingError
+ *
+ * Thrown when SMTP configuration is not found in environment variables.
+ * This prevents the SMTP email provider from initializing.
+ *
+ * Resolution: Set the SMTP_URL environment variable with format: smtp://user:pass@host:port
+ */
+declare class SmtpConfigurationMissingError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/email/errors/smtp-host-missing.error.d.ts
+/**
+ * SmtpHostMissingError
+ *
+ * Thrown when SMTP host could not be parsed from SMTP_URL or is empty.
+ * This prevents the SMTP email provider from initializing.
+ *
+ * Resolution: Ensure SMTP_URL is correctly formatted: smtp://user:pass@host:port
+ */
+declare class SmtpHostMissingError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/email/errors/email-smtp-connection-failed.error.d.ts
+/**
+ * EmailSmtpConnectionFailedError
+ *
+ * Thrown when connection to SMTP server fails during email sending.
+ * This is a runtime error that may be temporary.
+ *
+ * Resolution: Check SMTP server availability, network connectivity, or wait and retry.
+ */
+declare class EmailSmtpConnectionFailedError extends ApplicationError {
+  constructor(smtpHost: string, smtpPort: number);
+}
+//#endregion
+//#region src/email/errors/email-resend-api-failed.error.d.ts
+/**
+ * EmailResendApiFailedError
+ *
+ * Thrown when Resend API returns an error during email sending.
+ * This is a runtime error from the Resend service.
+ *
+ * Resolution: Check Resend API status, API key validity, or wait and retry.
+ */
+declare class EmailResendApiFailedError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/email/errors/email-provider-not-supported.error.d.ts
+/**
+ * EmailProviderNotSupportedError
+ *
+ * Thrown when an unsupported email provider is configured.
+ * Only 'resend' and 'smtp' providers are currently supported.
+ *
+ * Resolution: Set EMAIL_PROVIDER to either 'resend' or 'smtp'.
+ */
+declare class EmailProviderNotSupportedError extends ApplicationError {
+  constructor(provider: string);
+}
+//#endregion
+export { EMAIL_TOKENS, EmailAddress, EmailAttachment, EmailMessage, EmailModule, EmailModuleOptions, EmailProviderFactory, EmailProviderNotSupportedError, EmailResendApiFailedError, EmailService, EmailSmtpConnectionFailedError, InlineEmailAttachment, ResendApiKeyMissingError, ResolvedEmailAttachment, ResolvedEmailMessage, SendBatchEmailInput, SendBatchEmailInputWithTemplate, SendEmailInput, SendEmailInputWithTemplate, SmtpConfig, SmtpConfigurationMissingError, SmtpHostMissingError, StorageEmailAttachment, emailAddressSchema, emailAttachmentSchema, emailMessageSchema, inlineEmailAttachmentSchema, sendBatchEmailInputSchema, sendEmailInputSchema, storageEmailAttachmentSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/email/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/email/email.module.ts","../../src/email/email.tokens.ts","../../src/email/contracts/email-attachment.ts","../../src/email/contracts/email-message.contract.ts","../../src/email/contracts/send-email.input.ts","../../src/email/services/email.service.ts","../../src/email/providers/email-provider.interface.ts","../../src/email/services/email-provider-factory.ts","../../src/email/errors/resend-api-key-missing.error.ts","../../src/email/errors/smtp-configuration-missing.error.ts","../../src/email/errors/smtp-host-missing.error.ts","../../src/email/errors/email-smtp-connection-failed.error.ts","../../src/email/errors/email-resend-api-failed.error.ts","../../src/email/errors/email-provider-not-supported.error.ts"],"mappings":"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"}