@flink-app/email-plugin 2.0.0-alpha.74 → 2.0.0-alpha.75

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @flink-app/email-plugin
 
+## 2.0.0-alpha.75
+
+### Patch Changes
+
+-   @flink-app/flink@2.0.0-alpha.75
+
 ## 2.0.0-alpha.74
 
 ### Patch Changes

package/dist/index.d.ts

@@ -3,7 +3,10 @@ import { client } from "./schemas/client";
 export { sendgridClient } from "./sendgridClient";
 export { smtpClient } from "./smtpClient";
 export { flowMailerClient } from "./flowmailerClient";
+export { sesClient } from "./sesClient";
 export type { email } from "./schemas/email";
+export type { emailSes } from "./schemas/emailSes";
+export * from "./ses-types";
 export type emailPluginOptions = {
     /**
      * Path for request

package/dist/index.js

@@ -1,12 +1,29 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.emailPlugin = exports.flowMailerClient = exports.smtpClient = exports.sendgridClient = void 0;
+exports.emailPlugin = exports.sesClient = exports.flowMailerClient = exports.smtpClient = exports.sendgridClient = void 0;
 var sendgridClient_1 = require("./sendgridClient");
 Object.defineProperty(exports, "sendgridClient", { enumerable: true, get: function () { return sendgridClient_1.sendgridClient; } });
 var smtpClient_1 = require("./smtpClient");
 Object.defineProperty(exports, "smtpClient", { enumerable: true, get: function () { return smtpClient_1.smtpClient; } });
 var flowmailerClient_1 = require("./flowmailerClient");
 Object.defineProperty(exports, "flowMailerClient", { enumerable: true, get: function () { return flowmailerClient_1.flowMailerClient; } });
+var sesClient_1 = require("./sesClient");
+Object.defineProperty(exports, "sesClient", { enumerable: true, get: function () { return sesClient_1.sesClient; } });
+__exportStar(require("./ses-types"), exports);
 var emailPlugin = function (options) {
     return {
         id: "emailPlugin",

package/dist/schemas/client.d.ts

@@ -1,6 +1,7 @@
 import { email } from "./email";
 import { emailFlowmailer } from "./emailFlowmailer";
 import { emailSendgrid } from "./emailSendgrid";
+import { emailSes } from "./emailSes";
 export interface client {
-    send(email: email | emailSendgrid | emailFlowmailer): Promise<boolean>;
+    send(email: email | emailSendgrid | emailFlowmailer | emailSes): Promise<boolean>;
 }

package/dist/schemas/emailSes.d.ts

@@ -0,0 +1,60 @@
+export type emailSes = {
+    /**
+     * From address used to send the email
+     */
+    from: string;
+    /**
+     * Email addresses to send to
+     */
+    to: string[];
+    /**
+     * Reply-to addresses
+     */
+    replyTo?: string[];
+    /**
+     * CC addresses
+     */
+    cc?: string[];
+    /**
+     * Email addresses to add as BCC
+     */
+    bcc?: string[];
+    /**
+     * Subject of email
+     */
+    subject: string;
+    /**
+     * Plain text body
+     */
+    text?: string;
+    /**
+     * HTML body
+     */
+    html?: string;
+    /**
+     * File attachments
+     */
+    attachments?: SesAttachment[];
+    /**
+     * SES configuration set for tracking (opens, clicks, bounces)
+     */
+    configurationSet?: string;
+    /**
+     * SES tags for event filtering
+     */
+    tags?: Record<string, string>;
+};
+export interface SesAttachment {
+    /**
+     * Filename shown to recipient
+     */
+    filename: string;
+    /**
+     * Raw content as Buffer or base64 string
+     */
+    content: Buffer | string;
+    /**
+     * MIME content type (e.g. "application/pdf"). Defaults to "application/octet-stream"
+     */
+    contentType?: string;
+}

package/dist/schemas/emailSes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ses-types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Parameters for sending a templated email via SES
+ */
+export interface SesTemplatedEmailParams {
+    /** Sender address (overrides defaultFrom) */
+    from?: string;
+    /** Recipient addresses */
+    to: string[];
+    /** CC addresses */
+    cc?: string[];
+    /** BCC addresses */
+    bcc?: string[];
+    /** Reply-to addresses */
+    replyTo?: string[];
+    /** SES template name */
+    template: string;
+    /** Template data as key-value pairs (will be JSON.stringify'd for SES) */
+    templateData: Record<string, unknown>;
+    /** SES configuration set (overrides client default) */
+    configurationSet?: string;
+    /** SES tags for event filtering */
+    tags?: Record<string, string>;
+}
+/**
+ * Parameters for sending bulk emails via SES template
+ */
+export interface SesBulkEmailParams {
+    /** Sender address (overrides defaultFrom) */
+    from?: string;
+    /** SES template name */
+    template: string;
+    /** Default template data applied to all destinations */
+    defaultTemplateData?: Record<string, unknown>;
+    /** Individual recipients with optional per-recipient template overrides */
+    destinations: SesBulkDestination[];
+    /** SES configuration set (overrides client default) */
+    configurationSet?: string;
+    /** Reply-to addresses */
+    replyTo?: string[];
+    /** SES tags for event filtering */
+    tags?: Record<string, string>;
+}
+export interface SesBulkDestination {
+    to: string[];
+    cc?: string[];
+    bcc?: string[];
+    /** Per-destination template data (merged with defaultTemplateData) */
+    templateData?: Record<string, unknown>;
+}
+/**
+ * Result from a single send operation
+ */
+export interface SesResult {
+    success: boolean;
+    /** AWS MessageId, present on success */
+    messageId?: string;
+    /** Error details, present on failure */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Result from a bulk send operation
+ */
+export interface SesBulkResult {
+    success: boolean;
+    /** Per-destination results */
+    results: Array<{
+        success: boolean;
+        messageId?: string;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    /** Number of successful sends */
+    successCount: number;
+    /** Number of failed sends */
+    failureCount: number;
+}
+/**
+ * Result from verifySetup()
+ */
+export interface SesSetupStatus {
+    /** Whether credentials are valid and SES is accessible */
+    verified: boolean;
+    /** Whether the account is out of the SES sandbox */
+    sendingEnabled: boolean;
+    /** The configured AWS region */
+    region: string;
+    /** Error message if verification failed */
+    error?: string;
+}

package/dist/ses-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sesClient.d.ts

@@ -0,0 +1,48 @@
+import { SESv2Client } from "@aws-sdk/client-sesv2";
+import { client } from "./schemas/client";
+import { emailSes } from "./schemas/emailSes";
+import { SesTemplatedEmailParams, SesBulkEmailParams, SesResult, SesBulkResult, SesSetupStatus } from "./ses-types";
+export interface sesClientOptions {
+    /** AWS region (defaults to AWS_REGION env var) */
+    region?: string;
+    /** Explicit credentials. Omit to use default AWS credential chain (env vars, IAM roles, etc.) */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** Default "from" address when not specified per-email */
+    defaultFrom?: string;
+    /** Default SES configuration set name */
+    configurationSet?: string;
+}
+export declare class sesClient implements client {
+    private awsClient;
+    private defaultFrom?;
+    private defaultConfigurationSet?;
+    constructor(options: sesClientOptions, awsClient?: SESv2Client);
+    /**
+     * Send an email via SES. Implements the base `client` interface.
+     * Returns `true` on success, `false` on failure.
+     * For richer results (messageId, error details), use `sendEmail()` instead.
+     */
+    send(email: emailSes): Promise<boolean>;
+    /**
+     * Send an email via SES with rich result including messageId and error details.
+     */
+    sendEmail(email: emailSes): Promise<SesResult>;
+    /**
+     * Send a templated email using an SES template.
+     */
+    sendTemplated(params: SesTemplatedEmailParams): Promise<SesResult>;
+    /**
+     * Send bulk emails using an SES template.
+     */
+    sendBulk(params: SesBulkEmailParams): Promise<SesBulkResult>;
+    /**
+     * Verify that the SES setup is working — checks credentials and account status.
+     */
+    verifySetup(): Promise<SesSetupStatus>;
+    private toMessageTags;
+    private buildRawMimeMessage;
+}

package/dist/sesClient.js

@@ -0,0 +1,388 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sesClient = void 0;
+var client_sesv2_1 = require("@aws-sdk/client-sesv2");
+var sesClient = /** @class */ (function () {
+    function sesClient(options, awsClient) {
+        this.defaultFrom = options.defaultFrom;
+        this.defaultConfigurationSet = options.configurationSet;
+        this.awsClient =
+            awsClient !== null && awsClient !== void 0 ? awsClient : new client_sesv2_1.SESv2Client({
+                region: options.region,
+                credentials: options.credentials,
+            });
+    }
+    /**
+     * Send an email via SES. Implements the base `client` interface.
+     * Returns `true` on success, `false` on failure.
+     * For richer results (messageId, error details), use `sendEmail()` instead.
+     */
+    sesClient.prototype.send = function (email) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendEmail(email)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    /**
+     * Send an email via SES with rich result including messageId and error details.
+     */
+    sesClient.prototype.sendEmail = function (email) {
+        return __awaiter(this, void 0, void 0, function () {
+            var from, hasAttachments, content, input, response, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        from = email.from || this.defaultFrom;
+                        if (!from) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: {
+                                        code: "MISSING_FROM",
+                                        message: "No 'from' address specified. Set it on the email or use defaultFrom in sesClientOptions.",
+                                    },
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        hasAttachments = email.attachments && email.attachments.length > 0;
+                        content = hasAttachments
+                            ? { Raw: { Data: this.buildRawMimeMessage(email, from) } }
+                            : {
+                                Simple: {
+                                    Subject: { Data: email.subject, Charset: "UTF-8" },
+                                    Body: __assign(__assign({}, (email.text
+                                        ? { Text: { Data: email.text, Charset: "UTF-8" } }
+                                        : {})), (email.html
+                                        ? { Html: { Data: email.html, Charset: "UTF-8" } }
+                                        : {})),
+                                },
+                            };
+                        input = {
+                            FromEmailAddress: from,
+                            Destination: {
+                                ToAddresses: email.to,
+                                CcAddresses: email.cc,
+                                BccAddresses: email.bcc,
+                            },
+                            ReplyToAddresses: email.replyTo,
+                            ConfigurationSetName: email.configurationSet || this.defaultConfigurationSet,
+                            EmailTags: this.toMessageTags(email.tags),
+                            Content: content,
+                        };
+                        return [4 /*yield*/, this.awsClient.send(new client_sesv2_1.SendEmailCommand(input))];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                messageId: response.MessageId,
+                            }];
+                    case 3:
+                        err_1 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: {
+                                    code: err_1.name || err_1.code || "UNKNOWN",
+                                    message: err_1.message || "Unknown error",
+                                },
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Send a templated email using an SES template.
+     */
+    sesClient.prototype.sendTemplated = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var from, input, response, err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        from = params.from || this.defaultFrom;
+                        if (!from) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: {
+                                        code: "MISSING_FROM",
+                                        message: "No 'from' address specified. Set it on params or use defaultFrom in sesClientOptions.",
+                                    },
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        input = {
+                            FromEmailAddress: from,
+                            Destination: {
+                                ToAddresses: params.to,
+                                CcAddresses: params.cc,
+                                BccAddresses: params.bcc,
+                            },
+                            ReplyToAddresses: params.replyTo,
+                            ConfigurationSetName: params.configurationSet || this.defaultConfigurationSet,
+                            EmailTags: this.toMessageTags(params.tags),
+                            Content: {
+                                Template: {
+                                    TemplateName: params.template,
+                                    TemplateData: JSON.stringify(params.templateData),
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, this.awsClient.send(new client_sesv2_1.SendEmailCommand(input))];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                messageId: response.MessageId,
+                            }];
+                    case 3:
+                        err_2 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: {
+                                    code: err_2.name || err_2.code || "UNKNOWN",
+                                    message: err_2.message || "Unknown error",
+                                },
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Send bulk emails using an SES template.
+     */
+    sesClient.prototype.sendBulk = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var from, input, response, results, successCount, failureCount, err_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        from = params.from || this.defaultFrom;
+                        if (!from) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    results: [],
+                                    successCount: 0,
+                                    failureCount: params.destinations.length,
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        input = {
+                            FromEmailAddress: from,
+                            ReplyToAddresses: params.replyTo,
+                            ConfigurationSetName: params.configurationSet || this.defaultConfigurationSet,
+                            DefaultEmailTags: this.toMessageTags(params.tags),
+                            DefaultContent: {
+                                Template: {
+                                    TemplateName: params.template,
+                                    TemplateData: params.defaultTemplateData
+                                        ? JSON.stringify(params.defaultTemplateData)
+                                        : undefined,
+                                },
+                            },
+                            BulkEmailEntries: params.destinations.map(function (dest) { return ({
+                                Destination: {
+                                    ToAddresses: dest.to,
+                                    CcAddresses: dest.cc,
+                                    BccAddresses: dest.bcc,
+                                },
+                                ReplacementEmailContent: dest.templateData
+                                    ? {
+                                        ReplacementTemplate: {
+                                            ReplacementTemplateData: JSON.stringify(dest.templateData),
+                                        },
+                                    }
+                                    : undefined,
+                            }); }),
+                        };
+                        return [4 /*yield*/, this.awsClient.send(new client_sesv2_1.SendBulkEmailCommand(input))];
+                    case 2:
+                        response = _a.sent();
+                        results = (response.BulkEmailEntryResults || []).map(function (entry) {
+                            var success = entry.Status === "SUCCESS";
+                            return {
+                                success: success,
+                                messageId: success ? entry.MessageId : undefined,
+                                error: !success
+                                    ? {
+                                        code: entry.Error || "UNKNOWN",
+                                        message: entry.Error || "Bulk send entry failed",
+                                    }
+                                    : undefined,
+                            };
+                        });
+                        successCount = results.filter(function (r) { return r.success; }).length;
+                        failureCount = results.filter(function (r) { return !r.success; }).length;
+                        return [2 /*return*/, {
+                                success: failureCount === 0,
+                                results: results,
+                                successCount: successCount,
+                                failureCount: failureCount,
+                            }];
+                    case 3:
+                        err_3 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                results: [],
+                                successCount: 0,
+                                failureCount: params.destinations.length,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Verify that the SES setup is working — checks credentials and account status.
+     */
+    sesClient.prototype.verifySetup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, region, err_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, this.awsClient.send(new client_sesv2_1.GetAccountCommand({}))];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.awsClient.config.region()];
+                    case 2:
+                        region = (_a.sent()) || "unknown";
+                        return [2 /*return*/, {
+                                verified: true,
+                                sendingEnabled: response.ProductionAccessEnabled === true,
+                                region: region,
+                            }];
+                    case 3:
+                        err_4 = _a.sent();
+                        return [2 /*return*/, {
+                                verified: false,
+                                sendingEnabled: false,
+                                region: "unknown",
+                                error: err_4.message || "Failed to verify SES setup",
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    sesClient.prototype.toMessageTags = function (tags) {
+        if (!tags)
+            return undefined;
+        return Object.entries(tags).map(function (_a) {
+            var Name = _a[0], Value = _a[1];
+            return ({ Name: Name, Value: Value });
+        });
+    };
+    sesClient.prototype.buildRawMimeMessage = function (email, from) {
+        var _a, _b;
+        var boundary = "----=_Part_".concat(Date.now(), "_").concat(Math.random().toString(36).substring(2));
+        var lines = [];
+        lines.push("From: ".concat(from));
+        lines.push("To: ".concat(email.to.join(", ")));
+        if ((_a = email.cc) === null || _a === void 0 ? void 0 : _a.length)
+            lines.push("Cc: ".concat(email.cc.join(", ")));
+        if ((_b = email.replyTo) === null || _b === void 0 ? void 0 : _b.length)
+            lines.push("Reply-To: ".concat(email.replyTo.join(", ")));
+        lines.push("Subject: =?UTF-8?B?".concat(Buffer.from(email.subject).toString("base64"), "?="));
+        lines.push("MIME-Version: 1.0");
+        lines.push("Content-Type: multipart/mixed; boundary=\"".concat(boundary, "\""));
+        lines.push("");
+        // Text part
+        if (email.text) {
+            lines.push("--".concat(boundary));
+            lines.push("Content-Type: text/plain; charset=UTF-8");
+            lines.push("Content-Transfer-Encoding: 7bit");
+            lines.push("");
+            lines.push(email.text);
+            lines.push("");
+        }
+        // HTML part
+        if (email.html) {
+            lines.push("--".concat(boundary));
+            lines.push("Content-Type: text/html; charset=UTF-8");
+            lines.push("Content-Transfer-Encoding: 7bit");
+            lines.push("");
+            lines.push(email.html);
+            lines.push("");
+        }
+        // Attachments
+        for (var _i = 0, _c = email.attachments || []; _i < _c.length; _i++) {
+            var attachment = _c[_i];
+            var contentType = attachment.contentType || "application/octet-stream";
+            var base64Content = Buffer.isBuffer(attachment.content)
+                ? attachment.content.toString("base64")
+                : attachment.content;
+            lines.push("--".concat(boundary));
+            lines.push("Content-Type: ".concat(contentType, "; name=\"").concat(attachment.filename, "\""));
+            lines.push("Content-Disposition: attachment; filename=\"".concat(attachment.filename, "\""));
+            lines.push("Content-Transfer-Encoding: base64");
+            lines.push("");
+            lines.push(base64Content);
+            lines.push("");
+        }
+        lines.push("--".concat(boundary, "--"));
+        return new TextEncoder().encode(lines.join("\r\n"));
+    };
+    return sesClient;
+}());
+exports.sesClient = sesClient;