@houlak/plexo-sdk 0.1.0

package/lib/sdk/helpers/signature/signatureHelper.js

@@ -0,0 +1,305 @@
+"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());
+    });
+};
+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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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.SignatureHelper = exports.canonizeJson = void 0;
+var axios_1 = require("axios");
+var fs = require("fs");
+var pem = require("pem");
+var crypto_1 = require("crypto");
+var js_convert_case_1 = require("js-convert-case");
+var util_1 = require("util");
+var logger_lib_1 = require("../../../lib/logger.lib");
+var config_1 = require("../../../config/config");
+var __1 = require("../..");
+var stringifyWithFloats_1 = require("./stringifyWithFloats");
+var client = axios_1.default.create({
+    baseURL: config_1.config.plexoUrl,
+});
+var specialWords = [
+    { word: 'UtcUnixTimeExpiration', substitute: 'UTCUnixTimeExpiration' },
+    { word: 'VatAmount', substitute: 'VATAmount' },
+];
+var canonizeJson = function (object) {
+    var cleanObject = deleteObjectUndefined(object);
+    return sort(cleanObject);
+};
+exports.canonizeJson = canonizeJson;
+var toCamelKeys = function (object) {
+    var parsedObject = (0, js_convert_case_1.camelKeys)(object, { recursive: true, recursiveInArray: true });
+    return parsedObject;
+};
+function substituteWordRecursively(theParsedObject, word, substitute) {
+    var deleteObject = function (obj, key) {
+        delete obj[key];
+    };
+    if (typeof theParsedObject === 'object') {
+        Object.keys(theParsedObject).map(function (key) {
+            if (key === word) {
+                Object.defineProperty(theParsedObject, substitute, Object.getOwnPropertyDescriptor(theParsedObject, word) || '');
+                deleteObject(theParsedObject, word);
+            }
+            if (typeof theParsedObject[key] === 'object') {
+                substituteWordRecursively(theParsedObject[key], word, substitute);
+            }
+        });
+    }
+}
+var toPascalKeys = function (object) {
+    var parsedObject = (0, js_convert_case_1.pascalKeys)(object, { recursive: true, recursiveInArray: true });
+    specialWords.forEach(function (specialWord) {
+        if (JSON.stringify(parsedObject).includes(specialWord.word)) {
+            substituteWordRecursively(parsedObject, specialWord.word, specialWord.substitute);
+        }
+    });
+    return parsedObject;
+};
+var sort = function (object) {
+    if (Array.isArray(object)) {
+        var newArray_1 = [];
+        object.map(function (item) { return newArray_1.push(sort(item)); });
+        return newArray_1;
+    }
+    if (typeof object === 'object') {
+        var newObject_1 = {};
+        Object.keys(object)
+            .sort()
+            .map(function (key) { return (newObject_1[key] = sort(object[key])); });
+        return newObject_1;
+    }
+    return object;
+};
+// TODO:
+// const parseDateToISO = (object: any) => {}
+var deleteObjectUndefined = function (object) {
+    if (Array.isArray(object)) {
+        object = object
+            .filter(function (item) { return item !== undefined || !item.length; })
+            .map(function (item) {
+            return typeof item === 'object' || Array.isArray(item) ? deleteObjectUndefined(item) : null;
+        });
+        return;
+    }
+    if (typeof object === 'object') {
+        Object.keys(object).map(function (key) {
+            if (typeof object[key] === 'object') {
+                if (Object.entries(object[key]).length === 0) {
+                    delete object[key];
+                }
+                deleteObjectUndefined(object[key]);
+            }
+            if ((!object[key] && object[key] !== 0 && typeof object[key] !== 'boolean') ||
+                (!object[key].length && Array.isArray(object[key]))) {
+                delete object[key];
+                return;
+            }
+            if (Array.isArray(object[key]) && object[key].length) {
+                deleteObjectUndefined(object[key]);
+            }
+        });
+    }
+    return object;
+};
+var getFingerprint = function (content, algorithm, inputEncoding, outputEncoding) {
+    if (algorithm === void 0) { algorithm = 'sha1'; }
+    if (inputEncoding === void 0) { inputEncoding = 'utf8'; }
+    if (outputEncoding === void 0) { outputEncoding = 'base64'; }
+    var shaSum = (0, crypto_1.createHash)(algorithm);
+    shaSum.update(content, inputEncoding);
+    var res = shaSum.digest(outputEncoding);
+    return res;
+};
+var getCertificate = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var pathPfx, pfx, certs;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                pathPfx = config_1.config.plexoClient.certificatePath;
+                pfx = fs.readFileSync(pathPfx);
+                return [4 /*yield*/, new Promise(function (resolve, reject) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, pem.readPkcs12(pfx, { p12Password: config_1.config.plexoClient.certificatePassword }, function (_err, cert) { return __awaiter(void 0, void 0, void 0, function () {
+                                        var privateKey, stringifiedCert;
+                                        return __generator(this, function (_a) {
+                                            privateKey = cert.key;
+                                            stringifiedCert = cert.cert;
+                                            resolve({ privateKey: privateKey, cert: stringifiedCert });
+                                            return [2 /*return*/];
+                                        });
+                                    }); })];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+            case 1:
+                certs = _a.sent();
+                return [2 /*return*/, certs];
+        }
+    });
+}); };
+var generateSignature = function (object, privateKey) {
+    var canonizedString = (0, stringifyWithFloats_1.stringifyAmountsWithFloats)(object);
+    logger_lib_1.default.debug('STRING TO SIGN --> ' + canonizedString);
+    var canonizedStringEncoded = new util_1.TextEncoder().encode(canonizedString);
+    var signKey = (0, crypto_1.sign)('SHA512', canonizedStringEncoded, privateKey).toString('base64');
+    return signKey;
+};
+var getSignatureFromPlexo = function (objectToSign) { return __awaiter(void 0, void 0, void 0, function () {
+    var cert, privateKey, stringifiedCert, signedObject, thumbnail, canonizedObject, objectoToPascalKeys, signKey;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getCertificate()];
+            case 1:
+                cert = _a.sent();
+                logger_lib_1.default.debug({ cert: cert });
+                privateKey = cert.privateKey;
+                stringifiedCert = cert.cert
+                    .toString()
+                    .split('\n')
+                    .filter(function (line) { return !line.includes('-----'); })
+                    .map(function (line) { return line.trim(); })
+                    .join('');
+                signedObject = {
+                    object: objectToSign,
+                    signature: '',
+                };
+                thumbnail = getFingerprint(stringifiedCert, 'sha1', 'base64', 'hex').toUpperCase();
+                objectToSign.fingerprint = thumbnail;
+                canonizedObject = (0, exports.canonizeJson)(objectToSign);
+                objectoToPascalKeys = toPascalKeys(canonizedObject);
+                signKey = generateSignature(objectoToPascalKeys, privateKey);
+                signedObject.signature = signKey;
+                signedObject.object = canonizedObject;
+                return [2 /*return*/, signedObject];
+        }
+    });
+}); };
+var getSignatureFromCallback = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var object, stateObject, objectSignature, serverResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                object = {
+                    client: response.response.client,
+                    request: response,
+                };
+                stateObject = {
+                    fingerprint: '',
+                    utcUnixTimeExpiration: Date.parse(new Date().toString()),
+                    object: object,
+                };
+                return [4 /*yield*/, getSignatureFromPlexo(stateObject)];
+            case 1:
+                objectSignature = _a.sent();
+                serverResponse = {
+                    response: {
+                        object: {
+                            object: {
+                                client: objectSignature.object.object.client,
+                                resultCode: response.resultCode,
+                            },
+                            fingerprint: objectSignature.object.fingerprint,
+                            utcUnixTimeExpiration: objectSignature.object.utcUnixTimeExpiration,
+                        },
+                        signature: objectSignature.signature,
+                    },
+                    resultCode: response.resultCode,
+                    errorMessage: response.errorMessage,
+                    i18ErrorMessages: response.i18ErrorMessages,
+                };
+                return [2 /*return*/, serverResponse];
+        }
+    });
+}); };
+var getPlexoKey = function (fingerprint) { return __awaiter(void 0, void 0, void 0, function () {
+    var plexoResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, client.get("/Key/".concat(fingerprint))];
+            case 1:
+                plexoResponse = _a.sent();
+                if (plexoResponse.status !== 200) {
+                    throw new Error("Invalid or outdated Fingerprint, server returns: ".concat(plexoResponse.data.Object.Object.ErrorMessage));
+                }
+                return [2 /*return*/, plexoResponse.data];
+        }
+    });
+}); };
+var getPlexoSignature = function (fingerprint, response) { return __awaiter(void 0, void 0, void 0, function () {
+    var serverResponse, plexoResponse, err_1, key, objectBuffer, verifySignature;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, getPlexoKey(fingerprint)];
+            case 1:
+                plexoResponse = _a.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                err_1 = _a.sent();
+                logger_lib_1.default.error({ err: err_1 }, 'Error getting plexo certificate');
+                serverResponse = {
+                    response: response.object.object,
+                    resultCode: __1.ResultCodes.InvalidFingerprint,
+                    errorMessage: err_1,
+                };
+                return [2 /*return*/, serverResponse];
+            case 3:
+                key = "-----BEGIN CERTIFICATE-----\n".concat(plexoResponse.Object.Object.Response.Key, "\n-----END CERTIFICATE-----");
+                objectBuffer = new util_1.TextEncoder().encode((0, stringifyWithFloats_1.stringifyAmountsWithFloats)(response.object));
+                verifySignature = (0, crypto_1.createVerify)('SHA512')
+                    .update(objectBuffer)
+                    .verify(key, response.signature, 'base64');
+                serverResponse = {
+                    response: response.object.object,
+                    resultCode: verifySignature ? __1.ResultCodes.Ok : __1.ResultCodes.InvalidSignature,
+                    errorMessage: verifySignature ? "Signature do not match" : 'Success',
+                };
+                return [2 /*return*/, serverResponse];
+        }
+    });
+}); };
+exports.SignatureHelper = {
+    getCertificate: getCertificate,
+    getSignatureFromPlexo: getSignatureFromPlexo,
+    getSignatureFromCallback: getSignatureFromCallback,
+    getPlexoSignature: getPlexoSignature,
+    toCamelKeys: toCamelKeys,
+};

package/lib/sdk/helpers/signature/stringifyWithFloats.d.ts

@@ -0,0 +1 @@
+export declare const stringifyAmountsWithFloats: (object: any) => string;

package/lib/sdk/helpers/signature/stringifyWithFloats.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyAmountsWithFloats = void 0;
+var beginFloat = '~begin~float~';
+var endFloat = '~end~float~';
+var decimalCount = function (numberValue) {
+    var numberToString = String(numberValue);
+    if (numberToString.includes('.')) {
+        return numberToString.split('.')[1].length;
+    }
+    return 0;
+};
+var stringifyWithFloats = function (config, decimals) {
+    if (config === void 0) { config = {}; }
+    if (decimals === void 0) { decimals = 1; }
+    return function (inputValue, inputReplacer, space) {
+        var inputReplacerIsFunction = typeof inputReplacer === 'function';
+        var isFirstIteration = true;
+        var jsonReplacer = function (key, val) {
+            if (isFirstIteration) {
+                isFirstIteration = false;
+                return inputReplacerIsFunction ? inputReplacer(key, val) : val;
+            }
+            var value;
+            if (inputReplacerIsFunction) {
+                value = inputReplacer(key, val);
+            }
+            else if (Array.isArray(inputReplacer)) {
+                // remove the property if it is not included in the inputReplacer array
+                value = inputReplacer.indexOf(key) !== -1 ? val : undefined;
+            }
+            else {
+                value = val;
+            }
+            var forceFloat = config[key] === 'float' &&
+                (value || value === 0) &&
+                typeof value === 'number' &&
+                !value.toString().toLowerCase().includes('e') &&
+                decimalCount(value) < 2;
+            return forceFloat ? "".concat(beginFloat).concat(value).concat(endFloat) : value;
+        };
+        var json = JSON.stringify(inputValue, jsonReplacer, space);
+        var regexReplacer = function (match, num) {
+            return num.includes('.') || Number.isNaN(num)
+                ? Number.isNaN(num)
+                    ? num
+                    : Number(num).toFixed(decimals)
+                : "".concat(num, ".").concat('0'.repeat(decimals));
+        };
+        var re = new RegExp("\"".concat(beginFloat, "(.+?)").concat(endFloat, "\""), 'g');
+        return json.replace(re, regexReplacer);
+    };
+};
+// We are adding this method because we need to replace round numbers for
+// float numbers when generating signature to send to Plexo.
+// By using this, when we have for example Amount: 100, we replace that for Amount: 100.0.
+// If we send just 100, Plexo doesn't like that and we receive a
+// "signature does not match" error message
+var stringifyAmountsWithFloats = function (object) {
+    return stringifyWithFloats({
+        amount: 'float',
+        billedAmount: 'float',
+        taxedAmount: 'float',
+        vatAmount: 'float',
+        Amount: 'float',
+        BilledAmount: 'float',
+        TaxedAmount: 'float',
+        VATAmount: 'float',
+    }, 1)(object, null, 0);
+};
+exports.stringifyAmountsWithFloats = stringifyAmountsWithFloats;

package/lib/sdk/index.d.ts

@@ -0,0 +1,4 @@
+export * from './models/IndexSDK';
+export { IPaymentGatewayClient } from './IPaymentGatewayClient';
+export { PaymentGatewayClient } from './PaymentGatewayClient';
+export { SignatureHelper } from './helpers/signature/signatureHelper';

package/lib/sdk/index.js

@@ -0,0 +1,22 @@
+"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.SignatureHelper = exports.PaymentGatewayClient = void 0;
+__exportStar(require("./models/IndexSDK"), exports);
+var PaymentGatewayClient_1 = require("./PaymentGatewayClient");
+Object.defineProperty(exports, "PaymentGatewayClient", { enumerable: true, get: function () { return PaymentGatewayClient_1.PaymentGatewayClient; } });
+var signatureHelper_1 = require("./helpers/signature/signatureHelper");
+Object.defineProperty(exports, "SignatureHelper", { enumerable: true, get: function () { return signatureHelper_1.SignatureHelper; } });

package/lib/sdk/mocks/mocks.d.ts

@@ -0,0 +1,24 @@
+import { PaymentCode } from '../models/CodeAction';
+import { ClientSignedResponse, Commerce, InstrumentCallback, IssuerData, IssuerInfo, IssuerProcessor, PaymentInstrument, Session, Transaction, TransactionCallback, TransactionCursor, AmountLimit, Currency, FieldInfo, FieldInfoPaymentProcessors, FinancialInclusionResult, PaymentProcessor, TimeLimit, TransactionInfo } from '../models/IndexSDK';
+export declare const mocks: {
+    currencyMock: Currency;
+    amountLimitMock: AmountLimit;
+    timeLimitMock: TimeLimit;
+    fieldMock: FieldInfo;
+    issuerMock: IssuerInfo;
+    paymentInstrumentMock: PaymentInstrument;
+    financialInclusionMock: FinancialInclusionResult;
+    transactionInfoMock: TransactionInfo;
+    commerceMock: Commerce;
+    paymentCodeMock: PaymentCode;
+    issuerDataMock: IssuerData;
+    sessionMock: Session;
+    transactionMock: Transaction;
+    transactionCursorMock: TransactionCursor;
+    fieldInfoPaymentProcessorMock: FieldInfoPaymentProcessors;
+    paymentProcessorMock: PaymentProcessor;
+    issuerProcessorMock: IssuerProcessor;
+    clientSignedResponseMock: ClientSignedResponse;
+    transactionCallbackMock: TransactionCallback;
+    instrumentCallbackMock: InstrumentCallback;
+};

package/lib/sdk/mocks/mocks.js

@@ -0,0 +1,180 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mocks = void 0;
+var crypto_1 = require("crypto");
+var IndexSDK_1 = require("../models/IndexSDK");
+var currencyMock = {
+    currencyId: 1,
+    name: 'USD',
+    plural: 'USD',
+    symbol: 'USD',
+};
+var amountLimitMock = {
+    currency: currencyMock,
+    amount: 100,
+    extendedAmount: 121,
+    supportsExtendedLimit: true,
+};
+var timeLimitMock = {
+    secondsLeft: 120,
+    requirementAfterTimeLimit: IndexSDK_1.FieldType.CVC,
+};
+var fieldMock = {
+    fieldType: IndexSDK_1.FieldType.TerminalNumber,
+    labelName: 'TerminalMock',
+    required: true,
+};
+var issuerMock = {
+    id: 'id',
+    issuerId: 4,
+    variationId: 4,
+    issuer: 'MasterMock',
+    bank: 'MasterBankMock',
+    variation: '',
+    imageUrl: '',
+    mayHaveAsyncPayments: false,
+    supportsReserve: false,
+    mayHavePaymentsLimits: false,
+    fields: [fieldMock],
+};
+var paymentInstrumentMock = {
+    instrumentToken: 'token',
+    name: 'mockedInstrument',
+    issuer: issuerMock,
+    supportedCurrencies: [currencyMock],
+    status: IndexSDK_1.CardStatus.Ok,
+    instrumentExpirationUTC: 1919276061,
+    creditLimits: [amountLimitMock],
+    additionalRequirements: [timeLimitMock],
+    instrumentInformation: null,
+    sessionCreationId: 'MockedId',
+};
+var financialInclusionMock = {
+    isApplied: true,
+    returnAmount: 100,
+    lawNumber: IndexSDK_1.InclusionType.Law17934,
+};
+var transactionInfoMock = {
+    clientReferenceId: (0, crypto_1.randomUUID)(),
+    clientMetadata: 'metadata',
+    status: IndexSDK_1.TransactionResult.Ok,
+    transactionCode: 1900,
+    transactionResultText: 'OK',
+    executionDateUTC: 1919276061,
+    authorization: 'AuthorizationMock',
+    ticket: 'TicketMock',
+};
+var commerceMock = {
+    commerceId: 1891,
+    name: 'PlexoMock',
+};
+var paymentCodeMock = {
+    code: 'CodeMock',
+    url: 'https://UrlMock.com',
+};
+var issuerDataMock = {
+    commerceId: 1891,
+    issuerId: 4,
+    metadata: {
+        providerCommerceNumber: '12345',
+        terminalNumber: '12345',
+    },
+};
+var sessionMock = {
+    id: 'SessionIdMock',
+    uri: 'http://mockland.com',
+    expirationUTC: 1919276061,
+};
+var transactionMock = {
+    transactionId: (0, crypto_1.randomUUID)(),
+    commerce: commerceMock,
+    instrumentToken: 'Token',
+    instrumentName: 'MasterMock',
+    issuer: issuerMock,
+    amount: 100,
+    installments: 1,
+    currency: currencyMock,
+    isAnonymous: true,
+    currentState: IndexSDK_1.TransactionType.Purchase,
+    invoiceNumber: '1',
+    financialInclusion: financialInclusionMock,
+    transactions: {
+        purchase: transactionInfoMock,
+        reserve: transactionInfoMock,
+        cancel: transactionInfoMock,
+    },
+    fieldInformation: [],
+    isAsyncPayment: false,
+    paymentCode: paymentCodeMock,
+    utcUnixTimeExpiration: 1919276061,
+};
+var transactionCursorMock = {
+    start: 0,
+    totalCount: 100,
+    transactions: [transactionMock],
+};
+var fieldInfoPaymentProcessorMock = {
+    name: 'PaymentProcessorFieldInfoMock',
+    type: IndexSDK_1.FieldType.AvailableBanks,
+};
+var paymentProcessorMock = {
+    acquirer: 'FiservMock',
+    fields: [fieldInfoPaymentProcessorMock],
+};
+var issuerProcessorMock = {
+    issuerId: 4,
+    name: 'MasterMock',
+    paymentProcessors: [paymentProcessorMock],
+};
+var clientSignedResponseMock = {
+    signature: 'signature',
+    object: {
+        fingerprint: 'fingerprint',
+        utcUnixTimeExpiration: 1919276061,
+        object: {
+            client: 'PlexoMock',
+            resultCode: IndexSDK_1.ResultCodes.Ok,
+        },
+    },
+};
+var transactionCallbackMock = __assign(__assign({}, transactionMock), { client: 'PlexoMock' });
+var instrumentCallbackMock = {
+    action: IndexSDK_1.ActionType.RegisterInstrument,
+    client: 'PlexoMock',
+    sessionId: (0, crypto_1.randomUUID)(),
+    optionalMetadata: 'metadata',
+    paymentInstrument: paymentInstrumentMock,
+};
+exports.mocks = {
+    currencyMock: currencyMock,
+    amountLimitMock: amountLimitMock,
+    timeLimitMock: timeLimitMock,
+    fieldMock: fieldMock,
+    issuerMock: issuerMock,
+    paymentInstrumentMock: paymentInstrumentMock,
+    financialInclusionMock: financialInclusionMock,
+    transactionInfoMock: transactionInfoMock,
+    commerceMock: commerceMock,
+    paymentCodeMock: paymentCodeMock,
+    issuerDataMock: issuerDataMock,
+    sessionMock: sessionMock,
+    transactionMock: transactionMock,
+    transactionCursorMock: transactionCursorMock,
+    fieldInfoPaymentProcessorMock: fieldInfoPaymentProcessorMock,
+    paymentProcessorMock: paymentProcessorMock,
+    issuerProcessorMock: issuerProcessorMock,
+    clientSignedResponseMock: clientSignedResponseMock,
+    transactionCallbackMock: transactionCallbackMock,
+    instrumentCallbackMock: instrumentCallbackMock,
+};

package/lib/sdk/models/ActionType.d.ts

@@ -0,0 +1,9 @@
+export declare enum ActionType {
+    SelectInstrument = 1,
+    RegisterInstrument = 2,
+    DeleteInstrument = 4,
+    SessionExtendAmount = 8,
+    ClientExtendAmount = 16,
+    AskForTemporaryItems = 32,
+    ExpressCheckout = 64
+}

package/lib/sdk/models/ActionType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionType = void 0;
+var ActionType;
+(function (ActionType) {
+    ActionType[ActionType["SelectInstrument"] = 1] = "SelectInstrument";
+    ActionType[ActionType["RegisterInstrument"] = 2] = "RegisterInstrument";
+    ActionType[ActionType["DeleteInstrument"] = 4] = "DeleteInstrument";
+    ActionType[ActionType["SessionExtendAmount"] = 8] = "SessionExtendAmount";
+    ActionType[ActionType["ClientExtendAmount"] = 16] = "ClientExtendAmount";
+    ActionType[ActionType["AskForTemporaryItems"] = 32] = "AskForTemporaryItems";
+    ActionType[ActionType["ExpressCheckout"] = 64] = "ExpressCheckout";
+})(ActionType = exports.ActionType || (exports.ActionType = {}));

package/lib/sdk/models/AmountLimit.d.ts

@@ -0,0 +1,7 @@
+import { Currency } from './Currency';
+export declare type AmountLimit = {
+    amount: number;
+    extendedAmount: number;
+    currency: Currency;
+    supportsExtendedLimit: boolean;
+};

package/lib/sdk/models/AmountLimit.js

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

package/lib/sdk/models/Authorization.d.ts

@@ -0,0 +1,18 @@
+import { ESMap } from 'typescript';
+import { AuthorizationType } from '..';
+import { ActionType } from './ActionType';
+import { AuthorizationInfo } from './AuthorizationInfo';
+import { WebFormSettingsDto } from './WebFormSettingsDto';
+export declare class Authorization extends AuthorizationInfo {
+    action: ActionType;
+    redirectUri: string;
+    limitIssuers: string[];
+    optionalCommerceId: number;
+    doNotUseCallback?: boolean;
+    clientInformation?: any;
+    optionalMetadata?: string;
+    promotionInfoIssuers?: ESMap<string, string>;
+    extendableInstrumentToken?: string;
+    webFormSettings?: WebFormSettingsDto;
+    constructor(action: ActionType, redirectUri: string, limitIssuers: string[], optionalCommerceId: number, type: AuthorizationType, metaReference: string);
+}