@flusys/nestjs-email 7.0.2 → 8.0.0-beta.1

package/fesm/providers/index.js

@@ -1,5 +1,523 @@
-export * from './email-provider.registry';
-export * from './email-factory.service';
-export * from './smtp-provider';
-export * from './sendgrid-provider';
-export * from './mailgun-provider';
+import { createHash } from "crypto";
+import { SYSTEM_MESSAGES } from "@flusys/nestjs-shared/constants";
+import * as __rspack_external__flusys_nestjs_shared_393d2cae from "@flusys/nestjs-shared";
+import * as __rspack_external__flusys_nestjs_shared_utils_9125c1f1 from "@flusys/nestjs-shared/utils";
+import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
+export const __rspack_esm_id = 467;
+export const __rspack_esm_ids = [467];
+export const __webpack_modules__ = {
+887(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+// ==================== EMAIL MODULE MESSAGE KEYS ====================
+const EMAIL_TEMPLATE_MESSAGES = {
+    GET_SUCCESS: 'email.template.get.success',
+    NOT_FOUND: 'email.template.not.found'
+};
+const EMAIL_CONFIG_MESSAGES = {
+    DEFAULT_DELETE_FORBIDDEN: 'email.config.default.delete.forbidden'
+};
+const EMAIL_SEND_MESSAGES = {
+    SUCCESS: 'email.send.success',
+    FAILED: 'email.send.failed',
+    CONFIG_NOT_FOUND: 'email.send.config.not.found',
+    CONFIG_INACTIVE: 'email.send.config.inactive',
+    CONFIG_DEFAULT_NOT_FOUND: 'email.send.config.default.not.found',
+    TEMPLATE_NOT_FOUND: 'email.send.template.not.found',
+    TEMPLATE_INACTIVE: 'email.send.template.inactive',
+    TEMPLATE_ID_OR_SLUG_REQUIRED: 'email.send.template.id.or.slug.required'
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  T6: EMAIL_CONFIG_MESSAGES,
+  dP: EMAIL_SEND_MESSAGES,
+  xP: EMAIL_TEMPLATE_MESSAGES
+});
+
+
+},
+603(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  c: () => (/* reexport */ EmailFactoryService),
+  xC: () => (/* reexport */ EmailProviderRegistry),
+  Xp: () => (/* reexport */ MailgunProvider),
+  Iw: () => (/* reexport */ SendGridProvider),
+  Kg: () => (/* reexport */ SmtpProvider)
+});
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/email-provider.registry.ts
+class EmailProviderRegistry {
+    static providers = new Map();
+    static register(providerName, providerClass) {
+        this.providers.set(providerName.toLowerCase(), providerClass);
+    }
+    static get(providerName) {
+        return this.providers.get(providerName.toLowerCase());
+    }
+    static has(providerName) {
+        return this.providers.has(providerName.toLowerCase());
+    }
+    static getAll() {
+        return Array.from(this.providers.keys());
+    }
+    static clear() {
+        this.providers.clear();
+    }
+}
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: external "crypto"
+
+// EXTERNAL MODULE: ./projects/nestjs-email/src/config/message-keys.ts
+var message_keys = __webpack_require__(887);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/email-factory.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+
+class EmailFactoryService {
+    providerCache = new Map();
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    async createProvider(config) {
+        const cacheKey = this.generateCacheKey(config);
+        const cached = this.providerCache.get(cacheKey);
+        if (cached) return cached;
+        const ProviderClass = EmailProviderRegistry.get(config.provider);
+        if (!ProviderClass) {
+            throw new common_.NotFoundException({
+                message: `Email provider '${config.provider}' is not registered`,
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.CONFIG_NOT_FOUND */.dP.CONFIG_NOT_FOUND,
+                messageVariables: {
+                    provider: config.provider,
+                    available: EmailProviderRegistry.getAll().join(', ')
+                }
+            });
+        }
+        try {
+            const instance = new ProviderClass();
+            await instance.initialize?.(config.config);
+            this.providerCache.set(cacheKey, instance);
+            return instance;
+        } catch (error) {
+            throw new common_.InternalServerErrorException({
+                message: `Email provider '${config.provider}' not initialized successfully: ${this.extractErrorMessage(error)}`,
+                messageKey: nestjs_shared_.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
+                messageVariables: {
+                    provider: config.provider,
+                    available: EmailProviderRegistry.getAll().join(', ')
+                }
+            });
+        }
+    }
+    // ─── Lifecycle ──────────────────────────────────────────────────────────────
+    async onModuleDestroy() {
+        const closePromises = Array.from(this.providerCache.entries()).map(([, provider])=>this.closeProvider(provider));
+        await Promise.allSettled(closePromises);
+        this.providerCache.clear();
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    generateCacheKey(config) {
+        const sortedKeys = Object.keys(config.config || {}).sort();
+        const configString = JSON.stringify(config.config, sortedKeys);
+        const hash = createHash('sha256').update(configString).digest('hex').substring(0, 16);
+        return `${config.provider}-${hash}`;
+    }
+    async closeProvider(provider) {
+        if (!provider.close) return;
+        try {
+            await provider.close();
+        } catch  {
+        // Silent failure
+        }
+    }
+    extractErrorMessage(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+}
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'email.createProvider',
+        module: 'email'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof IEmailProviderConfig === "undefined" ? Object : IEmailProviderConfig
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EmailFactoryService.prototype, "createProvider", null);
+EmailFactoryService = _ts_decorate([
+    (0,common_.Injectable)()
+], EmailFactoryService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/smtp-provider.ts
+const VERIFY_TIMEOUT_MS = 10_000;
+const SEND_TIMEOUT_MS = 30_000;
+class SmtpProvider {
+    transporter = null;
+    async initialize(config) {
+        const nodemailer = await __webpack_require__.e(/* import() */ 99).then(__webpack_require__.bind(__webpack_require__, 982));
+        this.transporter = nodemailer.createTransport({
+            host: config.host,
+            port: config.port,
+            secure: config.secure ?? config.port === 465,
+            auth: config.auth,
+            connectionTimeout: VERIFY_TIMEOUT_MS,
+            greetingTimeout: VERIFY_TIMEOUT_MS,
+            socketTimeout: SEND_TIMEOUT_MS,
+            tls: {
+                rejectUnauthorized: config.tls?.rejectUnauthorized ?? true,
+                minVersion: config.tls?.minVersion ?? 'TLSv1.2'
+            }
+        });
+        await this.withTimeout(this.transporter.verify(), VERIFY_TIMEOUT_MS, 'SMTP verification timeout');
+    }
+    async sendEmail(options) {
+        if (!this.transporter) return {
+            success: false,
+            error: 'SMTP provider not initialized'
+        };
+        try {
+            const mailOptions = {
+                from: this.formatFrom(options.from, options.fromName),
+                to: this.joinAddresses(options.to),
+                cc: options.cc ? this.joinAddresses(options.cc) : undefined,
+                bcc: options.bcc ? this.joinAddresses(options.bcc) : undefined,
+                subject: options.subject,
+                text: options.text,
+                html: options.html,
+                replyTo: options.replyTo,
+                attachments: options.attachments?.map((a)=>({
+                        filename: a.filename,
+                        content: a.content,
+                        contentType: a.contentType,
+                        encoding: a.encoding
+                    }))
+            };
+            const info = await this.withTimeout(this.transporter.sendMail(mailOptions), SEND_TIMEOUT_MS, 'SMTP send timeout');
+            return {
+                success: true,
+                messageId: info.messageId
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: this.extractError(error)
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    async healthCheck() {
+        if (!this.transporter) return false;
+        try {
+            await this.transporter.verify();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async close() {
+        if (this.transporter) {
+            this.transporter.close();
+            this.transporter = null;
+        }
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    formatFrom(from, fromName) {
+        return fromName ? `"${fromName}" <${from}>` : from;
+    }
+    joinAddresses(addresses) {
+        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
+    }
+    async withTimeout(promise, ms, message) {
+        let timer;
+        const timeout = new Promise((_, reject)=>{
+            timer = setTimeout(()=>reject(new Error(message)), ms);
+        });
+        try {
+            return await Promise.race([
+                promise,
+                timeout
+            ]);
+        } finally{
+            clearTimeout(timer);
+        }
+    }
+    extractError(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+}
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/constants"
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/utils"
+var utils_ = __webpack_require__(216);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/sendgrid-provider.ts
+
+
+
+class SendGridProvider {
+    sgMail = null;
+    apiKey = null;
+    async initialize(config) {
+        this.apiKey = config.apiKey;
+        try {
+            // Optional peer dependency - loaded at runtime so bundlers don't statically resolve it
+            const sgMailModule = await (0,utils_.loadOptionalModule)('@sendgrid/mail');
+            this.sgMail = sgMailModule.default || sgMailModule;
+            this.sgMail.setApiKey(config.apiKey);
+        } catch  {
+            throw new common_.InternalServerErrorException({
+                message: 'SendGrid initialization failed. Install: npm install @sendgrid/mail',
+                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageVariables: {
+                    sdk: 'sendgrid'
+                }
+            });
+        }
+    }
+    async sendEmail(options) {
+        if (!this.sgMail) return {
+            success: false,
+            error: 'SendGrid provider not initialized'
+        };
+        try {
+            const msg = this.buildMessage(options, true);
+            const [response] = await this.sgMail.send(msg);
+            const messageId = response.headers['x-message-id'] || response.headers['X-Message-Id'];
+            return {
+                success: true,
+                messageId
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: this.extractError(error)
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        if (!this.sgMail) return options.map(()=>({
+                success: false,
+                error: 'SendGrid provider not initialized'
+            }));
+        try {
+            const messages = options.map((opt)=>this.buildMessage(opt, false));
+            await this.sgMail.send(messages);
+            return options.map(()=>({
+                    success: true
+                }));
+        } catch (error) {
+            const errorMessage = this.extractError(error);
+            return options.map(()=>({
+                    success: false,
+                    error: errorMessage
+                }));
+        }
+    }
+    async healthCheck() {
+        return !!(this.sgMail && this.apiKey?.startsWith('SG.'));
+    }
+    async close() {
+        this.sgMail = null;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildMessage(options, includeExtras) {
+        const msg = {
+            to: this.toArray(options.to),
+            from: options.fromName ? {
+                email: options.from,
+                name: options.fromName
+            } : options.from,
+            subject: options.subject
+        };
+        if (options.html) msg.html = options.html;
+        if (options.text) msg.text = options.text;
+        if (includeExtras) {
+            if (options.cc) msg.cc = this.toArray(options.cc);
+            if (options.bcc) msg.bcc = this.toArray(options.bcc);
+            if (options.replyTo) msg.replyTo = options.replyTo;
+            if (options.attachments?.length) {
+                msg.attachments = options.attachments.map((a)=>({
+                        filename: a.filename,
+                        content: typeof a.content === 'string' ? a.content : a.content.toString('base64'),
+                        type: a.contentType,
+                        disposition: 'attachment'
+                    }));
+            }
+        }
+        return msg;
+    }
+    toArray(value) {
+        return Array.isArray(value) ? value : [
+            value
+        ];
+    }
+    extractError(error) {
+        const sgError = error;
+        return sgError.response?.body?.errors?.[0]?.message || sgError.message || 'Unknown error';
+    }
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/mailgun-provider.ts
+
+
+
+const MAILGUN_API_URL = 'https://api.mailgun.net';
+const MAILGUN_EU_API_URL = 'https://api.eu.mailgun.net';
+class MailgunProvider {
+    client = null;
+    domain = null;
+    async initialize(config) {
+        this.domain = config.domain;
+        try {
+            // Optional peer dependency - loaded at runtime so bundlers don't statically resolve it
+            const mailgunModule = await (0,utils_.loadOptionalModule)('mailgun.js');
+            const formDataModule = await (0,utils_.loadOptionalModule)('form-data');
+            const Mailgun = mailgunModule.default || mailgunModule;
+            const FormData = formDataModule.default || formDataModule;
+            const mailgun = new Mailgun(FormData);
+            const url = config.region === 'eu' ? MAILGUN_EU_API_URL : MAILGUN_API_URL;
+            this.client = mailgun.client({
+                username: 'api',
+                key: config.apiKey,
+                url
+            });
+        } catch  {
+            throw new common_.InternalServerErrorException({
+                message: 'Mailgun initialization failed. Install: npm install mailgun.js form-data',
+                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageVariables: {
+                    sdk: 'mailgun'
+                }
+            });
+        }
+    }
+    async sendEmail(options) {
+        if (!this.client || !this.domain) {
+            return {
+                success: false,
+                error: 'Mailgun provider not initialized'
+            };
+        }
+        try {
+            const messageData = this.buildMessageData(options);
+            const result = await this.client.messages.create(this.domain, messageData);
+            return {
+                success: true,
+                messageId: result.id
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: this.extractError(error)
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    async healthCheck() {
+        if (!this.client || !this.domain) return false;
+        try {
+            await this.client.domains.get(this.domain);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async close() {
+        this.client = null;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildMessageData(options) {
+        const data = {
+            from: options.fromName ? `${options.fromName} <${options.from}>` : options.from,
+            to: this.joinAddresses(options.to),
+            subject: options.subject
+        };
+        if (options.html) data.html = options.html;
+        if (options.text) data.text = options.text;
+        if (options.cc) data.cc = this.joinAddresses(options.cc);
+        if (options.bcc) data.bcc = this.joinAddresses(options.bcc);
+        if (options.replyTo) data['h:Reply-To'] = options.replyTo;
+        if (options.attachments?.length) {
+            data.attachment = options.attachments.map((a)=>({
+                    filename: a.filename,
+                    data: typeof a.content === 'string' ? Buffer.from(a.content, 'base64') : a.content,
+                    contentType: a.contentType
+                }));
+        }
+        return data;
+    }
+    joinAddresses(addresses) {
+        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
+    }
+    extractError(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/index.ts
+
+
+
+
+
+
+
+},
+422(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_393d2cae;
+
+
+},
+216(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_utils_9125c1f1;
+
+
+},
+157(module) {
+
+module.exports = __rspack_external__nestjs_common_a04939da;
+
+
+},
+
+};
+import { __webpack_require__ } from '../runtime.js';
+var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
+import * as __rspack_chunk_1 from './index.js';
+__webpack_require__.C(__rspack_chunk_1);
+var __webpack_exports__ = __webpack_exec__(603);var __webpack_exports__EmailFactoryService = __webpack_exports__.c;
+var __webpack_exports__EmailProviderRegistry = __webpack_exports__.xC;
+var __webpack_exports__MailgunProvider = __webpack_exports__.Xp;
+var __webpack_exports__SendGridProvider = __webpack_exports__.Iw;
+var __webpack_exports__SmtpProvider = __webpack_exports__.Kg;
+export { __webpack_exports__EmailFactoryService as EmailFactoryService, __webpack_exports__EmailProviderRegistry as EmailProviderRegistry, __webpack_exports__MailgunProvider as MailgunProvider, __webpack_exports__SendGridProvider as SendGridProvider, __webpack_exports__SmtpProvider as SmtpProvider };

package/fesm/runtime.js

@@ -0,0 +1,134 @@
+var __webpack_modules__ = ({});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// expose the modules object (__webpack_modules__)
+__webpack_require__.m = __webpack_modules__;
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/ensure_chunk
+(() => {
+__webpack_require__.f = {};
+// This file contains only the entry chunk.
+// The chunk loading function for additional chunks
+__webpack_require__.e = (chunkId) => {
+	return Promise.all(
+		Object.keys(__webpack_require__.f).reduce((promises, key) => {
+			__webpack_require__.f[key](chunkId, promises);
+			return promises;
+		}, [])
+	);
+};
+})();
+// webpack/runtime/export_webpack_require
+var __webpack_require__temp = __webpack_require__;
+export { __webpack_require__temp as __webpack_require__ };
+// webpack/runtime/get javascript chunk filename
+(() => {
+// This function allow to reference chunks
+__webpack_require__.u = (chunkId) => {
+  // return url for filenames not based on template
+  
+  // return url for filenames based on template
+  return "chunks/" + chunkId + ".js"
+}
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/module_chunk_loading
+(() => {
+// no BaseURI
+      // object to store loaded and loading chunks
+      // undefined = chunk not loaded, null = chunk preloaded/prefetched
+      // [resolve, Promise] = chunk loading, 0 = chunk loaded
+      var moduleInstalledChunks = {146: 0,};
+      var moduleInstallChunk = (data) => {
+    var __rspack_esm_ids = data.__rspack_esm_ids;
+    var moreModules = data.__webpack_modules__;
+    var __rspack_esm_runtime = data.__rspack_esm_runtime;
+    // add "modules" to the modules object,
+    // then flag all "ids" as loaded and fire callback
+    var moduleId, chunkId, i = 0;
+    for (moduleId in moreModules) {
+        if (__webpack_require__.o(moreModules, moduleId)) {
+            __webpack_require__.m[moduleId] = moreModules[moduleId];
+        }
+    }
+    if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
+    for (; i < __rspack_esm_ids.length; i++) {
+        chunkId = __rspack_esm_ids[i];
+        if (__webpack_require__.o(moduleInstalledChunks, chunkId) && moduleInstalledChunks[chunkId]) {
+            moduleInstalledChunks[chunkId][0]();
+        }
+        moduleInstalledChunks[__rspack_esm_ids[i]] = 0;
+    }
+    
+};
+
+        __webpack_require__.f.j = function (chunkId, promises) {
+          // import() chunk loading for javascript
+var installedChunkData = __webpack_require__.o(moduleInstalledChunks, chunkId) ? moduleInstalledChunks[chunkId] : undefined;
+if (installedChunkData !== 0) { // 0 means "already installed".'
+    // a Promise means "currently loading".
+    if (installedChunkData) {
+        promises.push(installedChunkData[1]);
+    } else {
+        if (146 != chunkId) {
+            // setup Promise in chunk cache
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(moduleInstallChunk, (e) => {
+                if (moduleInstalledChunks[chunkId] !== 0) moduleInstalledChunks[chunkId] = undefined;
+                throw e;
+            });
+            var promise = Promise.race([promise, new Promise((resolve) => {
+                installedChunkData = moduleInstalledChunks[chunkId] = [resolve];
+            })]);
+            promises.push(installedChunkData[1] = promise);
+        }
+        else moduleInstalledChunks[chunkId] = 0;
+
+    }
+}
+
+        }
+        
+        __webpack_require__.C = moduleInstallChunk;
+        // no on chunks loaded
+// no HMR
+// no HMR manifest
+
+})();

package/fesm/services/index.js

@@ -1,5 +1,17 @@
-export * from './email-config.service';
-export * from './email-datasource.provider';
-export * from './email-provider-config.service';
-export * from './email-send.service';
-export * from './email-template.service';
+export const __rspack_esm_id = 995;
+export const __rspack_esm_ids = [995];
+export const __webpack_modules__ = {};
+import { __webpack_require__ } from '../runtime.js';
+var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
+import * as __rspack_chunk_1 from '../261.js';
+__webpack_require__.C(__rspack_chunk_1);
+import * as __rspack_chunk_2 from '../493.js';
+__webpack_require__.C(__rspack_chunk_2);
+import * as __rspack_chunk_3 from './index.js';
+__webpack_require__.C(__rspack_chunk_3);
+var __webpack_exports__ = __webpack_exec__(676);var __webpack_exports__EmailConfigService = __webpack_exports__.mi;
+var __webpack_exports__EmailDataSourceProvider = __webpack_exports__.Zt;
+var __webpack_exports__EmailProviderConfigService = __webpack_exports__.jG;
+var __webpack_exports__EmailSendService = __webpack_exports__.yu;
+var __webpack_exports__EmailTemplateService = __webpack_exports__.uS;
+export { __webpack_exports__EmailConfigService as EmailConfigService, __webpack_exports__EmailDataSourceProvider as EmailDataSourceProvider, __webpack_exports__EmailProviderConfigService as EmailProviderConfigService, __webpack_exports__EmailSendService as EmailSendService, __webpack_exports__EmailTemplateService as EmailTemplateService };