@konplit-services/common 1.2.0 → 1.2.1

package/build/helper/card_auth_type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARD_ATH_TYPE = void 0;
+var CARD_ATH_TYPE;
+(function (CARD_ATH_TYPE) {
+    CARD_ATH_TYPE["user_otp"] = "user_otp";
+    CARD_ATH_TYPE["user_3ds"] = "user_3ds";
+    CARD_ATH_TYPE["no_auth"] = "no_auth";
+})(CARD_ATH_TYPE = exports.CARD_ATH_TYPE || (exports.CARD_ATH_TYPE = {}));

package/build/helper/charges.d.ts

@@ -0,0 +1,31 @@
+export declare enum TOPUP_TRANSACTIONS {
+    FUND_WALLET = "FUND_WALLET",
+    BUY_DATA = "BUY_DATA",
+    BUY_AIRTIME = "BUY_AIRTIME",
+    TV_SUBSCRIPTION = "TV_SUBSCRIPTION",
+    TRANSFER = "TRANSFER"
+}
+export declare enum TRANSACTION_CHARGES_TYPE {
+    FUND_WALLET = "FUND_WALLET",
+    UPDATE_TRANSACTION = "UPDATE_TRANSACTION"
+}
+export declare enum ORIGIN {
+    wallet = "wallet"
+}
+export declare enum REVENUE_TYPE {
+    transfer = "transfer",
+    transaction = "transaction"
+}
+export interface Range {
+    min: number;
+    charge: number;
+    max: number;
+}
+export interface Charge {
+    type: "percent" | "flat";
+    value: number | Range[];
+    cap?: number | null;
+}
+export interface PaymentMethodCharge {
+    charge: Charge;
+}

package/build/helper/charges.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REVENUE_TYPE = exports.ORIGIN = exports.TRANSACTION_CHARGES_TYPE = exports.TOPUP_TRANSACTIONS = void 0;
+var TOPUP_TRANSACTIONS;
+(function (TOPUP_TRANSACTIONS) {
+    TOPUP_TRANSACTIONS["FUND_WALLET"] = "FUND_WALLET";
+    TOPUP_TRANSACTIONS["BUY_DATA"] = "BUY_DATA";
+    TOPUP_TRANSACTIONS["BUY_AIRTIME"] = "BUY_AIRTIME";
+    TOPUP_TRANSACTIONS["TV_SUBSCRIPTION"] = "TV_SUBSCRIPTION";
+    TOPUP_TRANSACTIONS["TRANSFER"] = "TRANSFER";
+})(TOPUP_TRANSACTIONS = exports.TOPUP_TRANSACTIONS || (exports.TOPUP_TRANSACTIONS = {}));
+var TRANSACTION_CHARGES_TYPE;
+(function (TRANSACTION_CHARGES_TYPE) {
+    TRANSACTION_CHARGES_TYPE["FUND_WALLET"] = "FUND_WALLET";
+    TRANSACTION_CHARGES_TYPE["UPDATE_TRANSACTION"] = "UPDATE_TRANSACTION";
+})(TRANSACTION_CHARGES_TYPE = exports.TRANSACTION_CHARGES_TYPE || (exports.TRANSACTION_CHARGES_TYPE = {}));
+var ORIGIN;
+(function (ORIGIN) {
+    ORIGIN["wallet"] = "wallet";
+})(ORIGIN = exports.ORIGIN || (exports.ORIGIN = {}));
+var REVENUE_TYPE;
+(function (REVENUE_TYPE) {
+    REVENUE_TYPE["transfer"] = "transfer";
+    REVENUE_TYPE["transaction"] = "transaction";
+})(REVENUE_TYPE = exports.REVENUE_TYPE || (exports.REVENUE_TYPE = {}));

package/build/helper/currency-formater.d.ts

@@ -0,0 +1,2 @@
+import { CURRENCY_TYPE } from "./currency-types";
+export declare const formatCurrency: (amount: number, currency?: CURRENCY_TYPE, locale?: string) => string;

package/build/helper/currency-formater.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrency = void 0;
+const currency_types_1 = require("./currency-types");
+const formatCurrency = (amount, currency = currency_types_1.CURRENCY_TYPE.NGN, locale = "en-NG") => {
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currency,
+    }).format(amount);
+};
+exports.formatCurrency = formatCurrency;
+//console.log(formatCurrency(123456.78, "USD")); // $123,456.78
+//console.log(formatCurrency(123456.78, "EUR", "de-DE")); // 123.456,78 €
+//console.log(formatCurrency(123456.78, "NGN", "en-NG")); // ₦123,456.78

package/build/helper/currency-types.d.ts

@@ -0,0 +1,4 @@
+export declare enum CURRENCY_TYPE {
+    NGN = "NGN",
+    USD = "USD"
+}

package/build/helper/currency-types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENCY_TYPE = void 0;
+var CURRENCY_TYPE;
+(function (CURRENCY_TYPE) {
+    CURRENCY_TYPE["NGN"] = "NGN";
+    CURRENCY_TYPE["USD"] = "USD";
+})(CURRENCY_TYPE = exports.CURRENCY_TYPE || (exports.CURRENCY_TYPE = {}));

package/build/helper/custom-paginate.d.ts

@@ -0,0 +1,52 @@
+import { Model, PopulateOptions } from "mongoose";
+export interface PaginationOptions {
+    page?: number;
+    limit?: number;
+    sort?: Record<string, "asc" | "desc">;
+    select?: string | Record<string, any>;
+    query?: Record<string, any>;
+    populate?: (string | PopulateOptions)[];
+}
+export interface PaginationResult<T> {
+    current_page: number;
+    total_page: number;
+    total_docs: number;
+    has_next: boolean;
+    has_previous: boolean;
+    next_page: number | null;
+    previous_page: number | null;
+    results: T[];
+}
+export declare function paginate<T>(model: Model<T>, options?: PaginationOptions): Promise<PaginationResult<T>>;
+export interface FilterOptions {
+    search?: string;
+    status?: string;
+    from?: string;
+    to?: string;
+    limit?: string;
+    page?: string;
+    sort_by?: string;
+    order?: "asc" | "desc";
+    merchantId?: string;
+    accountId?: string;
+    [key: string]: any;
+}
+export declare const generateQueryObject: (filters: FilterOptions, searchesFieldNames?: string[], select?: string | Record<string, any>, populate?: (string | PopulateOptions)[]) => {
+    page: number;
+    limit: number;
+    query: any;
+    sort: {
+        [key: string]: "asc" | "desc";
+    };
+    select: string | Record<string, any>;
+    populate: (string | PopulateOptions)[];
+};
+export interface DefaultFilterOptions {
+    search?: string;
+    page?: string;
+    limit?: string;
+    sort_by?: string;
+    order?: "asc" | "desc";
+    from?: string;
+    to?: string;
+}

package/build/helper/custom-paginate.js

@@ -0,0 +1,125 @@
+"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.generateQueryObject = exports.paginate = void 0;
+const date_processing_1 = require("./date-processing");
+function paginate(model, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const page = options.page || 1;
+        const limit = options.limit || 20;
+        const skip = (page - 1) * limit;
+        const query = options.query || {};
+        const sort = options.sort || {};
+        const select = options.select || "";
+        const populate = options.populate || "";
+        const keys = Object.keys(query);
+        let totalDocs;
+        if (keys.length > 0) {
+            totalDocs = yield model.countDocuments(query);
+        }
+        else {
+            totalDocs = yield model.estimatedDocumentCount();
+        }
+        const totalPages = Math.ceil(totalDocs / limit);
+        const queryBuilder = model.find(query).sort(sort);
+        if (select) {
+            queryBuilder.select(select);
+        }
+        // Populate specified fields
+        if (populate) {
+            queryBuilder.populate(populate);
+        }
+        const results = yield queryBuilder.skip(skip).limit(limit);
+        const hasNextPage = page < totalPages;
+        const hasPreviousPage = page > 1;
+        const paginationInfo = {
+            current_page: page,
+            total_page: totalPages,
+            total_docs: totalDocs,
+            has_next: hasNextPage,
+            has_previous: hasPreviousPage,
+            next_page: hasNextPage ? page + 1 : null,
+            previous_page: hasPreviousPage ? page - 1 : null,
+            results,
+        };
+        return paginationInfo;
+    });
+}
+exports.paginate = paginate;
+const generateQueryObject = (filters, searchesFieldNames = [], select = "", populate = []) => {
+    const { status, limit, page, sort_by = "createdAt", order = "desc", merchantId, accountId, } = filters;
+    const excludes = [
+        "status",
+        "from",
+        "page",
+        "to",
+        "limit",
+        "sort_by",
+        "search",
+        "accountId",
+        "merchantId",
+        "order",
+    ];
+    const query = {};
+    let sort = {};
+    const keys = Object.keys(filters);
+    for (const key of keys) {
+        if (!excludes.includes(key)) {
+            query[key] = filters[key];
+        }
+    }
+    if (filters.merchantId) {
+        query.merchantId = merchantId;
+    }
+    if (filters.accountId) {
+        query.accountId = accountId;
+    }
+    if (filters.search) {
+        const nameRegex = new RegExp(filters.search, "i");
+        const searchArray = [];
+        if (searchesFieldNames.length) {
+            for (const field of searchesFieldNames) {
+                searchArray.push({ [field]: nameRegex });
+            }
+        }
+        query.$or = searchArray;
+    }
+    if (filters.status) {
+        query.status = status;
+    }
+    if (filters.from && filters.to) {
+        const date = (0, date_processing_1.convertDateToUTCRange)(filters.from, filters.to);
+        query.createdAt = {
+            $gte: date.startUTC,
+            $lte: date.endUTC,
+        };
+    }
+    else if (filters.from) {
+        query.createdAt = {
+            $gte: (0, date_processing_1.convertDateToUTC)(filters.from),
+        };
+    }
+    if (filters.sort_by && filters.order) {
+        const newSory = {
+            [sort_by]: order === "asc" ? "asc" : "desc",
+        };
+        sort = Object.assign({}, newSory);
+    }
+    return {
+        page: parseInt(page, 10),
+        limit: parseInt(limit, 10),
+        query: query,
+        sort: sort,
+        select: select,
+        populate,
+    };
+};
+exports.generateQueryObject = generateQueryObject;

package/build/helper/date-processing.d.ts

@@ -0,0 +1,45 @@
+import { PLAN_INTERVAL } from "./plan-types";
+export declare const formatDate: (dataString: string | Date) => string;
+export declare const interswitchRefundDateFormat: (dataString: string) => string;
+export declare const formatDateTime: (dataString: string) => string;
+export declare const convertToDate: (date: string) => Date;
+export declare const getPreviousDayRange: () => {
+    startOfPreviousDay: Date;
+    endOfPreviousDay: Date;
+};
+export declare const getCurrentDayRange: () => {
+    startOfCurrentDay: Date;
+    endOfCurrentDay: Date;
+};
+export declare const getStartAndEndDate: (date: string | Date) => {
+    startOfDate: Date;
+    endOfDate: Date;
+};
+export declare const convertDateToUTCRangeString: (startDateTime: string, endDateTime: string) => {
+    startUTC: string;
+    endUTC: string;
+};
+export declare const convertDateToUTCRange: (startDateTime: string, endDateTime: string) => {
+    startUTC: Date;
+    endUTC: Date;
+};
+export declare const convertDateToUTCString: (startTime: string) => string;
+export declare const convertDateToUTC: (startTime: string) => Date;
+type PlanInterval = keyof typeof PLAN_INTERVAL;
+export declare const getDuration: (duration: PlanInterval) => number;
+export declare const getFutureDateFromPlan: (startDate: Date, duration: PlanInterval) => Date;
+export declare const calculateDelay: (targetDate: string | Date) => {
+    isValid: boolean;
+    message: string;
+    delay: number;
+};
+/**
+ * Determines if a refund can still be processed using the settlement ledger,
+ * based on the transaction's creation date (must be the same UTC day).
+ *
+ * @param transactionCreatedAt - Transaction createdAt timestamp (UTC string or Date)
+ * @param bufferInMinutes - Minimum time (in minutes) required before day ends
+ * @returns boolean - true if refund can still be processed from the settlement ledger
+ */
+export declare function canRefundFromSettlementLedgerByDay(transactionCreatedAt: string | Date, bufferInMinutes?: number): boolean;
+export {};

package/build/helper/date-processing.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canRefundFromSettlementLedgerByDay = exports.calculateDelay = exports.getFutureDateFromPlan = exports.getDuration = exports.convertDateToUTC = exports.convertDateToUTCString = exports.convertDateToUTCRange = exports.convertDateToUTCRangeString = exports.getStartAndEndDate = exports.getCurrentDayRange = exports.getPreviousDayRange = exports.convertToDate = exports.formatDateTime = exports.interswitchRefundDateFormat = exports.formatDate = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+// Extend dayjs with the UTC plugin
+dayjs_1.default.extend(utc_1.default);
+const plan_types_1 = require("./plan-types");
+const formatDate = (dataString) => {
+    return (0, dayjs_1.default)(dataString).format("YYYY-MM-DD");
+};
+exports.formatDate = formatDate;
+const interswitchRefundDateFormat = (dataString) => {
+    return (0, dayjs_1.default)(dataString).format("DD/MM/YYYY");
+};
+exports.interswitchRefundDateFormat = interswitchRefundDateFormat;
+const formatDateTime = (dataString) => {
+    return (0, dayjs_1.default)(dataString).format("YYYY-MM-DD HH:mm:ss");
+};
+exports.formatDateTime = formatDateTime;
+const convertToDate = (date) => {
+    return (0, dayjs_1.default)(date).toDate();
+};
+exports.convertToDate = convertToDate;
+const getPreviousDayRange = () => {
+    // Get the start of the previous day in UTC (00:00:00)
+    const startOfPreviousDay = dayjs_1.default
+        .utc()
+        .subtract(1, "day")
+        .startOf("day")
+        .toDate();
+    // Get the end of the previous day in UTC (23:59:59.999)
+    const endOfPreviousDay = dayjs_1.default.utc().subtract(1, "day").endOf("day").toDate();
+    return { startOfPreviousDay, endOfPreviousDay };
+};
+exports.getPreviousDayRange = getPreviousDayRange;
+const getCurrentDayRange = () => {
+    // Get the start of the previous day in UTC (00:00:00)
+    const startOfCurrentDay = dayjs_1.default.utc().startOf("day").toDate();
+    // Get the end of the previous day in UTC (23:59:59.999)
+    const endOfCurrentDay = dayjs_1.default.utc().endOf("day").toDate();
+    return { startOfCurrentDay, endOfCurrentDay };
+};
+exports.getCurrentDayRange = getCurrentDayRange;
+const getStartAndEndDate = (date) => {
+    const startTime = (0, dayjs_1.default)(`${date}`, "YYYY-MM-DD HH:mm");
+    // Get the start of day
+    const startOfDate = startTime.utc().startOf("day").toDate();
+    // Get the end of the previous day in UTC (23:59:59.999)
+    const endOfDate = startTime.utc().endOf("day").toDate();
+    return { startOfDate, endOfDate };
+};
+exports.getStartAndEndDate = getStartAndEndDate;
+const convertDateToUTCRangeString = (startDateTime, endDateTime) => {
+    // Get the start of the previous day in UTC (00:00:00)
+    const startTime = (0, dayjs_1.default)(`${startDateTime}`, "YYYY-MM-DD HH:mm");
+    const endTime = (0, dayjs_1.default)(`${endDateTime}`, "YYYY-MM-DD HH:mm");
+    const startUTC = startTime.utc().format();
+    const endUTC = endTime.utc().format();
+    return { startUTC, endUTC };
+};
+exports.convertDateToUTCRangeString = convertDateToUTCRangeString;
+const convertDateToUTCRange = (startDateTime, endDateTime) => {
+    // Get the start of the previous day in UTC (00:00:00)
+    const startTime = (0, dayjs_1.default)(`${startDateTime}`, "YYYY-MM-DD HH:mm");
+    const endTime = (0, dayjs_1.default)(`${endDateTime}`, "YYYY-MM-DD HH:mm");
+    const startUTC = startTime.utc().toDate();
+    const endUTC = endTime.utc().toDate();
+    return { startUTC, endUTC };
+};
+exports.convertDateToUTCRange = convertDateToUTCRange;
+const convertDateToUTCString = (startTime) => {
+    // Get the start of the previous day in UTC (00:00:00)
+    const date = (0, dayjs_1.default)(`${startTime}`, "YYYY-MM-DD HH:mm");
+    const DateInUTC = date.utc().format();
+    return DateInUTC;
+};
+exports.convertDateToUTCString = convertDateToUTCString;
+const convertDateToUTC = (startTime) => {
+    // Get the start of the previous day in UTC (00:00:00)
+    const date = (0, dayjs_1.default)(`${startTime}`, "YYYY-MM-DD HH:mm");
+    const DateInUTC = date.utc().toDate();
+    return DateInUTC;
+};
+exports.convertDateToUTC = convertDateToUTC;
+const getDuration = (duration) => {
+    const currentDate = (0, dayjs_1.default)();
+    switch (duration) {
+        case plan_types_1.PLAN_INTERVAL.HOURLY:
+            const newDurationHourly = currentDate.add(1, "hour").valueOf();
+            return newDurationHourly;
+        case plan_types_1.PLAN_INTERVAL.DAILY:
+            const newDurationDaily = currentDate.add(1, "day").valueOf();
+            return newDurationDaily;
+        case plan_types_1.PLAN_INTERVAL.WEEKLY:
+            const newDurationWeekly = currentDate.add(1, "week").valueOf();
+            return newDurationWeekly;
+        case plan_types_1.PLAN_INTERVAL.MONTHLY:
+            const newDurationMonthly = currentDate.add(1, "month").valueOf();
+            return newDurationMonthly;
+        case plan_types_1.PLAN_INTERVAL.QUARTERLY:
+            const newDurationQuarterly = currentDate.add(3, "month").valueOf();
+            return newDurationQuarterly;
+        case plan_types_1.PLAN_INTERVAL["6MONTHS"]:
+            const newDuration6Months = currentDate.add(6, "month").valueOf();
+            return newDuration6Months;
+        case plan_types_1.PLAN_INTERVAL.YEARLY:
+            const newDurationYearly = currentDate.add(1, "year").valueOf();
+            return newDurationYearly;
+        default:
+            throw new Error("Invalid duration");
+    }
+};
+exports.getDuration = getDuration;
+const getFutureDateFromPlan = (startDate, duration) => {
+    const currentDate = (0, dayjs_1.default)(startDate);
+    switch (duration) {
+        case plan_types_1.PLAN_INTERVAL.HOURLY:
+            return currentDate.add(1, "hour").toDate(); // Convert to Date object
+        case plan_types_1.PLAN_INTERVAL.DAILY:
+            return currentDate.add(1, "day").toDate();
+        case plan_types_1.PLAN_INTERVAL.WEEKLY:
+            return currentDate.add(1, "week").toDate();
+        case plan_types_1.PLAN_INTERVAL.MONTHLY:
+            return currentDate.add(1, "month").toDate();
+        case plan_types_1.PLAN_INTERVAL.QUARTERLY:
+            return currentDate.add(3, "month").toDate();
+        case plan_types_1.PLAN_INTERVAL["6MONTHS"]:
+            return currentDate.add(6, "month").toDate();
+        case plan_types_1.PLAN_INTERVAL.YEARLY:
+            return currentDate.add(1, "year").toDate();
+        default:
+            throw new Error("Invalid duration");
+    }
+};
+exports.getFutureDateFromPlan = getFutureDateFromPlan;
+const calculateDelay = (targetDate) => {
+    const targetDatetime = (0, dayjs_1.default)(targetDate).utc();
+    const now = (0, dayjs_1.default)().utc();
+    if (!targetDatetime.isValid()) {
+        return {
+            isValid: false,
+            message: "Invalid date format. Please provide a valid date.",
+            delay: 0,
+        };
+    }
+    const delay = targetDatetime.diff(now, "millisecond"); // Calculate delay in ms
+    const MIN_DELAY = 10 * 60 * 1000; // 10 minutes in milliseconds
+    if (delay < MIN_DELAY) {
+        return {
+            isValid: false,
+            delay: 0,
+            message: "The target date must be at least 10 minutes in the future.",
+        };
+    }
+    return {
+        isValid: true,
+        message: "valid date in the future",
+        delay: delay,
+    };
+};
+exports.calculateDelay = calculateDelay;
+/**
+ * Determines if a refund can still be processed using the settlement ledger,
+ * based on the transaction's creation date (must be the same UTC day).
+ *
+ * @param transactionCreatedAt - Transaction createdAt timestamp (UTC string or Date)
+ * @param bufferInMinutes - Minimum time (in minutes) required before day ends
+ * @returns boolean - true if refund can still be processed from the settlement ledger
+ */
+function canRefundFromSettlementLedgerByDay(transactionCreatedAt, bufferInMinutes = 60) {
+    const now = dayjs_1.default.utc();
+    const txnDay = dayjs_1.default.utc(transactionCreatedAt).startOf("day");
+    const nextDay = txnDay.add(1, "day");
+    const cutoffTime = nextDay.subtract(bufferInMinutes, "minute");
+    // You can refund if:
+    // 1. It’s still the same UTC day as transaction's createdAt
+    // 2. There’s still enough buffer time before the new day starts
+    return now.isBefore(cutoffTime);
+}
+exports.canRefundFromSettlementLedgerByDay = canRefundFromSettlementLedgerByDay;

package/build/helper/default-charges-types.js

@@ -0,0 +1 @@
+"use strict";

package/build/helper/disputes.d.ts

@@ -0,0 +1,15 @@
+export declare enum DISPUTE_STATUS {
+    ACCEPTED = "ACCEPTED",
+    DECLINED = "DECLINED",
+    WON = "WON",
+    LOST = "LOST",
+    PENDING = "PENDING",
+    UNDER_REVIEW = "UNDER_REVIEW"
+}
+export declare enum DisputeReasonCode {
+    FRAUD = "10.4",
+    NON_DELIVERED = "13.1",
+    DUPLICATE = "12.6",
+    NOT_AUTHORIZED = "10.5",
+    OTHER = "other"
+}

package/build/helper/disputes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisputeReasonCode = exports.DISPUTE_STATUS = void 0;
+var DISPUTE_STATUS;
+(function (DISPUTE_STATUS) {
+    DISPUTE_STATUS["ACCEPTED"] = "ACCEPTED";
+    DISPUTE_STATUS["DECLINED"] = "DECLINED";
+    DISPUTE_STATUS["WON"] = "WON";
+    DISPUTE_STATUS["LOST"] = "LOST";
+    DISPUTE_STATUS["PENDING"] = "PENDING";
+    DISPUTE_STATUS["UNDER_REVIEW"] = "UNDER_REVIEW";
+})(DISPUTE_STATUS = exports.DISPUTE_STATUS || (exports.DISPUTE_STATUS = {}));
+var DisputeReasonCode;
+(function (DisputeReasonCode) {
+    DisputeReasonCode["FRAUD"] = "10.4";
+    DisputeReasonCode["NON_DELIVERED"] = "13.1";
+    DisputeReasonCode["DUPLICATE"] = "12.6";
+    DisputeReasonCode["NOT_AUTHORIZED"] = "10.5";
+    DisputeReasonCode["OTHER"] = "other";
+})(DisputeReasonCode = exports.DisputeReasonCode || (exports.DisputeReasonCode = {}));

package/build/helper/encryptions.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+/**
+ * this is how the aes key and iv should be generated
+ *
+ * @returns
+ */
+export declare const generateAesKeyAndIv: () => {
+    aesKey: Buffer;
+    iv: Buffer;
+};
+/**
+ *
+ * @param data the data as string to be encrypted use JSON.stringify on objects
+ * @param aesKey
+ * @param iv
+ * @returns base 64 of the iv and encrypted data in iv:data
+ */
+export declare const encryptWithAes: (data: string, aesKey: Buffer, iv: Buffer) => string;
+/**
+ *
+ * @param aesKey  the key generated  for encryption
+ * @param publicKey  the public key shared will always be on the validation payload
+ * @returns
+ */
+export declare const encryptWithRsaPublicKey: (aesKey: Buffer, publicKey: string) => string;
+/**
+ *
+ * @param encryptedAesKey the encrypted Aes key to be decrypted by the private key for transaction processing
+ * @param privateKey the secured save private key
+ * @returns
+ */
+export declare const decryptWithRsaPrivateKey: (encryptedAesKey: string, privateKey: string) => Buffer;
+/**
+ *
+ * @param encryptedDataWithIv the encrypted data that was encrypted in the format iv:data
+ * @param aesKey the AES key as Buffer obtain from the decryption of the data
+ * @returns return data as string
+ */
+export declare const decryptWithAes: (encryptedDataWithIv: string, aesKey: Buffer) => string;
+/**
+ *
+ * @param data data to be encrpted as string
+ * @param publicKey  the RSA public key
+ * @returns
+ */
+export declare const hybridEncrypt: (data: string, publicKey: string) => {
+    encryptedData: string;
+    encryptedAesKey: string;
+    iv: string;
+};
+/**
+ *
+ * @param encryptedData  the encrypted data as a strig
+ * @param encryptedAesKey  the encrypted AESKey data as string
+ * @param privateKey the private key of the RSA
+ * @returns  string
+ */
+export declare const hybridDecrypt: (encryptedData: string, encryptedAesKey: string, privateKey: string) => string;