@konplit-services/common 1.1.0 → 1.2.1

package/build/middlewares/mono-webhook.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monoVerifyWebhook = void 0;
+const app_configs_1 = require("../app.configs");
+const helper_1 = require("../helper");
+const errors_1 = require("../errors");
+const monoVerifyWebhook = (req, res, next) => {
+    const { webhook_secret } = app_configs_1.appConfigs.getMonoDetails();
+    if (req.headers["mono-webhook-secret"] !== webhook_secret) {
+        throw new errors_1.NotAuthorizedError("You do not have permission to access this endpoint", helper_1.error_codes.INVALID_FORBIDDEN);
+    }
+    next();
+};
+exports.monoVerifyWebhook = monoVerifyWebhook;

package/build/middlewares/permission.d.ts

@@ -0,0 +1,11 @@
+import { NextFunction, Request, Response } from "express";
+import { JWT_Data } from "../services/Jwt";
+import { USER_TYPES } from "../helper";
+declare global {
+    namespace Express {
+        interface Request {
+            currentUser?: JWT_Data;
+        }
+    }
+}
+export declare const hasPermission: (userType: USER_TYPES, permissionCode: string) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/permission.js

@@ -0,0 +1,47 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPermission = void 0;
+const forbidden_error_1 = require("../errors/forbidden-error");
+const notAuthorized_1 = require("../errors/notAuthorized");
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const language_1 = require("../helper/lang/language");
+const base_1 = require("../redis/base");
+const constants_1 = require("../redis/constants");
+const hasPermission = (userType, permissionCode) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        //comment
+        if (!req.currentUser) {
+            throw new notAuthorized_1.NotAuthorizedError(language_1.lang.not_authorized, error_codes_1.error_codes.INVALID_AUTHORIZATION);
+        }
+        const user = req.currentUser;
+        if (userType !== user.userType) {
+            throw new forbidden_error_1.ForbiddenError(language_1.lang.forbidden, error_codes_1.error_codes.INVALID_FORBIDDEN);
+        }
+        try {
+            let permissions = [];
+            const perm = yield base_1.redisWrapper.get((0, constants_1.getPermissions)(user.id));
+            if (!perm) {
+                throw new forbidden_error_1.ForbiddenError(language_1.lang.forbidden, error_codes_1.error_codes.INVALID_FORBIDDEN);
+            }
+            permissions = JSON.parse(perm);
+            if (!permissions.includes(permissionCode)) {
+                throw new forbidden_error_1.ForbiddenError(language_1.lang.forbidden, error_codes_1.error_codes.INVALID_FORBIDDEN);
+            }
+            return next();
+        }
+        catch (error) {
+            console.log();
+            throw error;
+        }
+    });
+};
+exports.hasPermission = hasPermission;

package/build/middlewares/rate-limit.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const konplitRateLimit: (duration: number) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/rate-limit.js

@@ -0,0 +1,39 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.konplitRateLimit = void 0;
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const errors_1 = require("../errors");
+const redis_1 = require("../redis");
+//durations in seconds
+const konplitRateLimit = (duration) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const clientIp = req.ip || req.socket.remoteAddress || "";
+        const key = `rate_limit:${clientIp}`;
+        try {
+            const lastRequestTime = yield redis_1.redisWrapper.get(key);
+            if (lastRequestTime) {
+                throw new errors_1.TooManyRequestError(`Too many requests, please wait ${duration} seconds.`, error_codes_1.error_codes.TOO_MANY_REQUEST);
+            }
+            // Set the rate limit key with an expiry of 6 seconds
+            yield redis_1.redisWrapper.client.set(key, Date.now(), "EX", duration);
+            next();
+        }
+        catch (error) {
+            console.error("Redis error:", error);
+            if (error instanceof errors_1.CustomError) {
+                throw error;
+            }
+            throw new errors_1.ServiceNotAvailableError("Please try again server error", error_codes_1.error_codes.SERVER_ERROR);
+        }
+    });
+};
+exports.konplitRateLimit = konplitRateLimit;

package/build/middlewares/request-log.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="qs" />
+import { Request, Response } from "express";
+export declare const useMorgan: (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, callback: (err?: Error | undefined) => void) => void;

package/build/middlewares/request-log.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMorgan = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+const morgan_1 = __importDefault(require("morgan"));
+// Configure Day.js with plugins
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+// Create a custom Morgan logging function
+exports.useMorgan = (0, morgan_1.default)((tokens, req, res) => {
+    const timestamp = (0, dayjs_1.default)()
+        .tz("Africa/Lagos")
+        .format("YYYY-MM-DD HH:mm:ss.SSS");
+    return [
+        timestamp,
+        tokens["remote-addr"](req, res),
+        tokens.method(req, res),
+        tokens.url(req, res),
+        tokens.status(req, res),
+        `${tokens["response-time"](req, res)} ms`,
+        `Content-Length: ${tokens.res(req, res, "content-length") || "0"}`,
+        `User-Agent: ${req.headers["user-agent"] || "N/A"}`,
+    ].join(" | ");
+}, {
+    stream: {
+        write: (message) => {
+            console.log(message.trim()); // Customize log handling here
+        },
+    },
+});

package/build/middlewares/require-auth.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const requireAuth: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/require-auth.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuth = void 0;
+const notAuthorized_1 = require("../errors/notAuthorized");
+const language_1 = require("../helper/lang/language");
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const requireAuth = (req, res, next) => {
+    if (!req.currentUser) {
+        throw new notAuthorized_1.NotAuthorizedError(language_1.lang.not_authorized, error_codes_1.error_codes.INVALID_AUTHORIZATION);
+    }
+    next();
+};
+exports.requireAuth = requireAuth;

package/build/middlewares/transaction-session.d.ts

@@ -0,0 +1,10 @@
+import { NextFunction, Request, Response } from "express";
+import { TRANSACTION_JWT_DATA } from "../services/Jwt";
+declare global {
+    namespace Express {
+        interface Request {
+            transactionData: TRANSACTION_JWT_DATA;
+        }
+    }
+}
+export declare const validateTransactionSession: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/transaction-session.js

@@ -0,0 +1,36 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTransactionSession = void 0;
+const Jwt_1 = require("../services/Jwt");
+const notAuthorized_1 = require("../errors/notAuthorized");
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const app_configs_1 = require("../app.configs");
+const validateTransactionSession = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!req.headers["k-session"]) {
+        throw new notAuthorized_1.NotAuthorizedError("session  token not provided", error_codes_1.error_codes.INVALID_AUTHORIZATION);
+    }
+    try {
+        if (req.headers["k-session"]) {
+            const token = req.headers["k-session"];
+            const payload = yield Jwt_1.JWT.verifyTransactionToken(token);
+            req.transactionData = payload;
+        }
+        return next();
+    }
+    catch (error) {
+        if (app_configs_1.appConfigs.getNODE_ENV() !== "production") {
+            console.log("failed to process transaction token");
+        }
+        throw new notAuthorized_1.NotAuthorizedError("Invalid transaction session pleas restart the process again", error_codes_1.error_codes.INVALID_AUTHORIZATION);
+    }
+});
+exports.validateTransactionSession = validateTransactionSession;

package/build/middlewares/validate-fields.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const validAllowedFields: (allowFields: string[]) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/validate-fields.js

@@ -0,0 +1,44 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validAllowedFields = void 0;
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const errors_1 = require("../errors");
+const validAllowedFields = (allowFields) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const params = Object.keys(req.params);
+            const query = Object.keys(req.query);
+            const body = Object.keys(req.body);
+            const submittedFields = [...params, ...query, ...body];
+            const newAllowedFields = [
+                ...allowFields,
+                "search",
+                "page",
+                "limit",
+                "from",
+                "to",
+                "sort_by",
+                "order",
+            ];
+            const extraFields = submittedFields.filter((field) => !newAllowedFields.includes(field));
+            if (extraFields.length > 0) {
+                throw new errors_1.BadRequestError(`Extra fields submitted: ${extraFields.join(", ")}`, error_codes_1.error_codes.INVALID_INPUT);
+            }
+            return next();
+        }
+        catch (error) {
+            console.log();
+            throw error;
+        }
+    });
+};
+exports.validAllowedFields = validAllowedFields;

package/build/middlewares/validate-request.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const validateRequest: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/validate-request.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRequest = void 0;
+const express_validator_1 = require("express-validator");
+const request_validation_error_1 = require("../errors/request-validation-error");
+const validateRequest = (req, res, next) => {
+    const errros = (0, express_validator_1.validationResult)(req);
+    if (!errros.isEmpty()) {
+        throw new request_validation_error_1.RequestValidationError(errros.array());
+    }
+    next();
+};
+exports.validateRequest = validateRequest;

package/build/nats-cons.d.ts

@@ -0,0 +1,12 @@
+import { JetStreamClient, NatsConnection, ConnectionOptions } from "nats";
+declare class NatsWrapper {
+    private static instance;
+    private nc;
+    private js;
+    private constructor();
+    static getInstance(): NatsWrapper;
+    connect(options: ConnectionOptions): Promise<JetStreamClient>;
+    get getJetStream(): JetStreamClient;
+    get getConnection(): NatsConnection;
+}
+export default NatsWrapper;

package/build/nats-cons.js

@@ -0,0 +1,54 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nats_1 = require("nats");
+class NatsWrapper {
+    constructor() {
+        this.nc = null;
+        this.js = null;
+    }
+    static getInstance() {
+        if (!NatsWrapper.instance) {
+            NatsWrapper.instance = new NatsWrapper();
+        }
+        return NatsWrapper.instance;
+    }
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.nc && this.js) {
+                return this.js;
+            }
+            try {
+                this.nc = yield (0, nats_1.connect)(options);
+                console.log("Connected to NATS JetStream Server");
+                this.js = this.nc.jetstream();
+                return this.js;
+            }
+            catch (error) {
+                console.error("NATS JetStream connection error:", error);
+                throw error;
+            }
+        });
+    }
+    get getJetStream() {
+        if (!this.js) {
+            throw new Error("JetStream not connected. Call connect() first.");
+        }
+        return this.js;
+    }
+    get getConnection() {
+        if (!this.nc) {
+            throw new Error("NATS client not connected. Call connect() first.");
+        }
+        return this.nc;
+    }
+}
+exports.default = NatsWrapper;

package/build/notification/email/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./send";
+export * from "./types";

package/build/notification/email/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./send"), exports);
+__exportStar(require("./types"), exports);

package/build/notification/email/send.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+export interface PersonalizationEntry {
+    email: string;
+    data: Record<string, any>;
+}
+export interface EmailData {
+    to: string;
+    subject: string;
+    templateId?: string;
+    personalization?: PersonalizationEntry[];
+    pdf?: {
+        file: Buffer;
+        fileName: string;
+    };
+    sendAt?: number;
+}
+export declare class EmailService {
+    private mailerSend;
+    constructor(apiKey: string);
+    /**
+     *
+     * @param data the send mail data
+     */
+    sendEmail(data: EmailData, send_email: string, sender_name: string, recipient_name?: string): Promise<void>;
+}

package/build/notification/email/send.js

@@ -0,0 +1,56 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailService = void 0;
+const mailersend_1 = require("mailersend");
+class EmailService {
+    constructor(apiKey) {
+        this.mailerSend = new mailersend_1.MailerSend({
+            apiKey,
+        });
+    }
+    /**
+     *
+     * @param data the send mail data
+     */
+    sendEmail(data, send_email, sender_name, recipient_name = "") {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sentFrom = new mailersend_1.Sender(send_email, sender_name);
+            const recipients = [new mailersend_1.Recipient(data.to, recipient_name)];
+            const emailParams = new mailersend_1.EmailParams()
+                .setFrom(sentFrom)
+                .setTo(recipients)
+                .setReplyTo(sentFrom)
+                .setSubject(data.subject);
+            if (data.templateId) {
+                emailParams.setTemplateId(data.templateId);
+                if (data.personalization) {
+                    const personalizationArray = data.personalization.map((entry) => ({
+                        email: entry.email,
+                        data: entry.data,
+                    }));
+                    emailParams.setPersonalization(personalizationArray);
+                }
+            }
+            if (data.pdf) {
+                const pdfAttachment = [
+                    new mailersend_1.Attachment(data.pdf.file.toString("base64"), data.pdf.fileName, "attachment"),
+                ];
+                emailParams.setAttachments(pdfAttachment);
+            }
+            if (data.sendAt) {
+                emailParams.setSendAt(new Date(data.sendAt * 1000).getTime());
+            }
+            yield this.mailerSend.email.send(emailParams);
+        });
+    }
+}
+exports.EmailService = EmailService;

package/build/notification/email/types.d.ts

@@ -0,0 +1,22 @@
+export declare enum EMAIL_TYPES {
+    VERIFY_ACCOUNT = "VERIFY_ACCOUNT",
+    BUSINESS_ADDED = "BUSINESS_ADDED",
+    CONFIRMATION = "CONFIRMATION",
+    TWOFAVERIFICATION = "TWOFAVERIFICATION",
+    RESET_PASSWORD_REQUEST = "RESET_PASSWORD_REQUEST",
+    PASSWORD_CHANGED = "PASSWORD_CHANGED",
+    PAYEE_INVOICE = "PAYEE_INVOICE",
+    KEYS_GENERATED = "KEYS_GENERATED",
+    REFUND_REQUEST = "REFUND_REQUEST",
+    REFUND_UPDATE = "REFUND_UPDATE",
+    REFUND_SENT = "REFUND_SENT",
+    CHARGE_BACK_REQUEST = "CHARGE_BACK_REQUEST",
+    CHARGE_BACK_UPDATE = "CHARGE_BACK_UPDATE",
+    CHARGE_BACK_RESOLVED = "CHARGE_BACK_RESOLVED",
+    TRANSFER_REQUEST = "TRANSFER_REQUEST",
+    TRANSFER_UPDATE = "TRANSFER_UPDATE",
+    TRANSFER_SENT = "TRANSFER_SENT",
+    SETTLEMENT_CREATED = "SETTLEMENT_CREATED",
+    MERCHANT_CUSTOMER_PAYMENT_NOTIFICATION = "MERCHANT_CUSTOMER_PAYMENT_NOTIFICATION",
+    MERCHANT_BUSINESS_PAYMENT_NOTIFICATION = "MERCHANT_PAYMENT_NOTIFICATION"
+}

package/build/notification/email/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMAIL_TYPES = void 0;
+var EMAIL_TYPES;
+(function (EMAIL_TYPES) {
+    EMAIL_TYPES["VERIFY_ACCOUNT"] = "VERIFY_ACCOUNT";
+    EMAIL_TYPES["BUSINESS_ADDED"] = "BUSINESS_ADDED";
+    EMAIL_TYPES["CONFIRMATION"] = "CONFIRMATION";
+    EMAIL_TYPES["TWOFAVERIFICATION"] = "TWOFAVERIFICATION";
+    EMAIL_TYPES["RESET_PASSWORD_REQUEST"] = "RESET_PASSWORD_REQUEST";
+    EMAIL_TYPES["PASSWORD_CHANGED"] = "PASSWORD_CHANGED";
+    EMAIL_TYPES["PAYEE_INVOICE"] = "PAYEE_INVOICE";
+    EMAIL_TYPES["KEYS_GENERATED"] = "KEYS_GENERATED";
+    EMAIL_TYPES["REFUND_REQUEST"] = "REFUND_REQUEST";
+    EMAIL_TYPES["REFUND_UPDATE"] = "REFUND_UPDATE";
+    EMAIL_TYPES["REFUND_SENT"] = "REFUND_SENT";
+    EMAIL_TYPES["CHARGE_BACK_REQUEST"] = "CHARGE_BACK_REQUEST";
+    EMAIL_TYPES["CHARGE_BACK_UPDATE"] = "CHARGE_BACK_UPDATE";
+    EMAIL_TYPES["CHARGE_BACK_RESOLVED"] = "CHARGE_BACK_RESOLVED";
+    EMAIL_TYPES["TRANSFER_REQUEST"] = "TRANSFER_REQUEST";
+    EMAIL_TYPES["TRANSFER_UPDATE"] = "TRANSFER_UPDATE";
+    EMAIL_TYPES["TRANSFER_SENT"] = "TRANSFER_SENT";
+    EMAIL_TYPES["SETTLEMENT_CREATED"] = "SETTLEMENT_CREATED";
+    EMAIL_TYPES["MERCHANT_CUSTOMER_PAYMENT_NOTIFICATION"] = "MERCHANT_CUSTOMER_PAYMENT_NOTIFICATION";
+    EMAIL_TYPES["MERCHANT_BUSINESS_PAYMENT_NOTIFICATION"] = "MERCHANT_PAYMENT_NOTIFICATION";
+})(EMAIL_TYPES = exports.EMAIL_TYPES || (exports.EMAIL_TYPES = {}));

package/build/notification/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./email";
+export * from "./sms";
+export * from "./types";
+export * from "./interfaces";

package/build/notification/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./email"), exports);
+__exportStar(require("./sms"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./interfaces"), exports);