redsys-easy 3.1.0 → 4.0.2

package/lib/index.esm.js

@@ -1,42 +1,13 @@
+import { STATUS_CODES } from 'http';
 import base64url from 'base64url';
-import xmlParser, { j2xParser } from 'fast-xml-parser';
-import { createClientAsync } from 'soap';
 import crypto from 'crypto';
+import { XMLParser } from 'fast-xml-parser';
+import fetch from 'node-fetch';
+import Decimal from 'decimal.js';
 import dayjs from 'dayjs';
 import timezone from 'dayjs/plugin/timezone';
 import utc from 'dayjs/plugin/utc';
 
-class RedsysError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'RedsysError';
-    }
-}
-class ValidationError extends RedsysError {
-    constructor(message, value, field) {
-        super(message);
-        this.name = 'RedsysValidationError';
-        this.value = value;
-        this.field = field;
-    }
-}
-class ParseError extends RedsysError {
-    constructor(message, value, text) {
-        super(message);
-        this.name = 'RedsysParseError';
-        this.value = value;
-        this.text = text;
-    }
-}
-class GatewayError extends RedsysError {
-    constructor(message, code, response) {
-        super(message);
-        this.name = 'RedsysParseError';
-        this.code = code;
-        this.response = response;
-    }
-}
-
 const ALL_ERRORS = [
     { code: 9001, sisCode: 'SIS0001', text: 'Error Interno' },
     { code: 9002, sisCode: 'SIS0002', text: 'Error genérico' },
@@ -490,24 +461,151 @@ const RESPONSE_CODES = {
     900: 'Transacción autorizada para devoluciones y confirmaciones.'
 };
 
-const TRANSACTION_TYPES = {
-    AUTHORIZATION: '0',
-    PRE_AUTHORIZATION: '1',
-    CONFIRMATION: '2',
-    AUTO_REFUND: '3',
-    RECURRING_TRANSACTION: '5',
-    SUCCESSIVE_TRANSACTION: '6',
-    PRE_AUTHENTICATION: '7',
-    PRE_AUTHENTICATION_CONFIRMATION: '8',
-    PRE_AUTHORIZATION_CANCEL: '9',
-    DEFERRED_AUTHORIZATION: 'O',
-    PAYLINK: 'F',
-    DEFERRED_AUTHORIZATION_CONFIRMATION: 'P',
-    DEFERRED_AUTHORIZATION_CANCEL: 'Q',
-    DEFERRED_INITIAL_FEE: 'R',
-    DEFERRED_SUCCESSIVE_FEE: 'S',
-    NO_AUTHENTICATION: 'A',
-    DELETE_REFERENCE: '44' // Eliminar referencia
+/**
+ * Returns the message corresponding to a response code, in spanish
+ *
+ * @public
+ */
+const getResponseCodeMessage = (code) => {
+    if (typeof code !== 'number' && typeof code !== 'string') {
+        return;
+    }
+    const lookupNum = typeof code === 'string' ? Number.parseFloat(code.trim()) : code;
+    if (!Number.isInteger(lookupNum) || lookupNum < 0) {
+        return;
+    }
+    const msg = RESPONSE_CODES[lookupNum.toString()];
+    if ((msg == null || !msg) && lookupNum < 100) {
+        return 'Transacción autorizada para pagos y preautorizaciones';
+    }
+    return msg;
+};
+/**
+ * Returns the message corresponding to a gateway error code
+ *
+ * @public
+ */
+const getSISErrorCodeMessage = (code) => {
+    if (!code || typeof code !== 'string') {
+        return undefined;
+    }
+    return SIS_ERROR_CODES[code.trim()];
+};
+const getHTTPErrorCodeMessage = (code) => {
+    return STATUS_CODES[code];
+};
+
+/**
+ * Error superclass for all redsys-easy specific errors
+ *
+ * @public
+ */
+class RedsysError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RedsysError';
+    }
+}
+/**
+ * Invalid input provided
+ *
+ * @public
+ */
+class ValidationError extends RedsysError {
+    constructor(message, parameters) {
+        super(message);
+        this.name = 'RedsysValidationError';
+        this.parameters = parameters;
+    }
+}
+/**
+ * Response cannot be parsed
+ *
+ * @public
+ */
+class ParseError extends RedsysError {
+    constructor(message, value, location) {
+        super(message);
+        this.name = 'RedsysParseError';
+        this.value = value;
+        this.location = location;
+    }
+}
+/**
+ * HTTP Error
+ *
+ * @public
+ */
+class HTTPError extends RedsysError {
+    constructor({ message, code, response }) {
+        const codeDescription = getHTTPErrorCodeMessage(code);
+        const codeInfo = code !== undefined
+            ? ` ${code}${codeDescription != null ? `: ${codeDescription}` : ''}`
+            : '';
+        const augmentationLine = message != null && message ? `\n${message}` : '';
+        const augmentedMessage = `HTTP error${codeInfo}${augmentationLine}`;
+        super(augmentedMessage);
+        this.name = 'RedsysHTTPError';
+        this.code = code;
+        this.response = response;
+    }
+}
+/**
+ * Request could not be processed by Redsys
+ *
+ * @public
+ */
+class GatewayError extends RedsysError {
+    constructor({ message, code, response }) {
+        const codeDescription = getSISErrorCodeMessage(code);
+        const codeInfo = code !== undefined
+            ? ` ${code}${codeDescription != null ? `: ${codeDescription}` : ''}`
+            : '';
+        const augmentationLine = message != null && message ? `\n${message}` : '';
+        const augmentedMessage = `Gateway error${codeInfo}${augmentationLine}`;
+        super(augmentedMessage);
+        this.name = 'RedsysGatewayError';
+        this.code = code;
+        this.response = response;
+    }
+}
+/**
+ * Response contained an error code
+ *
+ * @public
+ */
+class ResponseError extends RedsysError {
+    constructor({ message, code, response }) {
+        const codeDescription = getResponseCodeMessage(code);
+        const codeInfo = code !== undefined
+            ? ` ${code}${codeDescription != null ? `: ${codeDescription}` : ''}`
+            : '';
+        const augmentationLine = message != null && message ? `\n${message}` : '';
+        const augmentedMessage = `Response error${codeInfo}${augmentationLine}`;
+        super(augmentedMessage);
+        this.name = 'RedsysResponseError';
+        this.code = code;
+        this.response = response;
+    }
+}
+
+const deserializeJSONMerchantParams = (strPayload) => {
+    if (!strPayload) {
+        throw new ParseError('Payload is empty');
+    }
+    if (typeof strPayload !== 'string') {
+        throw new ParseError('Payload must be a base-64 encoded string');
+    }
+    const payload = JSON.parse(decodeURIComponent(Buffer.from(strPayload, 'base64').toString('utf8')));
+    if (typeof payload !== 'object' || payload == null) {
+        throw new ParseError('Cannot parse notification payload');
+    }
+    return payload;
+};
+const serializeJSONMerchantParams = (requestParams) => {
+    // Official redsys docs escape "/" because they use php json_encode. I think
+    // this is wrong and it also works without escaping.
+    return Buffer.from(JSON.stringify(requestParams), 'utf8').toString('base64');
 };
 
 /**
@@ -515,9 +613,8 @@ const TRANSACTION_TYPES = {
  *
  * Rounds up the buffer length to the next block and uses 0 as padding.
  *
- * @params {buffer} buf - Input buffer
- * @params {number} blocksize - Size of block
- * @return {buffer}
+ * @params buf - Input buffer
+ * @params blocksize - Size of block
  */
 const zeroPad = (buf, blocksize) => {
     const pad = Buffer.alloc((blocksize - (buf.length % blocksize)) % blocksize, 0);
@@ -526,9 +623,8 @@ const zeroPad = (buf, blocksize) => {
 /**
  * Encrypt a message using 3DES
  *
- * @params {string} key - Key to encrypt message
- * @params {string} message - Message to be encrypted
- * @return {buffer}
+ * @params key - Key to encrypt message
+ * @params message - Message to be encrypted
  */
 const encrypt3DES = (key, message) => {
     const keyBuf = Buffer.from(key, 'base64');
@@ -543,34 +639,353 @@ const encrypt3DES = (key, message) => {
     const maxLength = Math.ceil(messageBuf.length / 8) * 8;
     return encryptedBuf.slice(0, maxLength);
 };
+/**
+ * Compute HMAC_SHA256_V1 signature
+ *
+ * @params merchantKey - Key to encrypt message
+ * @params order - Order number
+ * @params params - Payload to sign
+ */
 const sha256Sign = (merchantKey, order, params) => {
     const orderKeyBuf = encrypt3DES(merchantKey, order);
     return crypto.createHmac('sha256', orderKeyBuf).update(params).digest('base64');
+};
+
+/**
+ * Discrete uniform distribution with domain (0 to *max*)
+ */
+const drawPositiveDiscreteUniform = (max) => {
+    return Math.floor(Math.random() * (max + 1));
 };
-const getResponseCodeMessage = (code) => {
-    if ((typeof code !== 'number' && typeof code !== 'string') || !Number.isInteger(code)) {
-        return null;
+const alphanumeric = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+/**
+ * Generates a random order ID following redsys requirements
+ *
+ * @public
+ */
+const randomTransactionId = () => {
+    // Random 4 digit number between 0 and 9999
+    const num = drawPositiveDiscreteUniform(9999);
+    const numStr = num.toString().padStart(4, '0');
+    // Random 8 letter alphanumeric sequence
+    const alphanum = new Array(8);
+    for (let idx = 0; idx < 8; idx++) {
+        alphanum[idx] = alphanumeric[drawPositiveDiscreteUniform(alphanumeric.length - 1)];
     }
-    const lookupNum = typeof code === 'string' ? Number.parseInt(code.trim()) : code;
-    if (!Number.isFinite(lookupNum) || lookupNum < 0) {
-        return null;
+    const alphanumStr = alphanum.join('');
+    return `${numStr}${alphanumStr}`;
+};
+const extractAndAssertOrderFromRequestParams = (requestParams) => {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions, @typescript-eslint/prefer-nullish-coalescing
+    const order = requestParams['DS_MERCHANT_ORDER'] || requestParams['Ds_Merchant_Order'];
+    if (typeof order !== 'string' || !order) {
+        throw new ParseError('Missing order number');
     }
-    const msg = RESPONSE_CODES[lookupNum.toString()];
-    if ((msg == null || !msg) && lookupNum < 100) {
-        return 'Transacción autorizada para pagos y preautorizaciones';
+    return order;
+};
+const extractAndAssertOrderFromResponseParams = (responseParams) => {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions, @typescript-eslint/prefer-nullish-coalescing
+    const order = responseParams['Ds_Order'] || responseParams['DS_ORDER'];
+    if (typeof order !== 'string' || !order) {
+        throw new ParseError('Missing order number');
     }
-    return msg !== null && msg !== void 0 ? msg : null;
+    return order;
 };
-const getSISErrorCodeMessage = (code) => {
-    if (!code || typeof code !== 'string') {
-        return undefined;
+/**
+ * Indicates if a response code signals success
+ *
+ * @public
+ */
+const isResponseCodeOk = (responseCode) => {
+    const numResCode = Number.parseInt(responseCode);
+    return Number.isFinite(numResCode) && ((numResCode >= 0 && numResCode < 100) ||
+        numResCode === 400 || // Transaction cancellation authorized
+        numResCode === 900 // Refund authorized
+    );
+};
+/**
+ * Asserts that response has a code that indicates success
+ *
+ * @public
+ */
+const assertSuccessfulResponseCode = (responseParams) => {
+    const { Ds_Response: resCode } = responseParams;
+    if (resCode == null) {
+        throw new ParseError('Missing response code');
     }
-    return SIS_ERROR_CODES[code.trim()];
+    if (!isResponseCodeOk(resCode)) {
+        throw new ResponseError({ code: Number.parseInt(resCode), response: responseParams });
+    }
+};
+const isStringNotEmpty = (str) => str != null && str.length > 0;
+
+const sha256VerifyJSONResponse = (merchantKey, response, responseParams) => {
+    if (response.Ds_SignatureVersion !== 'HMAC_SHA256_V1') {
+        throw new RedsysError(`Unknown signature version: ${response.Ds_SignatureVersion}`);
+    }
+    const order = extractAndAssertOrderFromResponseParams(responseParams);
+    const signature = response.Ds_Signature;
+    // Base64url with padding, only substitutes + and /
+    const expSignature = sha256Sign(merchantKey, order, response.Ds_MerchantParameters);
+    // Comparing different base64 encodings is messy. Make it foolproof by comparing buffers.
+    if (!signature || !Buffer.from(expSignature, 'base64').equals(base64url.toBuffer(signature))) {
+        throw new ParseError('Invalid signature');
+    }
+};
+const sha256SignJSONRequest = (merchantKey, serializedParams, requestParams) => {
+    const order = extractAndAssertOrderFromRequestParams(requestParams);
+    const signature = sha256Sign(merchantKey, order, serializedParams);
+    return {
+        Ds_SignatureVersion: 'HMAC_SHA256_V1',
+        Ds_MerchantParameters: serializedParams,
+        Ds_Signature: signature
+    };
+};
+
+const deserializeAndVerifyJSONResponse = (merchantKey, response) => {
+    const params = deserializeJSONMerchantParams(response.Ds_MerchantParameters);
+    sha256VerifyJSONResponse(merchantKey, response, params);
+    return params;
+};
+const serializeAndSignJSONRequest = (merchantKey, requestParams) => {
+    const serializedParams = serializeJSONMerchantParams(requestParams);
+    return sha256SignJSONRequest(merchantKey, serializedParams, requestParams);
+};
+
+const serializeSoapNotificationResponse = ({ allow: allowOperation }) => {
+    const answer = allowOperation ? 'OK' : 'KO';
+    return `<Response Ds_Version="0.0"><Ds_Response_Merchant>${answer}</Ds_Response_Merchant></Response>`;
+};
+const xmlParser = new XMLParser({ parseTagValue: false });
+const deserializeSoapNotification = (xml) => {
+    return xmlParser.parse(xml).Message;
+};
+
+const verifySoapNotification = (merchantKey, xml, msg) => {
+    const startToken = '<Request';
+    const endToken = '</Request>';
+    const startPos = xml.indexOf(startToken);
+    const endPos = xml.indexOf(endToken);
+    if (startPos < 0 || endPos < 0 || startPos > endPos) {
+        throw new ParseError('Cannot find payload of SOAP notification Request', xml);
+    }
+    const signedStr = xml.slice(startPos, endPos + endToken.length);
+    const signature = msg.Signature;
+    const order = msg.Request.Ds_Order;
+    if (order == null || !order) {
+        throw new ParseError('Invalid notification response');
+    }
+    const expSignature = sha256Sign(merchantKey, order, signedStr);
+    if (!signature || signature !== expSignature) {
+        throw new ParseError('Invalid signature', signature, xml);
+    }
+};
+const signSoapNotificationResponse = (merchantKey, serializedResponse, response) => {
+    const signature = sha256Sign(merchantKey, response.order, serializedResponse);
+    return `<Message>${serializedResponse}<Signature>${signature}</Signature></Message>`;
+};
+
+const serializeAndSignSoapNotificationResponse = (merchantKey, response) => {
+    const serializedResponse = serializeSoapNotificationResponse(response);
+    return signSoapNotificationResponse(merchantKey, serializedResponse, response);
+};
+const deserializeAndVerifySoapNotification = (merchantKey, xml) => {
+    const msg = deserializeSoapNotification(xml);
+    verifySoapNotification(merchantKey, xml, msg);
+    // Return only parameters. Signature is useless after verification
+    return msg.Request;
+};
+
+const jsonRequest = async (url, merchantKey, rawRequestParams) => {
+    const payload = serializeAndSignJSONRequest(merchantKey, rawRequestParams);
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(payload)
+    });
+    const responseData = await response.json();
+    if (!response.ok) {
+        throw new HTTPError({
+            code: response.status,
+            response: responseData
+        });
+    }
+    if ('errorCode' in responseData) {
+        throw new GatewayError({
+            code: responseData.errorCode,
+            response: responseData
+        });
+    }
+    return deserializeAndVerifyJSONResponse(merchantKey, responseData);
+};
+
+/**
+ * Redsys production urls
+ *
+ * @public
+ */
+const PRODUCTION_URLS = {
+    redirect: 'https://sis.redsys.es/sis/realizarPago',
+    restTrataPeticion: 'https://sis.redsys.es/sis/rest/trataPeticionREST',
+    restIniciaPeticion: 'https://sis.redsys.es/sis/rest/iniciaPeticionREST'
+};
+/**
+ * Redsys sandbox urls
+ *
+ * @public
+ */
+const SANDBOX_URLS = {
+    redirect: 'https://sis-t.redsys.es:25443/sis/realizarPago',
+    restTrataPeticion: 'https://sis-t.redsys.es:25443/sis/rest/trataPeticionREST',
+    restIniciaPeticion: 'https://sis-t.redsys.es:25443/sis/rest/iniciaPeticionREST'
+};
+/**
+ * Creates Redsys API functions
+ *
+ * @remarks
+ * These API functions are anonymous and can be wrapped by formatters and processors
+ *
+ * @public
+ */
+const createRedsysAPI = (config) => {
+    if (!config.secretKey || typeof config.secretKey !== 'string') {
+        throw new RedsysError('A secretKey key must be provided');
+    }
+    if (typeof config.urls !== 'object' || config.urls == null ||
+        !config.urls.restIniciaPeticion || !config.urls.restTrataPeticion ||
+        !config.urls.redirect) {
+        throw new RedsysError('URLs must be provided');
+    }
+    /**
+     * Sends a iniciaPeticion request using REST interface
+     */
+    const restIniciaPeticion = async (paramsInput) => {
+        return await jsonRequest(config.urls.restIniciaPeticion, config.secretKey, paramsInput);
+    };
+    /**
+     * Sends a trataPeticion request using REST interface
+     */
+    const restTrataPeticion = async (paramsInput) => {
+        const result = await jsonRequest(config.urls.restTrataPeticion, config.secretKey, paramsInput);
+        return result;
+    };
+    /**
+     * Creates the parameters needed for a redirect form
+     */
+    const createRedirectForm = (paramsInput) => {
+        const body = serializeAndSignJSONRequest(config.secretKey, paramsInput);
+        return {
+            url: config.urls.redirect,
+            body
+        };
+    };
+    /**
+     * Processes a JSON REST notification
+     */
+    const processRestNotification = (
+    /** Body of JSON notification, as a POJO (Plain Old Javascript Object) */
+    body) => {
+        // A notification can't contain a gateway error, it didn't initiate the request
+        return deserializeAndVerifyJSONResponse(config.secretKey, body);
+    };
+    /**
+     * Parses and verifies the body of a SOAP notification
+     */
+    const processSoapNotification = (
+    /** SOAP notification as a XML string */
+    xml) => {
+        return deserializeAndVerifySoapNotification(config.secretKey, xml);
+    };
+    /**
+     * Creates an answer for a SOAP notification, serializes and signs it
+     */
+    const createSoapNotificationAnswer = (
+    /** Order identifier */
+    order, 
+    /** Indicates if the payment is allowed to proceed */
+    allow) => {
+        return serializeAndSignSoapNotificationResponse(config.secretKey, {
+            order,
+            allow
+        });
+    };
+    return {
+        restIniciaPeticion,
+        restTrataPeticion,
+        createRedirectForm,
+        processRestNotification,
+        processSoapNotification,
+        createSoapNotificationAnswer
+    };
+};
+
+/*
+ * 3DS method form
+ */
+/**
+ * Creates parameters for a 3DS method form
+ *
+ * @public
+ */
+const create3DSMethodForm = (emv3dsParams, notificationURL) => {
+    const methodData = {
+        threeDSServerTransID: emv3dsParams.threeDSServerTransID,
+        threeDSMethodNotificationURL: notificationURL
+    };
+    return {
+        url: emv3dsParams.threeDSMethodURL,
+        body: {
+            threeDSMethodData: base64url.encode(JSON.stringify(methodData))
+        }
+    };
+};
+/**
+ * Creates parameters for a 3DS v1 challenge form
+ *
+ * @public
+ */
+const create3DSv1ChallengeForm = (emv3dsV1Challenge, challengeNotificationUrl) => {
+    return {
+        url: emv3dsV1Challenge.acsURL,
+        body: {
+            PaReq: emv3dsV1Challenge.PAReq,
+            MD: emv3dsV1Challenge.MD,
+            TermUrl: challengeNotificationUrl
+        }
+    };
+};
+/**
+ * Creates parameters for a 3DS v2 challenge form
+ *
+ * @public
+ */
+const create3DSv2ChallengeForm = (emv3dsV2Challenge) => {
+    return {
+        url: emv3dsV2Challenge.acsURL,
+        body: {
+            creq: emv3dsV2Challenge.creq
+        }
+    };
+};
+/**
+ * Deserialize threeDSMethodData
+ *
+ * @public
+ */
+const deserializeThreeDSMethodData = (threeDSMethodData) => {
+    return JSON.parse(base64url.decode(threeDSMethodData));
 };
-// Order is important
-const signedFieldsXMLResponse = ['Ds_Amount', 'Ds_Order',
-    'Ds_MerchantCode', 'Ds_Currency', 'Ds_Response', 'Ds_CardNumber',
-    'Ds_TransactionType', 'Ds_SecurePayment'];
+/**
+ * Deserialize `cres` field of a 3DS v2 challenge
+ *
+ * @public
+ */
+const deserializeCres = (cres) => {
+    return JSON.parse(Buffer.from(cres, 'base64').toString('utf8'));
+};
+
 const unescapeXML = (str) => {
     const xml = str.replace(/&(lt|#60|gt|#62|quot|#34|amp|#38|apos|#39);/g, (_match, p1) => {
         switch (p1) {
@@ -614,6 +1029,11 @@ const escapeXML = (str) => {
     });
     return xml;
 };
+/**
+ * Detects the soap version of a HTTP request
+ *
+ * @public
+ */
 const detectSoapVersion = (req) => {
     var _a;
     const contentType = (_a = req.headers) === null || _a === void 0 ? void 0 : _a['Content-Type'];
@@ -635,6 +1055,14 @@ const detectSoapVersion = (req) => {
     }
     throw new ParseError('Not a valid SOAP request', req);
 };
+/**
+ * Extracts the body of a SOAP notification from the body of the HTTP request
+ *
+ * @remarks
+ * It does not understand SOAP or use WSDL, the implementation is a little bit hacky
+ *
+ * @public
+ */
 const mimicSoapNotificationReceiver = (xml) => {
     const regex = /<(?:\w+:)?XML(?: [^<>]+)?>([^<>]+)<\/(?:\w+:)?XML>/;
     const matchArray = regex.exec(xml);
@@ -645,73 +1073,37 @@ const mimicSoapNotificationReceiver = (xml) => {
     // wsdl defines XML tag as a string. It cannot be a CDATA (which is a XML element).
     return unescapeXML(xmlContent);
 };
+/**
+ * Creates the body of a HTTP response as SOAP 1.1 from the body of a SOAP notification response
+ *
+ * @remarks
+ * It does not understand SOAP or use WSDL, the implementation is a little bit hacky
+ *
+ * @public
+ */
 const mimicSoap11NotificationResponse = (answer) => {
     const escapedAnswer = escapeXML(answer);
     return `<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:tns="https://sis.sermepa.es/sis/InotificacionSIS.wsdl" xmlns:types="https://sis.sermepa.es/sis/InotificacionSIS.wsdl/encodedTypes" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><q2:procesaNotificacionSISResponse xmlns:q2="InotificacionSIS"><return xsi:type="xsd:string">${escapedAnswer}</return></q2:procesaNotificacionSISResponse></soap:Body></soap:Envelope>`;
 };
-const mimicSoap12NotificationResponse = (answer) => {
+/**
+ * Creates the body of a HTTP response as SOAP 1.2 from the body of a SOAP notification response
+ *
+ * @remarks
+ * It does not understand SOAP or use WSDL, the implementation is a little bit hacky
+ *
+ * @public
+ */
+const mimicSoap12NotificationResponse = (answer) => {
     const escapedAnswer = escapeXML(answer);
     return `<?xml version="1.0" encoding="utf-8"?><soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenc="http://www.w3.org/2003/05/soap-encoding" xmlns:tns="https://sis.sermepa.es/sis/InotificacionSIS.wsdl" xmlns:types="https://sis.sermepa.es/sis/InotificacionSIS.wsdl/encodedTypes" xmlns:rpc="http://www.w3.org/2003/05/soap-rpc" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope"><soap12:Body soap12:encodingStyle="http://www.w3.org/2003/05/soap-encoding"><q4:procesaNotificacionSISResponse xmlns:q4="InotificacionSIS"><rpc:result xmlns="">return</rpc:result><return xsi:type="xsd:string">${escapedAnswer}</return></q4:procesaNotificacionSISResponse></soap12:Body></soap12:Envelope>`;
-};
-// Range: 0 to (top -1)
-const randomInt = (top) => {
-    return Math.floor(Math.random() * Math.floor(top));
-};
-const alphanumeric = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-const randomTransactionId = () => {
-    // Random 4 digit number between 0 and 9999
-    const num = randomInt(10000);
-    const numStr = num.toString().padStart(4, '0');
-    // Random 8 letter alphanumeric sequence
-    const alphanum = new Array(8);
-    for (let idx = 0; idx < 8; idx++) {
-        alphanum[idx] = alphanumeric[randomInt(alphanumeric.length)];
-    }
-    const alphanumStr = alphanum.join('');
-    return `${numStr}${alphanumStr}`;
 };
 
-// ISO 639-1
-const LANGUAGES = {
-    es: '1',
-    en: '2',
-    ca: '3',
-    fr: '4',
-    de: '5',
-    nl: '6',
-    it: '7',
-    sv: '8',
-    pt: '9',
-    pl: '11',
-    gl: '12',
-    eu: '13',
-    // Redsys ha utilizado ISO 3166-1(pais) como codigo de idioma
-    bg: '100',
-    zh: '156',
-    hr: '191',
-    cs: '203',
-    da: '208',
-    et: '233',
-    fi: '246',
-    el: '300',
-    hu: '348',
-    ja: '392',
-    lv: '428',
-    lt: '440',
-    mt: '470',
-    ro: '642',
-    ru: '643',
-    sk: '703',
-    sl: '705',
-    tr: '792'
-};
-const REV_LANGUAGES = {};
-for (const [key, value] of Object.entries(LANGUAGES)) {
-    REV_LANGUAGES[value] = key;
-}
-REV_LANGUAGES['10'] = 'ca';
-
-// ISO 4217
+/**
+ * Maps a ISO 4217 code to a ISO 4217 currency number and decimal positions
+ *
+ * @public
+ */
+// The Record key makes sure that all members of the key union type are defined.
 const CURRENCIES = {
     ALL: { num: '8', decimals: 2 },
     DZD: { num: '12', decimals: 2 },
@@ -925,6 +1317,15 @@ const CURRENCIES = {
     BRL: { num: '986', decimals: 2 }
     // ZAL: { num: '991', decimals: }
 };
+/**
+ * Maps a ISO 4217 number to a ISO 4217 currency code and decimal positions
+ *
+ * @remarks
+ * @see {@link CURRENCIES}
+ *
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const REV_CURRENCIES = {};
 for (const [key, value] of Object.entries(CURRENCIES)) {
     REV_CURRENCIES[value.num] = {
@@ -933,7 +1334,72 @@ for (const [key, value] of Object.entries(CURRENCIES)) {
     };
 }
 
-// ISO 3166 Alpha 2 => (UN M49 === ISO 3166 Num)
+/**
+ * Maps an ISO 639-1 language code to redsys language number
+ *
+ * @remarks
+ * Some ISO 639-1 language codes may include more more than one redsys language number. In such cases the main redsys language number is used.
+ *
+ * @public
+ */
+// The Record key makes sure that all members of the key union type are defined.
+const LANGUAGES = {
+    es: '1',
+    en: '2',
+    ca: '3',
+    fr: '4',
+    de: '5',
+    nl: '6',
+    it: '7',
+    sv: '8',
+    pt: '9',
+    pl: '11',
+    gl: '12',
+    eu: '13',
+    // Redsys ha utilizado ISO 3166-1(pais) como codigo de idioma para el resto
+    bg: '100',
+    zh: '156',
+    hr: '191',
+    cs: '203',
+    da: '208',
+    et: '233',
+    fi: '246',
+    el: '300',
+    hu: '348',
+    ja: '392',
+    lv: '428',
+    lt: '440',
+    mt: '470',
+    ro: '642',
+    ru: '643',
+    sk: '703',
+    sl: '705',
+    tr: '792'
+};
+/**
+ * Maps a redsys language code to an ISO 639-1 language code
+ *
+ * @remarks
+ * @see {@link LANGUAGES}
+ *
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+const REV_LANGUAGES = {};
+for (const [key, value] of Object.entries(LANGUAGES)) {
+    REV_LANGUAGES[value] = key;
+}
+REV_LANGUAGES['10'] = 'ca';
+
+/**
+ * Maps ISO 3166 Alpha 2 codes to UN M49 numbers
+ *
+ * @remarks
+ * [UN M49 to ISO 3166 information](https://unstats.un.org/unsd/methodology/m49/)
+ *
+ * @public
+ */
+// The Record key makes sure that all members of the key union type are defined.
 const COUNTRIES = {
     af: '4',
     al: '8',
@@ -1185,344 +1651,26 @@ const COUNTRIES = {
     ye: '887',
     zm: '894'
 };
+/**
+ * Maps UN M49 numbers to ISO 3166 Alpha 2 codes
+ *
+ * @remarks
+ * @see {@link COUNTRIES}
+ *
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const REV_COUNTRIES = {};
 for (const [key, value] of Object.entries(COUNTRIES)) {
     REV_COUNTRIES[value] = key;
 }
 
-const isStringNotEmpty = (str) => str != null && str.length > 0;
-const inputParamsFormatter = (input, options) => {
-    const obj = {};
-    for (const key of Object.keys(input)) {
-        switch (key) {
-            case 'expiryMonth':
-            case 'expiryYear':
-            case 'raw':
-                continue;
-            case 'order':
-                obj.DS_MERCHANT_ORDER = input[key];
-                break;
-            case 'merchantCode':
-                obj.DS_MERCHANT_MERCHANTCODE = input[key];
-                break;
-            case 'transactionType':
-                obj.DS_MERCHANT_TRANSACTIONTYPE = input.transactionType;
-                break;
-            case 'terminal': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_TERMINAL = value;
-                break;
-            }
-            case 'currency': {
-                const value = input.currency;
-                if (!isStringNotEmpty(value))
-                    continue;
-                const currencyData = CURRENCIES[value];
-                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-                if (!currencyData || !currencyData.num) {
-                    throw new ValidationError('Unsupported currency', value, 'currency');
-                }
-                obj.DS_MERCHANT_CURRENCY = currencyData.num.padStart(3, '0');
-                break;
-            }
-            case 'amount': {
-                /*
-                 * Experimental feature!!!
-                 *
-                 * The feature amountType='float' may be removed any time.
-                 * If you like this feature or have any comment please open an issue
-                 *
-                 * amountType can be atomic or float.
-                 * - atomic: amount represents the smallest currency unit. 1130 (EUR) -> 11.30 EUR
-                 * - float: amount is rounded to last decimal precision. 11.299999999 (EUR) -> 11.30 EUR
-                 *
-                 * Float amount can lead to losing precision, specially after doing
-                 * operations. Atomic is more precise for monetary amount, no lost cents,
-                 * better for accounting.
-                 *
-                 */
-                const value = input[key];
-                // atomic by default
-                let rawValue = value.toString();
-                if ((options === null || options === void 0 ? void 0 : options.amountType) != null) {
-                    if (options.amountType === 'float') {
-                        const currencyData = CURRENCIES[input.currency];
-                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-                        if (!currencyData || !currencyData.decimals) {
-                            throw new ValidationError('Unsupported currency', input.currency, 'currency');
-                        }
-                        const numericValue = typeof value === 'number' ? value : Number.parseFloat(value);
-                        if (!Number.isFinite(numericValue)) {
-                            throw new ValidationError('Invalid amount', value, 'amount');
-                        }
-                        rawValue = Math.round(numericValue * Math.pow(10, currencyData.decimals)).toString();
-                    }
-                    else if (options.amountType !== 'atomic') {
-                        throw new ValidationError('Unknown format', options.amountType, 'amountType');
-                    }
-                }
-                if (rawValue.length > 12) {
-                    throw new ValidationError('Amount to charge is too large', value, 'amount');
-                }
-                obj.DS_MERCHANT_AMOUNT = rawValue;
-                break;
-            }
-            case 'merchantName': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_MERCHANTNAME = value;
-                break;
-            }
-            case 'merchantURL': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_MERCHANTURL = value;
-                break;
-            }
-            case 'merchantSignature': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_MERCHANTSIGNATURE = value;
-                break;
-            }
-            case 'successURL': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_URLOK = value;
-                break;
-            }
-            case 'errorURL': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_URLKO = value;
-                break;
-            }
-            case 'dateFrequency': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_DATEFRECUENCY = value;
-                break;
-            }
-            case 'chargeExpiryDate': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_CHARGEEXPIRYDATE = value;
-                break;
-            }
-            case 'sumTotal': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_SUMTOTAL = value;
-                break;
-            }
-            case 'directPayment': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_DIRECTPAYMENT = value;
-                break;
-            }
-            case 'identifier': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_IDENTIFIER = value;
-                break;
-            }
-            case 'group': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_GROUP = value;
-                break;
-            }
-            case 'pan': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_PAN = value;
-                break;
-            }
-            case 'expiryDate': {
-                const stdFmt = input[key];
-                if (!isStringNotEmpty(stdFmt))
-                    continue;
-                if (stdFmt.length !== 4 || !/^\d+$/.test(stdFmt)) {
-                    throw new ValidationError('Invalid expiryDate', stdFmt, 'expiryDate');
-                }
-                const altFmt = `${stdFmt.slice(2, 4)}${stdFmt.slice(0, 2)}`;
-                obj.DS_MERCHANT_EXPIRYDATE = altFmt;
-                break;
-            }
-            case 'cvv': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_CVV2 = value;
-                break;
-            }
-            case 'cardCountry': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                const countryInt = COUNTRIES[value];
-                if (countryInt != null && countryInt) {
-                    obj.DS_CARD_COUNTRY = countryInt;
-                }
-                break;
-            }
-            case 'lang': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                const langInt = LANGUAGES[value];
-                if (langInt != null && langInt) {
-                    obj.DS_MERCHANT_CONSUMERLANGUAGE = langInt;
-                }
-                break;
-            }
-            case 'merchantData': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_MERCHANTDATA = value;
-                break;
-            }
-            case 'clientIp': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_CLIENTIP = value;
-                break;
-            }
-            case 'operationId': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_IDOPER = value;
-                break;
-            }
-            case 'payMethods': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_PAYMETHODS = value;
-                break;
-            }
-            case 'productDescription': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_PRODUCTDESCRIPTION = value;
-                break;
-            }
-            case 'taxReference': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_TAX_REFERENCE = value;
-                break;
-            }
-            case 'transactionDate': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_TRANSACTIONDATE = value;
-                break;
-            }
-            case 'merchantDescriptor': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_MERCHANTDESCRIPTOR = value;
-                break;
-            }
-            case 'customerMobile': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_CUSTOMER_MOBILE = value;
-                break;
-            }
-            case 'customerMail': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_CUSTOMER_MAIL = value;
-                break;
-            }
-            case 'cardHolder': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_TITULAR = value;
-                break;
-            }
-            case 'smsTemplate': {
-                const value = input[key];
-                if (!isStringNotEmpty(value))
-                    continue;
-                obj.DS_MERCHANT_CUSTOMER_SMS_TEXT = value;
-                break;
-            }
-            default:
-                throw new ValidationError('Unknown parameter', undefined, key);
-        }
-    }
-    return obj;
-};
-const formatParams = (paramsInput, options) => {
-    // Pre processing
-    const { amount, currency, merchantCode, transactionType, order, expiryYear, expiryMonth, expiryDate } = paramsInput;
-    if ((typeof amount !== 'string' || !amount) &&
-        (typeof amount !== 'number' || amount < 0)) {
-        // An amount of 0 is valid, it may be used for obtaining a credit card reference(tokenization)
-        throw new ValidationError('Invalid amount', amount, 'amount');
-    }
-    if (!currency) {
-        throw new ValidationError('No currency provided', currency, 'currency');
-    }
-    if (!merchantCode) {
-        throw new ValidationError('The merchant code is mandatory', merchantCode, 'merchantCode');
-    }
-    if (!transactionType) {
-        throw new ValidationError('The transaction type is mandatory', transactionType, 'transactionType');
-    }
-    if (!order) {
-        throw new ValidationError('No order reference provided', order, 'order');
-    }
-    if ((expiryDate == null || !expiryDate) &&
-        (expiryMonth != null && expiryMonth) &&
-        (expiryYear != null && expiryYear)) {
-        if (expiryMonth.length !== 2) {
-            throw new ValidationError('Invalid expiryMonth', expiryMonth, 'expiryMonth');
-        }
-        if (expiryYear.length !== 2) {
-            throw new ValidationError('Invalid expiryYear', expiryYear, 'expiryYear');
-        }
-        paramsInput.expiryDate = `${expiryMonth}${expiryYear}`;
-    }
-    // Defaults
-    if (paramsInput.terminal == null || !paramsInput.terminal)
-        paramsInput.terminal = '1';
-    const paramsObj = inputParamsFormatter(paramsInput, options);
-    return {
-        ...paramsObj,
-        // Last, so raw doesn't get overwritten
-        ...paramsInput.raw
-    };
-};
-
+/**
+ * Card brand name to number
+ *
+ * @public
+ */
+// The Record key makes sure that all members of the key union type are defined.
 const CARDBRANDS = {
     VISA: '1',
     MASTERCARD: '2',
@@ -1532,300 +1680,363 @@ const CARDBRANDS = {
     JCB: '9',
     UPI: '22'
 };
+/**
+ * Card brand number to name
+ *
+ * @remarks
+ * @see {@link CARDBRANDS}
+ *
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const REV_CARDBRANDS = {};
 for (const [key, value] of Object.entries(CARDBRANDS)) {
     REV_CARDBRANDS[value] = key;
 }
 
-dayjs.extend(timezone);
-dayjs.extend(utc);
-const hourFormatter = (obj, value) => {
-    if (value)
-        obj.hour = value;
-};
-const dateFormatter = (obj, value) => {
-    // Transform to ISO format
-    if (value)
-        obj.date = value.split('/').reverse().join('-');
-};
-const langFormatter = (obj, value) => {
-    const langInt = Number.parseInt(value);
-    const lang = REV_LANGUAGES[langInt];
-    if (lang != null && lang)
-        obj.lang = lang;
-};
-const responseFormatters = {
-    DS_HOUR: hourFormatter,
-    HORA: hourFormatter,
-    DS_DATE: dateFormatter,
-    FECHA: dateFormatter,
-    DS_CURRENCY: (obj, value) => {
-        const currencyInt = Number.parseInt(value);
-        const currency = REV_CURRENCIES[currencyInt];
-        if (currency)
-            obj.currency = currency.code;
-    },
-    DS_AMOUNT: (obj, value) => {
-        if (value)
-            obj.amount = Number.parseInt(value);
-    },
-    DS_RESPONSE: (obj, value) => {
-        // Remove leading zeros
-        if (value)
-            obj.response = Number.parseInt(value);
-    },
-    DS_ORDER: (obj, value) => {
-        obj.order = value;
-    },
-    DS_MERCHANTCODE: (obj, value) => {
-        obj.merchantCode = value;
-    },
-    DS_TERMINAL: (obj, value) => {
-        obj.terminal = value;
-    },
-    DS_MERCHANTDATA: (obj, value) => {
-        if (value)
-            obj.merchantData = value;
-    },
-    DS_SECUREPAYMENT: (obj, value) => {
-        obj.securePayment = value === '1';
-    },
-    DS_TRANSACTIONTYPE: (obj, value) => {
-        obj.transactionType = value;
-    },
-    // Pago por referencia
-    DS_MERCHANT_IDENTIFIER: (obj, value) => {
-        obj.identifier = value;
-    },
-    DS_MERCHANT_GROUP: (obj, value) => {
-        obj.merchantGroup = value;
-    },
-    DS_EXPIRYDATE: (obj, value) => {
-        obj.expiryMonth = value.slice(2, 4);
-        obj.expiryYear = value.slice(0, 2);
-        obj.expiryDate = `${obj.expiryMonth}${obj.expiryYear}`;
-    },
-    // Optional
-    DS_CARDNUMBER: (obj, value) => {
-        obj.cardNumber = value;
-    },
-    DS_CARD_TYPE: (obj, value) => {
-        obj.cardType = value;
-    },
-    DS_AUTHORISATIONCODE: (obj, value) => {
-        obj.authorisationCode = value;
-    },
-    DS_CONSUMERLANGUAGE: langFormatter,
-    DS_LANGUAGE: langFormatter,
-    DS_CARD_COUNTRY: (obj, value) => {
-        const cardCountryInt = Number.parseInt(value);
-        const cardCountry = REV_COUNTRIES[cardCountryInt];
-        if (cardCountry != null && cardCountry) {
-            obj.cardCountry = cardCountry;
-        }
-    },
-    DS_CARD_BRAND: (obj, value) => {
-        const cardBrandInt = Number.parseInt(value);
-        const cardBrand = REV_CARDBRANDS[cardBrandInt];
-        if (cardBrand != null && cardBrand) {
-            obj.cardBrand = cardBrand;
-        }
-    },
-    DS_URLPAGO2FASES: (obj, value) => {
-        obj.payURL = value;
-    }
-};
-const formatResponse = (rawParams) => {
-    const obj = { raw: rawParams };
-    for (const [key, value] of Object.entries(rawParams)) {
-        const formatter = responseFormatters[key.toUpperCase()];
-        if (!formatter)
-            continue;
-        formatter(obj, value);
-    }
-    // Post formatting
-    if (obj.date != null && obj.date && obj.hour != null && obj.hour) {
-        obj.timestamp = dayjs.tz(`${obj.date} ${obj.hour}`, 'YYYY-MM-DD HH:mm', 'Europe/Madrid').toDate();
-    }
-    return obj;
+/**
+ * Transaction type enum
+ *
+ * @public
+ */
+const TRANSACTION_TYPES = {
+    /** Autorización */
+    AUTHORIZATION: '0',
+    /** Preautorización */
+    PRE_AUTHORIZATION: '1',
+    /** Confirmación de preautorización */
+    CONFIRMATION: '2',
+    /** Devolución Automática */
+    AUTO_REFUND: '3',
+    /** Transacción Recurrente */
+    RECURRING_TRANSACTION: '5',
+    /** Transacción Sucesiva */
+    SUCCESSIVE_TRANSACTION: '6',
+    /** Pre-autenticación */
+    PRE_AUTHENTICATION: '7',
+    /** Confirmación de pre-autenticación */
+    PRE_AUTHENTICATION_CONFIRMATION: '8',
+    /** Anulación de Preautorización */
+    PRE_AUTHORIZATION_CANCEL: '9',
+    /** Autorización en diferido */
+    DEFERRED_AUTHORIZATION: 'O',
+    /** Paygold */
+    PAYGOLD: '15',
+    /** Autenticación Puce */
+    PUCE_AUTH: '17',
+    /** Devolución sin original */
+    RETURN_WITHOUT_ORIGINAL: '34',
+    /** Premio de apuestas */
+    BETTING_PAYOUT: '37',
+    /** Eliminar referencia */
+    DELETE_REFERENCE: '44',
+    /** Operaciones sin autenticacíon */
+    NO_AUTHENTICATION: 'A',
+    /** Paygold */
+    PAYLINK: 'F',
+    /** Confirmación de autorización en diferido */
+    DEFERRED_AUTHORIZATION_CONFIRMATION: 'P',
+    /** Anulación de autorización en diferido */
+    DEFERRED_AUTHORIZATION_CANCEL: 'Q',
+    /** Cuota inicial diferido */
+    DEFERRED_INITIAL_FEE: 'R',
+    /** Cuota sucesiva diferido */
+    DEFERRED_SUCCESSIVE_FEE: 'S'
 };
 
-const js2xml = new j2xParser({});
-const PRODUCTION_URLS = {
-    redirect: 'https://sis.redsys.es/sis/realizarPago',
-    ws: 'https://sis.redsys.es/sis/services/SerClsWSEntrada/wsdl/SerClsWSEntrada.wsdl'
+/**
+ * Applies an input formatter to the first argument of a function
+ *
+ * @remarks
+ * The signature of this function is so complex because tries to suport
+ * formatters with generics that provide a default type. This should remain
+ * until [variadic generics](https://github.com/microsoft/TypeScript/issues/5453)
+ * land in typescript
+ *
+ * @public
+ */
+const useSingleInputFormatter = (fn, inputFormatter) => {
+    return (input, ...otherArgs) => fn(inputFormatter(input), ...otherArgs);
 };
-const SANDBOX_URLS = {
-    redirect: 'https://sis-t.redsys.es:25443/sis/realizarPago',
-    ws: 'https://sis-t.redsys.es:25443/sis/services/SerClsWSEntrada/wsdl/SerClsWSEntrada.wsdl'
+/**
+ * Applies an output formatter to a function
+ *
+ * @public
+ */
+const useOutputFormatter = (fn, outputFormatter) => {
+    return (a) => outputFormatter(fn(a));
 };
-class Redsys {
-    constructor(options) {
-        if (!options.secretKey || typeof options.secretKey !== 'string') {
-            throw new RedsysError('A secretKey key must be provided');
-        }
-        if (typeof options.urls !== 'object' || options.urls == null ||
-            !options.urls.ws || !options.urls.redirect) {
-            throw new RedsysError('URLs must be provided');
-        }
-        this.secretKey = options.secretKey;
-        this.urls = options.urls;
-    }
-    signOrderText(order, text) {
-        return sha256Sign(this.secretKey, order, text);
-    }
-    redirectPetitionParameters(paramsInput, options) {
-        const paramsObj = formatParams(paramsInput, options);
-        // Docs escape "/" but we don't, this JSON won't get placed in a script tag
-        return Buffer.from(JSON.stringify(paramsObj), 'utf8').toString('base64');
-    }
-    redirectPetition(paramsInput, options) {
-        const paramsString = this.redirectPetitionParameters(paramsInput, options);
-        const signature = sha256Sign(this.secretKey, paramsInput.order, paramsString);
-        return {
-            url: this.urls.redirect,
-            body: {
-                Ds_SignatureVersion: 'HMAC_SHA256_V1',
-                Ds_MerchantParameters: paramsString,
-                Ds_Signature: signature
-            }
-        };
-    }
-    processNotificationParameters(strPayload) {
-        if (!strPayload) {
-            throw new ParseError('Payload is required');
-        }
-        if (typeof strPayload !== 'string') {
-            throw new ParseError('Payload must be a base-64 encoded string');
-        }
-        const payload = JSON.parse(decodeURIComponent(Buffer.from(strPayload, 'base64').toString('utf8')));
-        if (typeof payload !== 'object' || payload == null) {
-            throw new ParseError('Cannot parse notification payload');
-        }
-        return payload;
-    }
-    processNotification(body) {
-        const params = this.processNotificationParameters(body.Ds_MerchantParameters);
-        const order = params.Ds_Order;
-        if (order == null || !order) {
-            throw new ParseError('Invalid notification parameters');
-        }
-        const signature = body.Ds_Signature;
-        // Base64url with padding, only substitutes + and /
-        const expSignature = sha256Sign(this.secretKey, order, body.Ds_MerchantParameters);
-        // Comparing different base64 encodings is messy. Foolproof, compare buffers.
-        if (!signature || !Buffer.from(expSignature, 'base64').equals(base64url.toBuffer(signature))) {
-            throw new ParseError('Invalid signature');
-        }
-        return formatResponse(params);
-    }
-    processXMLResponseData(xmlData) {
-        const parsedResponse = xmlParser.parse(xmlData, { parseNodeValue: false });
-        if (typeof parsedResponse !== 'object' || parsedResponse == null) {
-            throw new ParseError('Cannot parse notification payload');
-        }
-        return parsedResponse.RETORNOXML;
-    }
-    // Generic Processor for Web Service Responses
-    processXMLResponse(xmlData) {
-        const data = this.processXMLResponseData(xmlData);
-        if (data.CODIGO !== '0') {
-            const err = new ParseError(`Redsys error ${data.CODIGO}`);
-            err.code = data.CODIGO;
-            err.description = getSISErrorCodeMessage(data.CODIGO);
-            // Can't access data.OPERACION, only data.RECIBIDO
-            // However data.RECIBIDO may contain sensitive information
-            throw err;
-        }
-        return data;
+/**
+ * Applies an output formatter to the resolved ouput promise of a function
+ *
+ * @public
+ */
+const usePromiseOutputFormatter = (fn, outputFormatter) => {
+    return async (a) => outputFormatter(await fn(a));
+};
+
+const formatInputCurrency = (input) => {
+    const currencyData = CURRENCIES[input];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (!currencyData || !currencyData.num) {
+        throw new ValidationError('Unsupported currency', { currency: input });
     }
-    assertXMLPetitionResponseSignature(data) {
-        const operationData = data.OPERACION;
-        const signedValues = [];
-        for (const field of signedFieldsXMLResponse) {
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions, @typescript-eslint/prefer-nullish-coalescing
-            const value = operationData[field] || operationData[field.toUpperCase()];
-            if (value != null && value) {
-                signedValues.push(value);
-            }
-        }
-        const signedString = signedValues.join('');
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions, @typescript-eslint/prefer-nullish-coalescing
-        const orderId = operationData.Ds_Order || operationData.DS_ORDER;
-        if (orderId == null || !orderId) {
-            throw new ParseError('Invalid signature');
-        }
-        const signature = operationData.Ds_Signature;
-        const expSignature = sha256Sign(this.secretKey, orderId, signedString);
-        if (signature == null || !signature || signature !== expSignature) {
-            throw new ParseError('Invalid signature');
-        }
+    return currencyData.num;
+};
+const formatExpiryDate = ({ expiryYear, expiryMonth }) => {
+    if ((expiryMonth === null || expiryMonth === void 0 ? void 0 : expiryMonth.length) !== 2) {
+        throw new ValidationError('Invalid expiryMonth', { expiryMonth: expiryMonth });
     }
-    // Processes Web Service Petitions Responses
-    processXMLPetitionResponse(xml) {
-        const data = this.processXMLResponse(xml);
-        this.assertXMLPetitionResponseSignature(data);
-        return formatResponse(data.OPERACION);
+    if ((expiryYear === null || expiryYear === void 0 ? void 0 : expiryYear.length) !== 2) {
+        throw new ValidationError('Invalid expiryYear', { expiryYear: expiryYear });
     }
-    xmlPetitionParameters(paramsInput, options) {
-        const datosEntrada = { DATOSENTRADA: formatParams(paramsInput, options) };
-        return js2xml.parse(datosEntrada);
+    return `${expiryYear}${expiryMonth}`;
+};
+/**
+ * Converts a monetary amount from a decimal string currency unit to the atomic currency unit
+ */
+const formatAmount = (value, context) => {
+    const { currency } = context;
+    if (!currency) {
+        throw new ValidationError('Missing currency', { currency: currency });
     }
-    xmlPetitionSignedData(paramsInput, options) {
-        const datosEntradaXML = this.xmlPetitionParameters(paramsInput, options);
-        const signature = sha256Sign(this.secretKey, paramsInput.order, datosEntradaXML);
-        return `<REQUEST>${datosEntradaXML}<DS_SIGNATUREVERSION>HMAC_SHA256_V1</DS_SIGNATUREVERSION><DS_SIGNATURE>${signature}</DS_SIGNATURE></REQUEST>`;
+    const currencyData = CURRENCIES[currency];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (!currencyData || !currencyData.decimals) {
+        throw new ValidationError('Unsupported currency', { currency: currency });
     }
-    // Good idea unless sessions are used
-    async getWSClient() {
-        if (!this.wsClient) {
-            this.wsClient = createClientAsync(this.urls.ws, {});
-        }
-        // Promise
-        return await this.wsClient;
+    const rawValue = typeof value === 'number'
+        ? Math.round(value * Math.pow(10, currencyData.decimals)).toString()
+        : new Decimal(value).mul(Math.pow(10, currencyData.decimals)).round().toFixed(0);
+    if (rawValue.length > 12) {
+        throw new ValidationError('Amount to charge is too large', { amount: value });
     }
-    async wsPetition(paramsInput, options) {
-        const peticion = this.xmlPetitionSignedData(paramsInput, options);
-        const client = await this.getWSClient();
-        if (!client.trataPeticionAsync) {
-            throw new GatewayError('Cannot obtain client');
-        }
-        const res = await client.trataPeticionAsync({ datoEntrada: peticion });
-        const result = res[0].trataPeticionReturn;
-        const parsedResponse = this.processXMLPetitionResponse(result);
-        const resCode = parsedResponse.response;
-        if (resCode != null && resCode > 100 && resCode !== 400 && resCode !== 600) {
-            throw new GatewayError('Error in webservice petition', resCode, res);
-        }
-        return parsedResponse;
+    return rawValue;
+};
+const formatLang$1 = (value) => {
+    const langInt = LANGUAGES[value];
+    if (langInt == null) {
+        throw new ValidationError('Invalid lang code', { lang: value });
     }
-    processSoapNotification(xml) {
-        const startToken = '<Request';
-        const endToken = '</Request>';
-        const startPos = xml.indexOf(startToken);
-        const endPos = xml.indexOf(endToken);
-        if (startPos < 0 || endPos < 0 || startPos > endPos) {
-            throw new ParseError('Cannot find payload of SOAP notification Request', xml);
-        }
-        const signedStr = xml.slice(startPos, endPos + endToken.length);
-        const msg = xmlParser.parse(xml, { parseNodeValue: false }).Message;
-        const signature = msg.Signature;
-        const order = msg.Request.Ds_Order;
-        if (order == null || !order) {
-            throw new ParseError('Invalid notification response');
-        }
-        const expSignature = sha256Sign(this.secretKey, order, signedStr);
-        if (!signature || signature !== expSignature) {
-            throw new ParseError('Invalid signature', signature, xml);
-        }
-        return formatResponse(msg.Request);
+    return langInt;
+};
+const baseInputFormatter = (input) => {
+    const { order, merchantCode, transactionType, terminal, amount, currency, merchantName, identifier, group, expiryYear, expiryMonth, pan, cvv, directPayment, merchantData, operationId, productDescription, taxReference, transactionDate, cardHolder, raw, ...unknownInput } = input;
+    const unknownKeys = Object.keys(unknownInput);
+    if (unknownKeys.length > 0) {
+        throw new ValidationError([
+            `Unknown parameters: ${unknownKeys.join(', ')}`,
+            'To pass raw parameters, use "raw"'
+        ].join('\n'), unknownInput);
     }
-    soapNotificationAnswer(order, bool) {
-        const answer = bool ? 'OK' : 'KO';
-        const response = `<Response Ds_Version="0.0"><Ds_Response_Merchant>${answer}</Ds_Response_Merchant></Response>`;
-        const signature = sha256Sign(this.secretKey, order, response);
-        return `<Message>${response}<Signature>${signature}</Signature></Message>`;
+    return {
+        DS_MERCHANT_ORDER: order,
+        DS_MERCHANT_MERCHANTCODE: merchantCode,
+        DS_MERCHANT_TRANSACTIONTYPE: transactionType,
+        DS_MERCHANT_TERMINAL: terminal,
+        ...(amount != null ? { DS_MERCHANT_AMOUNT: formatAmount(amount, { currency }) } : undefined),
+        ...(isStringNotEmpty(currency) ? { DS_MERCHANT_CURRENCY: formatInputCurrency(currency) } : undefined),
+        ...(isStringNotEmpty(merchantName) ? { DS_MERCHANT_MERCHANTNAME: merchantName } : undefined),
+        ...(isStringNotEmpty(identifier) ? { DS_MERCHANT_IDENTIFIER: identifier } : undefined),
+        ...(isStringNotEmpty(group) ? { DS_MERCHANT_GROUP: group } : undefined),
+        ...(isStringNotEmpty(expiryYear) || isStringNotEmpty(expiryMonth) ? { DS_MERCHANT_EXPIRYDATE: formatExpiryDate({ expiryYear, expiryMonth }) } : undefined),
+        ...(isStringNotEmpty(pan) ? { DS_MERCHANT_PAN: pan } : undefined),
+        ...(isStringNotEmpty(cvv) ? { DS_MERCHANT_CVV2: cvv } : undefined),
+        ...(isStringNotEmpty(directPayment) ? { DS_MERCHANT_DIRECTPAYMENT: directPayment } : undefined),
+        ...(isStringNotEmpty(merchantData) ? { DS_MERCHANT_MERCHANTDATA: merchantData } : undefined),
+        ...(isStringNotEmpty(operationId) ? { DS_MERCHANT_IDOPER: operationId } : undefined),
+        ...(isStringNotEmpty(productDescription) ? { DS_MERCHANT_PRODUCTDESCRIPTION: productDescription } : undefined),
+        ...(isStringNotEmpty(taxReference) ? { DS_MERCHANT_TAX_REFERENCE: taxReference } : undefined),
+        ...(isStringNotEmpty(transactionDate) ? { DS_MERCHANT_TRANSACTIONDATE: transactionDate } : undefined),
+        ...(isStringNotEmpty(cardHolder) ? { DS_MERCHANT_TITULAR: cardHolder } : undefined),
+        ...raw
+    };
+};
+/**
+ * Redirection input formatter
+ *
+ * @public
+ */
+const redirectInputFormatter = (input) => {
+    const { merchantURL, successURL, errorURL, payMethods, lang, ...baseInput } = input;
+    return {
+        ...baseInputFormatter(baseInput),
+        ...(isStringNotEmpty(merchantURL) ? { DS_MERCHANT_MERCHANTURL: merchantURL } : undefined),
+        ...(isStringNotEmpty(successURL) ? { DS_MERCHANT_URLOK: successURL } : undefined),
+        ...(isStringNotEmpty(errorURL) ? { DS_MERCHANT_URLKO: errorURL } : undefined),
+        ...(isStringNotEmpty(payMethods) ? { DS_MERCHANT_PAYMETHODS: payMethods } : undefined),
+        ...(isStringNotEmpty(lang) ? { DS_MERCHANT_CONSUMERLANGUAGE: formatLang$1(lang) } : undefined),
+        // Overwrite formatted parameters
+        ...baseInput.raw
+    };
+};
+const requestInputFormatter = (input) => {
+    const { customerMail, customerMobile, smsTemplate, ...baseInput } = input;
+    return {
+        ...baseInputFormatter(baseInput),
+        ...(isStringNotEmpty(customerMobile) ? { DS_MERCHANT_CUSTOMER_MOBILE: customerMobile } : undefined),
+        ...(isStringNotEmpty(customerMail) ? { DS_MERCHANT_CUSTOMER_MAIL: customerMail } : undefined),
+        ...(isStringNotEmpty(smsTemplate) ? { DS_MERCHANT_CUSTOMER_SMS_TEXT: smsTemplate } : undefined),
+        // Overwrite formatted parameters
+        ...baseInput.raw
+    };
+};
+/**
+ * REST iniciaPeticion input formatter
+ *
+ * @public
+ */
+const restIniciaPeticionInputFormatter = (raw) => {
+    const { emv3ds, ...requestInput } = raw;
+    return {
+        ...requestInputFormatter(requestInput),
+        ...(emv3ds != null ? { DS_MERCHANT_EMV3DS: emv3ds } : undefined),
+        // Overwrite formatted parameters
+        ...requestInput.raw
+    };
+};
+/**
+ * REST trataPeticion input formatter
+ *
+ * @public
+ */
+const restTrataPeticionInputFormatter = (raw) => {
+    const { emv3ds, ...requestInput } = raw;
+    return {
+        ...requestInputFormatter(requestInput),
+        ...(emv3ds != null ? { DS_MERCHANT_EMV3DS: emv3ds } : undefined),
+        // Overwrite formatted parameters
+        ...requestInput.raw
+    };
+};
+
+dayjs.extend(timezone);
+dayjs.extend(utc);
+const formatCountry = (rawCountry) => {
+    const countryInt = Number.parseInt(rawCountry).toString();
+    return REV_COUNTRIES[countryInt];
+};
+const formatCardBrand = (rawCardBrand) => {
+    const cardBrandInt = Number.parseInt(rawCardBrand).toString();
+    return REV_CARDBRANDS[cardBrandInt];
+};
+const formatResponse = (rawResponse) => Number.parseInt(rawResponse);
+const baseOutputFormatter = (raw) => {
+    const { Ds_MerchantCode: merchantCode, Ds_Terminal: terminal, Ds_Order: order, Ds_SecurePayment: rawSecurePayment, Ds_TransactionType: transactionType, Ds_Card_Country: rawCardCountry, Ds_Card_Brand: rawCardBrand, Ds_Card_PSD2: rawCardPSD2, Ds_MerchantData: merchantData, Ds_Card_Type: cardType, Ds_AuthorisationCode: authorisationCode } = raw;
+    return {
+        raw,
+        merchantCode,
+        terminal,
+        order,
+        transactionType,
+        ...(rawSecurePayment != null && rawSecurePayment.length > 0
+            ? { securePayment: rawSecurePayment === '1' || rawSecurePayment === '2' }
+            : undefined),
+        ...(isStringNotEmpty(rawCardCountry) ? { cardCountry: formatCountry(rawCardCountry) } : undefined),
+        ...(isStringNotEmpty(rawCardBrand) ? { cardBrand: formatCardBrand(rawCardBrand) } : undefined),
+        ...(isStringNotEmpty(rawCardPSD2) ? { cardPSD2: rawCardPSD2 === 'Y' } : undefined),
+        ...(isStringNotEmpty(merchantData) ? { merchantData } : undefined),
+        ...(isStringNotEmpty(cardType) ? { cardType } : undefined),
+        ...(isStringNotEmpty(authorisationCode) ? { authorisationCode } : undefined)
+    };
+};
+const formatPrice = (params) => {
+    const { Ds_Amount: rawAmount, Ds_Currency: rawCurrency } = params;
+    const currencyInt = Number.parseInt(rawCurrency).toString();
+    const currencyInfo = REV_CURRENCIES[currencyInt];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (!currencyInfo) {
+        throw new ParseError('Unknown currency', rawCurrency);
     }
-}
+    const currency = currencyInfo.code;
+    const amount = new Decimal(rawAmount).dividedBy(Math.pow(10, currencyInfo.decimals)).toFixed();
+    return {
+        amount,
+        currency
+    };
+};
+const formatLang = (rawLang) => {
+    const langInt = Number.parseInt(rawLang).toString();
+    return REV_LANGUAGES[langInt];
+};
+const notificationOutputFormatter = (raw) => {
+    const { Ds_ConsumerLanguage: rawConsumerLanguage, Ds_Response: rawResponse } = raw;
+    return {
+        ...baseOutputFormatter(raw),
+        ...formatPrice(raw),
+        response: formatResponse(rawResponse),
+        ...(isStringNotEmpty(rawConsumerLanguage) ? { lang: formatLang(rawConsumerLanguage) } : undefined)
+    };
+};
+/**
+ * REST notification formatter
+ *
+ * @public
+ */
+const restNotificationOutputFormatter = (raw) => {
+    const { Ds_Hour: hour, Ds_Date: rawDate } = raw;
+    const date = rawDate.split('/').reverse().join('-');
+    return {
+        ...notificationOutputFormatter(raw),
+        time: hour,
+        date,
+        timestamp: dayjs.tz(`${date}T${hour}`, 'YYYY-MM-DDTHH:mm', 'Europe/Madrid').toDate()
+    };
+};
+/**
+ * SOAP notification formatter
+ *
+ * @public
+ */
+const soapNotificationOutputFormatter = (raw) => {
+    const { Hora: hour, Fecha: rawDate } = raw;
+    const date = rawDate.split('/').reverse().join('-');
+    return {
+        ...notificationOutputFormatter(raw),
+        time: hour,
+        date,
+        timestamp: dayjs.tz(`${date}T${hour}`, 'YYYY-MM-DDTHH:mm', 'Europe/Madrid').toDate()
+    };
+};
+const requestOutputFormatter = (raw) => {
+    const { Ds_CardNumber: deprecatedCardNumber, Ds_Card_Number: newCardNumber, Ds_Merchant_Identifier: identifier, Ds_ExpiryDate: rawExpiryDate, Ds_UrlPago2Fases: payURL, Ds_Language: rawLang } = raw;
+    const cardNumber = newCardNumber !== null && newCardNumber !== void 0 ? newCardNumber : deprecatedCardNumber;
+    return {
+        ...baseOutputFormatter(raw),
+        ...(isStringNotEmpty(cardNumber) ? { cardNumber } : undefined),
+        ...(isStringNotEmpty(identifier) ? { identifier } : undefined),
+        ...(isStringNotEmpty(payURL) ? { payURL } : undefined),
+        ...(isStringNotEmpty(rawExpiryDate)
+            ? { expiryYear: rawExpiryDate.slice(0, 2), expiryMonth: rawExpiryDate.slice(2, 4) }
+            : undefined),
+        ...(isStringNotEmpty(rawLang) ? { lang: formatLang(rawLang) } : undefined)
+    };
+};
+/**
+ * REST iniciaPeticion output formatter
+ *
+ * @public
+ */
+const restIniciaPeticionOutputFormatter = (raw) => {
+    const { Ds_EMV3DS: emv3ds } = raw;
+    return {
+        ...requestOutputFormatter(raw),
+        ...(emv3ds != null ? { emv3ds } : undefined)
+    };
+};
+/**
+ * REST trataPeticion output formatter
+ *
+ * @public
+ */
+const restTrataPeticionOutputFormatter = (raw) => {
+    const { Ds_Response: rawResponse, Ds_EMV3DS: emv3ds } = raw;
+    return {
+        ...requestOutputFormatter(raw),
+        ...formatPrice(raw),
+        ...(emv3ds != null ? { emv3ds } : undefined),
+        ...(rawResponse != null ? { response: Number.parseInt(rawResponse) } : undefined)
+    };
+};
 
-export { PRODUCTION_URLS, Redsys, SANDBOX_URLS, TRANSACTION_TYPES, detectSoapVersion, getResponseCodeMessage, getSISErrorCodeMessage, mimicSoap11NotificationResponse, mimicSoap12NotificationResponse, mimicSoapNotificationReceiver, randomTransactionId };
+export { CARDBRANDS, COUNTRIES, CURRENCIES, GatewayError, HTTPError, LANGUAGES, PRODUCTION_URLS, ParseError, REV_CARDBRANDS, REV_COUNTRIES, REV_CURRENCIES, REV_LANGUAGES, RedsysError, ResponseError, SANDBOX_URLS, TRANSACTION_TYPES, ValidationError, assertSuccessfulResponseCode, create3DSMethodForm, create3DSv1ChallengeForm, create3DSv2ChallengeForm, createRedsysAPI, deserializeCres, deserializeThreeDSMethodData, detectSoapVersion, getResponseCodeMessage, getSISErrorCodeMessage, isResponseCodeOk, mimicSoap11NotificationResponse, mimicSoap12NotificationResponse, mimicSoapNotificationReceiver, randomTransactionId, redirectInputFormatter, restIniciaPeticionInputFormatter, restIniciaPeticionOutputFormatter, restNotificationOutputFormatter, restTrataPeticionInputFormatter, restTrataPeticionOutputFormatter, soapNotificationOutputFormatter, useOutputFormatter, usePromiseOutputFormatter, useSingleInputFormatter };