@mojaloop/ml-schema-transformer-lib/dist/index.js

Shared component for ML schemas translation

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  TransformFacades: () => TransformFacades,
  createTransformer: () => createTransformer
});
module.exports = __toCommonJS(index_exports);

// src/lib/transformer.ts
var transformFn = async (source, options) => {
  const { mapping, mapTransformOptions, mapperOptions, logger: logger2 } = options;
  try {
    const transformer = createTransformer(mapping, { mapTransformOptions });
    return transformer.transform(source, { mapperOptions });
  } catch (error) {
    logger2.error("Error transforming payload with supplied mapping", { error, source, mapping });
    throw error;
  }
};
var Transformer = class {
  mapper;
  constructor(mapper) {
    this.mapper = mapper;
  }
  async transform(source, { mapperOptions } = {}) {
    return this.mapper(source, mapperOptions);
  }
};

// src/lib/utils/index.ts
var ilpPacket = __toESM(require("ilp-packet"));

// src/types/type-guards.ts
var isContextLogger = (logger2) => {
  return "info" in logger2 && "error" in logger2 && "warn" in logger2 && "verbose" in logger2 && "debug" in logger2 && "silly" in logger2 && "audit" in logger2 && "trace" in logger2;
};
var baseFspiopGuards = {
  isSource: (source) => {
    return !!source.body;
  }
};
var baseIsoGuards = {
  isSource: (source) => {
    return !!source.body;
  }
};
var FSPIOP = {
  parties: {
    put: {
      isSource: (source) => {
        return !!(source.body && (source.headers?.["fspiop-source"] && source.headers["fspiop-destination"]) && (source.params.IdPath || source.params?.Type && source.params.ID));
      }
    },
    putError: {
      isSource: (source) => {
        return !!(source.body && (source.headers?.["fspiop-source"] && source.headers["fspiop-destination"]) && (source.params.IdPath || source.params?.Type && source.params.ID));
      }
    }
  },
  quotes: {
    post: baseFspiopGuards,
    put: {
      isSource: (source) => {
        return !!(source.body && source.params?.ID && (source.$context?.isoPostQuote || source.headers?.["fspiop-source"] && source.headers["fspiop-destination"]));
      }
    },
    putError: baseFspiopGuards
  },
  transfers: {
    post: baseFspiopGuards,
    patch: baseFspiopGuards,
    put: baseFspiopGuards,
    putError: baseFspiopGuards
  },
  fxQuotes: {
    post: baseFspiopGuards,
    put: baseFspiopGuards,
    putError: baseFspiopGuards
  },
  fxTransfers: {
    post: baseFspiopGuards,
    patch: baseFspiopGuards,
    put: baseFspiopGuards,
    putError: baseFspiopGuards
  }
};
var FSPIOPISO20022 = {
  parties: {
    put: baseIsoGuards,
    putError: baseIsoGuards
  },
  quotes: {
    post: baseIsoGuards,
    put: baseIsoGuards,
    putError: baseIsoGuards
  },
  transfers: {
    post: baseIsoGuards,
    patch: baseIsoGuards,
    put: baseIsoGuards,
    putError: baseIsoGuards
  },
  fxQuotes: {
    post: baseIsoGuards,
    put: baseIsoGuards,
    putError: baseIsoGuards
  },
  fxTransfers: {
    post: baseIsoGuards,
    patch: baseIsoGuards,
    put: baseIsoGuards,
    putError: baseIsoGuards
  }
};
var TypeGuards = { FSPIOP, FSPIOPISO20022 };

// src/types/index.ts
var logLevelsMap = {
  error: "error",
  warn: "warn",
  info: "info",
  verbose: "verbose",
  debug: "debug",
  silly: "silly",
  audit: "audit",
  trace: "trace",
  perf: "perf"
};
var logLevelValues = Object.values(logLevelsMap);

// src/lib/utils/index.ts
var idGenerator = require("@mojaloop/central-services-shared").Util.id;
var { CreateFSPIOPErrorFromErrorCode } = require("@mojaloop/central-services-error-handling");
var fspiopToIsoTransferStateMap = {
  COMMITTED: "COMM",
  RESERVED: "RESV",
  RECEIVED: "RECV",
  ABORTED: "ABOR"
};
var generateID = (idGenType = "ulid" /* ulid */, config = {}) => {
  switch (idGenType) {
    case "ulid" /* ulid */:
    case "uuid" /* uuid */:
      return idGenerator({ ...config, type: idGenType })();
    default:
      return idGenerator({ ...config, type: "ulid" /* ulid */ })();
  }
};
var isPersonPartyIdType = (partyIdType) => partyIdType && !["BUSINESS", "ALIAS", "DEVICE"].includes(partyIdType);
var isEmptyObject = (data) => {
  return typeof data === "object" && data !== null && Object.keys(data).length === 0;
};
var setProp = (obj, path2, value) => {
  const pathParts = path2.split(".");
  let current = obj;
  for (let i = 0; i < pathParts.length - 1; i++) {
    const part = pathParts[i];
    if (!current[part]) {
      current[part] = {};
    }
    current = current[part];
  }
  current[pathParts[pathParts.length - 1]] = value;
};
var getProp = (obj, path2) => {
  const pathParts = path2.split(".");
  let current = obj;
  for (const part of pathParts) {
    if (typeof current === "object" && current !== null && part in current) {
      current = current[part];
    } else {
      return void 0;
    }
  }
  return current;
};
var hasProp = (obj, path2) => {
  const pathParts = path2.split(".");
  let current = obj;
  for (const part of pathParts) {
    if (typeof current === "object" && current !== null && part in current) {
      current = current[part];
    } else {
      return false;
    }
  }
  return true;
};
var deepMerge = (target, source) => {
  for (const key in source) {
    if (source[key] instanceof Object && key in target) {
      Object.assign(source[key], deepMerge(target[key], source[key]));
    }
  }
  Object.assign(target, source);
  return target;
};
var getDescrForErrCode = (code) => {
  try {
    const errorCode = Number.parseInt(code);
    const errorCreated = CreateFSPIOPErrorFromErrorCode(errorCode);
    return errorCreated?.apiErrorCode?.type?.description;
  } catch (error) {
    return "Unknown error";
  }
};
var getIlpPacketCondition = (inputIlpPacket) => {
  const binaryPacket = Buffer.from(inputIlpPacket, "base64");
  const decoded = ilpPacket.deserializeIlpPrepare(binaryPacket);
  return decoded?.executionCondition?.toString("base64url");
};
var toIsoTransferState = (fspiopState) => {
  if (!fspiopState) return void 0;
  const isoState = fspiopToIsoTransferStateMap[fspiopState];
  if (!isoState) throw new Error(`toIsoTransferState: Unknown FSPIOP transfer state: ${fspiopState}`);
  return isoState;
};
var toFspiopTransferState = (isoState) => {
  if (!isoState) return void 0;
  for (const [key, value] of Object.entries(fspiopToIsoTransferStateMap)) {
    if (value === isoState) return key;
  }
  throw new Error(`toFspiopTransferState: Unknown ISO20022 transfer state: ${isoState}`);
};
var validateConfig = (config) => {
  if (hasProp(config, "logger") && !isContextLogger(config.logger)) {
    throw new Error("Invalid logger provided");
  }
};
var unrollExtensions = (extensions) => {
  const unrolled = {};
  for (const { key, value } of extensions) {
    setProp(unrolled, key, value);
  }
  return unrolled;
};
var rollUpUnmappedAsExtensions = (source, mapping) => {
  const extensions = [];
  const mappingObj = mapping = typeof mapping === "string" ? JSON.parse(mapping) : mapping;
  const mappingValues = extractValues(mappingObj).map((value) => String(value)).filter((value) => value.startsWith("body.") || value.startsWith("$context.")).map((value) => value.replace("body.", "")).map((value) => value.replace(/\$context\.[a-zA-Z0-9]+./, ""));
  const sourcePaths = getObjectPaths(source.body);
  for (const path2 of sourcePaths) {
    if (!mappingValues.includes(path2)) {
      const value = getProp(source.body, path2);
      extensions.push({ key: path2, value });
    }
  }
  return extensions;
};
var extractValues = (obj) => {
  const values = [];
  function recurse(current) {
    if (Array.isArray(current)) {
      current.forEach((item) => recurse(item));
    } else if (typeof current === "object" && current !== null) {
      Object.values(current).forEach((value) => recurse(value));
    } else {
      values.push(current);
    }
  }
  recurse(obj);
  return values;
};
var getObjectPaths = (obj, prefix = "") => {
  let paths = [];
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const path2 = prefix ? `${prefix}.${key}` : key;
      if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])) {
        paths = paths.concat(getObjectPaths(obj[key], path2));
      } else {
        paths.push(path2);
      }
    }
  }
  return paths;
};
var deduplicateObjectsArray = (arr, uniqueKey) => {
  const seen = /* @__PURE__ */ new Set();
  return arr.reduce((acc, obj) => {
    if (!seen.has(obj[uniqueKey])) {
      seen.add(obj[uniqueKey]);
      acc.push(obj);
    }
    return acc;
  }, []);
};

// src/lib/transforms/index.ts
var CustomTransforms = {
  generateID: (options) => () => (data, state) => {
    return generateID();
  },
  datetimeNow: (options) => () => (data, state) => {
    return (/* @__PURE__ */ new Date()).toISOString();
  },
  isPersonParty: (options) => () => (data, state) => {
    return isPersonPartyIdType(data);
  },
  isNotPersonParty: (options) => () => (data, state) => {
    return !isPersonPartyIdType(data);
  },
  isNotEmpty: (options) => () => (data, state) => {
    return data && !isEmptyObject(data);
  },
  fspiopErrorDescrForCode: (options) => () => (data, state) => {
    return getDescrForErrCode(data);
  },
  ilpPacketToCondition: (options) => () => (data, state) => {
    return getIlpPacketCondition(data);
  },
  toFspiopTransferState: (options) => () => (data, state) => {
    return toFspiopTransferState(data);
  },
  toIsoTransferState: (options) => () => (data, state) => {
    return toIsoTransferState(data);
  },
  toIsoErrorDescription: (options) => () => (data, state) => {
    const dataStr = data;
    return dataStr.length > 105 ? dataStr.substring(0, 105) : dataStr;
  },
  supportedCurrenciesToString: (options) => () => (data, state) => {
    return data && Array.isArray(data) && data.length > 0 ? data[0] : data;
  },
  toArray: (options) => () => (data, state) => {
    if (data) {
      return Array.isArray(data) ? data : [data];
    }
    return void 0;
  }
};

// src/lib/createTransformer.ts
var mapTransform = require("map-transform-cjs").default;
var createTransformer = (mapping, options = {}) => {
  const { mapTransformOptions } = options;
  const mergedOptions = { ...mapTransformOptions, transformers: { ...mapTransformOptions?.transformers, ...CustomTransforms } };
  mapping = typeof mapping === "string" ? JSON.parse(mapping) : mapping;
  return new Transformer(mapTransform(mapping, mergedOptions));
};

// src/lib/logger.ts
var import_contextLogger = require("@mojaloop/central-services-logger/src/contextLogger");
var createLogger = (context, logLevel) => {
  const log = (0, import_contextLogger.loggerFactory)(context);
  log.setLevel(logLevel);
  return log;
};
var logger = createLogger("MLST", process.env.MLST_LOG_LEVEL || logLevelsMap.warn);

// src/mappings/fspiopiso20022/index.ts
var fspiopiso20022_exports = {};
__export(fspiopiso20022_exports, {
  discovery: () => discovery,
  discovery_reverse: () => discovery_reverse,
  fxQuotes: () => fxQuotes,
  fxQuotes_reverse: () => fxQuotes_reverse,
  fxTransfers: () => fxTransfers,
  fxTransfers_reverse: () => fxTransfers_reverse,
  quotes: () => quotes,
  quotes_reverse: () => quotes_reverse,
  transfers: () => transfers,
  transfers_reverse: () => transfers_reverse
});

// src/mappings/fspiopiso20022/discovery.ts
var discovery = {
  parties: {
    put: `{
      "$noDefaults": true,
      "headers.fspiop-source": "body.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id",
      "headers.fspiop-destination": "body.Assgnmt.Assgne.Agt.FinInstnId.Othr.Id",
      "params.IdPath": "body.Rpt.OrgnlId",
      "body.party.partyIdInfo.partyIdType": { "$alt": [ "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.OrgId.Othr.SchmeNm.Prtry", "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.PrvtId.Othr.SchmeNm.Prtry", "body.Rpt.UpdtdPtyAndAcctId.Pty.PrvtId.Othr.Id" ] },
      "body.party.partyIdInfo.partyIdentifier": { "$alt": ["body.Rpt.UpdtdPtyAndAcctId.Pty.Id.OrgId.Othr.Id", "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.PrvtId.Othr.Id"] },
      "body.party.partyIdInfo.fspId": "body.Rpt.UpdtdPtyAndAcctId.Agt.FinInstnId.Othr.Id",
      "body.party.name": "body.Rpt.UpdtdPtyAndAcctId.Pty.Nm",
      "body.party.supportedCurrencies": ["body.Rpt.UpdtdPtyAndAcctId.Acct.Ccy", { "$transform": "toArray" }]
    }`,
    putError: `{
      "$noDefaults": true,
      "body.errorInformation.errorDescription": ["body.Rpt.Rsn.Cd", { "$transform": "fspiopErrorDescrForCode" }],
      "body.errorInformation.errorCode": "body.Rpt.Rsn.Cd",
      "headers.fspiop-source": "body.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id",
      "headers.fspiop-destination": "body.Assgnmt.Assgne.Agt.FinInstnId.Othr.Id",
      "params.IdPath": "body.Rpt.OrgnlId"
    }`
  }
};
var discovery_reverse = {
  parties: {
    put: `{
      "$noDefaults": true,
      "body.Assgnmt.MsgId": { "$transform": "generateID" },
      "body.Assgnmt.CreDtTm": { "$transform": "datetimeNow" },
      "body.Rpt.Vrfctn": [{ "$transform": "fixed", "value": true }],
      "body.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id": "headers.fspiop-source",
      "body.Assgnmt.Assgne.Agt.FinInstnId.Othr.Id": "headers.fspiop-destination",
      "body.Rpt.OrgnlId": "params.IdPath",
      "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.OrgId.Othr.SchmeNm.Prtry": ["body.party.partyIdInfo.partyIdType", { "$filter": "isNotPersonParty" }],
      "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.PrvtId.Othr.SchmeNm.Prtry": ["body.party.partyIdInfo.partyIdType", { "$filter": "isPersonParty" }],
      "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.OrgId.Othr.Id": ["body.party.partyIdInfo.partyIdentifier", { "$filter": "isNotPersonParty" }],
      "body.Rpt.UpdtdPtyAndAcctId.Pty.Id.PrvtId.Othr.Id": ["body.party.partyIdInfo.partyIdentifier", { "$filter": "isPersonParty" }],
      "body.Rpt.UpdtdPtyAndAcctId.Agt.FinInstnId.Othr.Id": "body.party.partyIdInfo.fspId",
      "body.Rpt.UpdtdPtyAndAcctId.Pty.Nm": "body.party.name",
      "body.Rpt.UpdtdPtyAndAcctId.Acct.Ccy": ["body.party.supportedCurrencies", { "$transform": "supportedCurrenciesToString" }]
    }`,
    putError: `{
      "$noDefaults": true,
      "body.Rpt.Rsn.Cd": "body.errorInformation.errorCode",
      "body.Assgnmt.MsgId": { "$transform": "generateID" },
      "body.Assgnmt.CreDtTm": { "$transform": "datetimeNow" },
      "body.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id": "headers.fspiop-source",
      "body.Assgnmt.Assgne.Agt.FinInstnId.Othr.Id": "headers.fspiop-destination",
      "body.Rpt.OrgnlId": "params.IdPath",
      "body.Rpt.Vrfctn": [{ "$transform": "fixed", "value": false }]
    }`
  }
};

// src/mappings/fspiopiso20022/quotes.ts
var quotes = {
  post: `{
    "$noDefaults": "true",
    "body.quoteId": "body.CdtTrfTxInf.PmtId.TxId",
    "body.expiration": "body.GrpHdr.PmtInstrXpryDtTm",
    "body.transactionId": "body.CdtTrfTxInf.PmtId.EndToEndId",
    "body.transactionRequestId": "body.CdtTrfTxInf.PmtId.InstrId",
    "body.payee.partyIdInfo.partyIdType": { "$alt": [ "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.SchmeNm.Prtry", "body.CdtTrfTxInf.Cdtr.Id.PrvtId.Othr.SchmeNm.Prtry" ] },
    "body.payee.partyIdInfo.partyIdentifier": { "$alt": [ "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.Id", "body.CdtTrfTxInf.Cdtr.Id.PrvtId.Othr.Id" ] },
    "body.payee.partyIdInfo.fspId": "body.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id",
    "body.payee.name": "body.CdtTrfTxInf.Cdtr.Name",
    "body.payee.supportedCurrencies": ["body.CdtTrfTxInf.CdtrAcct.Ccy", { "$transform": "toArray" }],
    "body.payer.partyIdInfo.partyIdType": { "$alt": [ "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.SchmeNm.Prtry", "body.CdtTrfTxInf.Dbtr.Id.PrvtId.Othr.SchmeNm.Prtry" ] },
    "body.payer.partyIdInfo.partyIdentifier": { "$alt": [ "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.Id", "body.CdtTrfTxInf.Dbtr.Id.PrvtId.Othr.Id" ] },
    "body.payer.partyIdInfo.fspId": "body.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id",
    "body.payer.name": "body.CdtTrfTxInf.Dbtr.Name",
    "body.payer.supportedCurrencies": ["body.CdtTrfTxInf.DbtrAcct.Ccy", { "$transform": "toArray" }],
    "body.amount.currency": "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy",
    "body.amount.amount": "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount",
    "body.transactionType.scenario": "body.CdtTrfTxInf.Purp.Prtry",
    "body.transactionType.refundInfo.originalTransactionId": "body.CdtTrfTxInf.PmtId.InstrId"
  }`,
  // TODO: Support payeeFspCommission.currency and payeeFspCommission.amount
  //       when CdtTrfTxInf.IntrBkSttlmAmt.ChrgsInf.Tp.Cd is "COMM"
  put: `{
    "$noDefaults": "true",
    "params.ID": "body.CdtTrfTxInf.PmtId.TxId",
    "headers.fspiop-destination": "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.Id",
    "headers.fspiop-source": "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.Id",
    "body.expiration": "body.GrpHdr.PmtInstrXpryDtTm",
    "body.transferAmount.currency": "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy",
    "body.transferAmount.amount": "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount",
    "body.payeeReceiveAmount.currency": "body.CdtTrfTxInf.InstdAmt.Ccy",
    "body.payeeReceiveAmount.amount": "body.CdtTrfTxInf.InstdAmt.ActiveOrHistoricCurrencyAndAmount",
    "body.payeeFspFee.currency": "body.CdtTrfTxInf.ChrgsInf.Amt.Ccy",
    "body.payeeFspFee.amount": "body.CdtTrfTxInf.ChrgsInf.Amt.ActiveOrHistoricCurrencyAndAmount",
    "body.ilpPacket": "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket",
    "body.condition": [ "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket", { "$transform": "ilpPacketToCondition" }]
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.errorInformation.errorCode": "body.TxInfAndSts.StsRsnInf.Rsn.Prtry",
    "body.errorInformation.errorDescription": "body.TxInfAndSts.StsRsnInf.AddtlInf"
  }`
};
var quotes_reverse = {
  post: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.expiration",
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.CdtTrfTxInf.PmtId.TxId": "body.quoteId",
    "body.CdtTrfTxInf.PmtId.EndToEndId": "body.transactionId",
    "body.CdtTrfTxInf.PmtId.InstrId": "body.transactionRequestId",
    "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.SchmeNm.Prtry": ["body.payee.partyIdInfo.partyIdType", { "$filter": "isNotPersonParty" }],
    "body.CdtTrfTxInf.Cdtr.Id.PrvtId.Othr.SchmeNm.Prtry": ["body.payee.partyIdInfo.partyIdType", { "$filter": "isPersonParty" }],
    "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.Id": ["body.payee.partyIdInfo.partyIdentifier", { "$filter": "isNotPersonParty" }],
    "body.CdtTrfTxInf.Cdtr.Id.PrvtId.Othr.Id": ["body.payee.partyIdInfo.partyIdentifier", { "$filter": "isPersonParty" }],
    "body.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id": "body.payee.partyIdInfo.fspId",
    "body.CdtTrfTxInf.Cdtr.Name": "body.payee.name",
    "body.CdtTrfTxInf.CdtrAcct.Ccy": ["body.payee.supportedCurrencies", { "$transform": "supportedCurrenciesToString" }],
    "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.SchmeNm.Prtry": ["body.payer.partyIdInfo.partyIdType", { "$filter": "isNotPersonParty" }],
    "body.CdtTrfTxInf.Dbtr.Id.PrvtId.Othr.SchmeNm.Prtry": ["body.payer.partyIdInfo.partyIdType", { "$filter": "isPersonParty" }],
    "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.Id": ["body.payer.partyIdInfo.partyIdentifier", { "$filter": "isNotPersonParty" }],
    "body.CdtTrfTxInf.Dbtr.Id.PrvtId.Othr.Id": ["body.payer.partyIdInfo.partyIdentifier", { "$filter": "isPersonParty" }],
    "body.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id": "body.payer.partyIdInfo.fspId",
    "body.CdtTrfTxInf.Dbtr.Name": "body.payer.name",
    "body.CdtTrfTxInf.DbtrAcct.Ccy": ["body.payer.supportedCurrencies", { "$transform": "supportedCurrenciesToString" }],
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.amount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.amount.amount",
    "body.CdtTrfTxInf.Purp.Prtry": "body.transactionType.scenario",
    "body.CdtTrfTxInf.PmtId.InstrId": "body.transactionType.refundInfo.originalTransactionId"
  }`,
  // TODO: Support payeeFspCommission.currency and payeeFspCommission.amount
  //       when CdtTrfTxInf.IntrBkSttlmAmt.ChrgsInf.Tp.Cd is "COMM"
  putTesting: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.expiration",
    "body.CdtTrfTxInf.PmtId.TxId": "params.ID",
    "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.Id": { "$alt": [ "$context.isoPostQuote.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.Id", "headers.fspiop-destination" ]},
    "body.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id": { "$alt": [ "$context.isoPostQuote.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id", "headers.fspiop-destination" ]},
    "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.Id": { "$alt": [ "$context.isoPostQuote.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.Id", "headers.fspiop-source" ] },
    "body.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id": { "$alt": [ "$context.isoPostQuote.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id", "headers.fspiop-source" ]},
    "body.CdtTrfTxInf.ChrgBr": { "$alt": [ "$context.isoPostQuote.CdtTrfTxInf.ChrgBr", { "$transform": "fixed", "value": "SHAR" } ] },
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.transferAmount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.transferAmount.amount",
    "body.CdtTrfTxInf.InstdAmt.Ccy": "body.payeeReceiveAmount.currency",
    "body.CdtTrfTxInf.InstdAmt.ActiveOrHistoricCurrencyAndAmount": "body.payeeReceiveAmount.amount",
    "body.CdtTrfTxInf.ChrgsInf.Amt.Ccy": "body.payeeFspFee.currency",
    "body.CdtTrfTxInf.ChrgsInf.Amt.ActiveOrHistoricCurrencyAndAmount": "body.payeeFspFee.amount",
    "body.CdtTrfTxInf.ChrgsInf.Agt.FinInstnId.Othr.Id": { "$alt": [ "$context.isoPostQuote.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id", { "$transform": "fixed", "value": "Testing" } ] },
    "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket": "body.ilpPacket"
  }`,
  put: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.expiration",
    "body.CdtTrfTxInf.PmtId.TxId": "params.ID",
    "body.CdtTrfTxInf.Dbtr": "$context.isoPostQuote.CdtTrfTxInf.Dbtr",
    "body.CdtTrfTxInf.DbtrAgt": "$context.isoPostQuote.CdtTrfTxInf.DbtrAgt",
    "body.CdtTrfTxInf.Cdtr": "$context.isoPostQuote.CdtTrfTxInf.Cdtr",
    "body.CdtTrfTxInf.CdtrAgt": "$context.isoPostQuote.CdtTrfTxInf.CdtrAgt",
    "body.CdtTrfTxInf.ChrgBr": "$context.isoPostQuote.CdtTrfTxInf.ChrgBr",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.transferAmount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.transferAmount.amount",
    "body.CdtTrfTxInf.InstdAmt.Ccy": "body.payeeReceiveAmount.currency",
    "body.CdtTrfTxInf.InstdAmt.ActiveOrHistoricCurrencyAndAmount": "body.payeeReceiveAmount.amount",
    "body.CdtTrfTxInf.ChrgsInf.Amt.Ccy": "body.payeeFspFee.currency",
    "body.CdtTrfTxInf.ChrgsInf.Amt.ActiveOrHistoricCurrencyAndAmount": "body.payeeFspFee.amount",
    "body.CdtTrfTxInf.ChrgsInf.Agt": "$context.isoPostQuote.CdtTrfTxInf.CdtrAgt",
    "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket": "body.ilpPacket"
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.StsRsnInf.Rsn.Prtry": "body.errorInformation.errorCode",
    "body.TxInfAndSts.StsRsnInf.AddtlInf": [ "body.errorInformation.errorDescription", { "$transform": "toIsoErrorDescription" } ]
  }`
};

// src/mappings/fspiopiso20022/fxQuotes.ts
var fxQuotes = {
  post: `{
    "$noDefaults": "true",
    "body.conversionTerms.expiration": "body.GrpHdr.PmtInstrXpryDtTm",
    "body.conversionRequestId": "body.CdtTrfTxInf.PmtId.TxId",
    "body.conversionTerms.conversionId": "body.CdtTrfTxInf.PmtId.InstrId",
    "body.conversionTerms.determiningTransferId": "body.CdtTrfTxInf.PmtId.EndToEndId",
    "body.conversionTerms.initiatingFsp": "body.CdtTrfTxInf.Dbtr.FinInstnId.Othr.Id",
    "body.conversionTerms.counterPartyFsp": "body.CdtTrfTxInf.Cdtr.FinInstnId.Othr.Id",
    "body.conversionTerms.sourceAmount.currency": "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.Ccy",
    "body.conversionTerms.sourceAmount.amount": "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.ActiveOrHistoricCurrencyAndAmount",
    "body.conversionTerms.targetAmount.currency": "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy",
    "body.conversionTerms.targetAmount.amount": "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount",
    "body.conversionTerms.amountType": "body.CdtTrfTxInf.InstrForCdtrAgt.InstrInf"
  }`,
  put: `{
    "$noDefaults": "true",
    "params.ID": "body.CdtTrfTxInf.PmtId.TxId",
    "body.condition": "body.CdtTrfTxInf.VrfctnOfTerms.Sh256Sgntr", 
    "body.conversionTerms.conversionId": "body.CdtTrfTxInf.PmtId.InstrId",
    "body.conversionTerms.determiningTransferId": "body.CdtTrfTxInf.PmtId.EndToEndId",
    "body.conversionTerms.initiatingFsp": "body.CdtTrfTxInf.Dbtr.FinInstnId.Othr.Id",
    "body.conversionTerms.counterPartyFsp": "body.CdtTrfTxInf.Cdtr.FinInstnId.Othr.Id",
    "body.conversionTerms.sourceAmount.currency": "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.Ccy",
    "body.conversionTerms.sourceAmount.amount": "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.ActiveOrHistoricCurrencyAndAmount",
    "body.conversionTerms.targetAmount.currency": "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy",
    "body.conversionTerms.targetAmount.amount": "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount",
    "body.conversionTerms.expiration": "body.GrpHdr.PmtInstrXpryDtTm",
    "body.conversionTerms.amountType": "body.CdtTrfTxInf.InstrForCdtrAgt.InstrInf"
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.errorInformation.errorCode": "body.TxInfAndSts.StsRsnInf.Rsn.Prtry",
    "body.errorInformation.errorDescription": "body.TxInfAndSts.StsRsnInf.AddtlInf"
  }`
};
var fxQuotes_reverse = {
  post: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.conversionTerms.expiration",
    "body.CdtTrfTxInf.PmtId.TxId": "body.conversionRequestId",
    "body.CdtTrfTxInf.PmtId.InstrId": "body.conversionTerms.conversionId",
    "body.CdtTrfTxInf.PmtId.EndToEndId": "body.conversionTerms.determiningTransferId",
    "body.CdtTrfTxInf.Dbtr.FinInstnId.Othr.Id": "body.conversionTerms.initiatingFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.Dbtr.Id.OrgId.Othr.Id": "body.conversionTerms.initiatingFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.DbtrAgt.FinInstnId.Othr.Id": "body.conversionTerms.initiatingFsp",
    "body.CdtTrfTxInf.Cdtr.FinInstnId.Othr.Id": "body.conversionTerms.counterPartyFsp",  
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.Cdtr.Id.OrgId.Othr.Id": "body.conversionTerms.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.CdtrAgt.FinInstnId.Othr.Id": "body.conversionTerms.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.Ccy": "body.conversionTerms.sourceAmount.currency",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.ActiveOrHistoricCurrencyAndAmount": { "$alt": [ "body.conversionTerms.sourceAmount.amount", { "$transform": "fixed", "value": "0" } ] },
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.conversionTerms.targetAmount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": { "$alt": [ "body.conversionTerms.targetAmount.amount", { "$transform": "fixed", "value": "0" } ] },
    "body.CdtTrfTxInf.InstrForCdtrAgt.InstrInf": "body.conversionTerms.amountType"
  }`,
  put: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.conversionTerms.expiration",
    "body.CdtTrfTxInf.VrfctnOfTerms.Sh256Sgntr": "body.condition",
    "body.CdtTrfTxInf.PmtId.TxId": "params.ID",
    "body.CdtTrfTxInf.PmtId.InstrId": "body.conversionTerms.conversionId",
    "body.CdtTrfTxInf.PmtId.EndToEndId": "body.conversionTerms.determiningTransferId",
    "body.CdtTrfTxInf.Dbtr.FinInstnId.Othr.Id": "body.conversionTerms.initiatingFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.Dbtr.Id.OrgId.Othr.Id": "body.conversionTerms.initiatingFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.DbtrAgt.FinInstnId.Othr.Id": "body.conversionTerms.initiatingFsp",
    "body.CdtTrfTxInf.Cdtr.FinInstnId.Othr.Id": "body.conversionTerms.counterPartyFsp",  
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.Cdtr.Id.OrgId.Othr.Id": "body.conversionTerms.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.CdtrAgt.FinInstnId.Othr.Id": "body.conversionTerms.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.Ccy": "body.conversionTerms.sourceAmount.currency",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.ActiveOrHistoricCurrencyAndAmount": "body.conversionTerms.sourceAmount.amount",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.conversionTerms.targetAmount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.conversionTerms.targetAmount.amount",
    "body.CdtTrfTxInf.InstrForCdtrAgt.InstrInf": "body.conversionTerms.amountType"
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.StsRsnInf.Rsn.Prtry": "body.errorInformation.errorCode",
    "body.TxInfAndSts.StsRsnInf.AddtlInf": [ "body.errorInformation.errorDescription", { "$transform": "toIsoErrorDescription" } ]
  }`
};

// src/mappings/fspiopiso20022/transfers.ts
var transfers = {
  post: `{
    "$noDefaults": "true",
    "body.expiration": "body.GrpHdr.PmtInstrXpryDtTm",
    "body.transferId": "body.CdtTrfTxInf.PmtId.TxId",
    "body.payeeFsp": "body.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id",
    "body.payerFsp": "body.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id",
    "body.amount.currency": "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy",
    "body.amount.amount": "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount",
    "body.ilpPacket": "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket",
    "body.condition": ["body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket", { "$transform": "ilpPacketToCondition" }]
  }`,
  patch: `{
    "$noDefaults": "true",
    "body.completedTimestamp": "body.TxInfAndSts.PrcgDt.DtTm",
    "body.transferState": ["body.TxInfAndSts.TxSts", { "$transform": "toFspiopTransferState" }]
  }`,
  put: `{
    "$noDefaults": "true",
    "body.fulfilment": "body.TxInfAndSts.ExctnConf",
    "body.completedTimestamp": "body.TxInfAndSts.PrcgDt.DtTm",
    "body.transferState": ["body.TxInfAndSts.TxSts", { "$transform": "toFspiopTransferState" }]
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.errorInformation.errorCode": "body.TxInfAndSts.StsRsnInf.Rsn.Prtry",
    "body.errorInformation.errorDescription": "body.TxInfAndSts.StsRsnInf.AddtlInf"
  }`
};
var transfers_reverse = {
  postTesting: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.expiration",
    "body.CdtTrfTxInf.PmtId.TxId": "body.transferId",
    "body.CdtTrfTxInf.ChrgBr": { "$alt": [ "$context.isoPostQuoteResponse.CdtTrfTxInf.ChrgBr", { "$transform": "fixed", "value": "SHAR" } ] },
    "body.CdtTrfTxInf.Cdtr.Id.OrgId.Othr.Id": "body.payeeFsp",
    "body.CdtTrfTxInf.Dbtr.Id.OrgId.Othr.Id": "body.payerFsp",
    "body.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id": "body.payeeFsp",
    "body.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id": "body.payerFsp",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.amount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.amount.amount",
    "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket": "body.ilpPacket"
  }`,
  post: `{
      "$noDefaults": "true",
      "body.GrpHdr.MsgId": { "$transform": "generateID" },
      "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
      "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
      "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
      "body.GrpHdr.PmtInstrXpryDtTm": "body.expiration",
      "body.CdtTrfTxInf.PmtId.TxId": "body.transferId",
      "body.CdtTrfTxInf.ChrgBr": "$context.isoPostQuoteResponse.CdtTrfTxInf.ChrgBr",
      "body.CdtTrfTxInf.Cdtr": "$context.isoPostQuoteResponse.CdtTrfTxInf.Cdtr",
      "body.CdtTrfTxInf.Dbtr": "$context.isoPostQuoteResponse.CdtTrfTxInf.Dbtr",
      "body.CdtTrfTxInf.CdtrAgt.FinInstnId.Othr.Id": "body.payeeFsp",
      "body.CdtTrfTxInf.DbtrAgt.FinInstnId.Othr.Id": "body.payerFsp",
      "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.amount.currency",
      "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.amount.amount",
      "body.CdtTrfTxInf.VrfctnOfTerms.IlpV4PrepPacket": "body.ilpPacket"
  }`,
  patch: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.PrcgDt.DtTm": "body.completedTimestamp",
    "body.TxInfAndSts.TxSts": ["body.transferState", { "$transform": "toIsoTransferState" }]
  }`,
  put: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.ExctnConf": "body.fulfilment",
    "body.TxInfAndSts.PrcgDt.DtTm": "body.completedTimestamp",
    "body.TxInfAndSts.TxSts": ["body.transferState", { "$transform": "toIsoTransferState" }]
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.StsRsnInf.Rsn.Prtry": "body.errorInformation.errorCode",
    "body.TxInfAndSts.StsRsnInf.AddtlInf": [ "body.errorInformation.errorDescription", { "$transform": "toIsoErrorDescription" } ]
  }`
};

// src/mappings/fspiopiso20022/fxTransfers.ts
var fxTransfers = {
  post: `{
    "$noDefaults": "true",
    "body.expiration": "body.GrpHdr.PmtInstrXpryDtTm",
    "body.commitRequestId": "body.CdtTrfTxInf.PmtId.TxId",
    "body.determiningTransferId": "body.CdtTrfTxInf.PmtId.EndToEndId",
    "body.initiatingFsp": "body.CdtTrfTxInf.Dbtr.FinInstnId.Othr.Id",
    "body.counterPartyFsp": "body.CdtTrfTxInf.Cdtr.FinInstnId.Othr.Id",
    "body.sourceAmount.currency": "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.Ccy",
    "body.sourceAmount.amount": "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.ActiveOrHistoricCurrencyAndAmount",
    "body.targetAmount.currency": "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy",
    "body.targetAmount.amount": "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount",
    "body.condition": "body.CdtTrfTxInf.VrfctnOfTerms.Sh256Sgntr"
  }`,
  patch: `{
    "$noDefaults": "true",
    "body.completedTimestamp": "body.TxInfAndSts.PrcgDt.DtTm",
    "body.conversionState": ["body.TxInfAndSts.TxSts", { "$transform": "toFspiopTransferState" }]
  }`,
  put: `{
    "$noDefaults": "true",
    "body.fulfilment": "body.TxInfAndSts.ExctnConf",
    "body.completedTimestamp": "body.TxInfAndSts.PrcgDt.DtTm",
    "body.conversionState": ["body.TxInfAndSts.TxSts", { "$transform": "toFspiopTransferState" }]
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.errorInformation.errorCode": "body.TxInfAndSts.StsRsnInf.Rsn.Prtry",
    "body.errorInformation.errorDescription": "body.TxInfAndSts.StsRsnInf.AddtlInf"
  }`
};
var fxTransfers_reverse = {
  post: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.GrpHdr.NbOfTxs": { "$transform": "fixed", "value": "1" },
    "body.GrpHdr.SttlmInf.SttlmMtd": { "$transform": "fixed", "value": "CLRG" },
    "body.GrpHdr.PmtInstrXpryDtTm": "body.expiration",
    "body.CdtTrfTxInf.PmtId.TxId": "body.commitRequestId",
    "body.CdtTrfTxInf.PmtId.EndToEndId": "body.determiningTransferId",
    "body.CdtTrfTxInf.Dbtr.FinInstnId.Othr.Id": "body.initiatingFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.Dbtr.Id.OrgId.Othr.Id": "body.initiatingFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.DbtrAgt.FinInstnId.Othr.Id": "body.initiatingFsp",
    "body.CdtTrfTxInf.Cdtr.FinInstnId.Othr.Id": "body.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.Cdtr.Id.OrgId.Othr.Id": "body.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.CdtrAgt.FinInstnId.Othr.Id": "body.counterPartyFsp",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.Ccy": "body.sourceAmount.currency",
    "body.CdtTrfTxInf.UndrlygCstmrCdtTrf.InstdAmt.ActiveOrHistoricCurrencyAndAmount": "body.sourceAmount.amount",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.Ccy": "body.targetAmount.currency",
    "body.CdtTrfTxInf.IntrBkSttlmAmt.ActiveCurrencyAndAmount": "body.targetAmount.amount",
    "body.CdtTrfTxInf.VrfctnOfTerms.Sh256Sgntr": "body.condition"
  }`,
  patch: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.PrcgDt.DtTm": "body.completedTimestamp",
    "body.TxInfAndSts.TxSts": ["body.conversionState", { "$transform": "toIsoTransferState" }]
  }`,
  put: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.ExctnConf": "body.fulfilment",
    "body.TxInfAndSts.PrcgDt.DtTm": "body.completedTimestamp",
    "body.TxInfAndSts.TxSts": ["body.conversionState", { "$transform": "toIsoTransferState" }]
  }`,
  putError: `{
    "$noDefaults": "true",
    "body.GrpHdr.MsgId": { "$transform": "generateID" },
    "body.GrpHdr.CreDtTm": { "$transform": "datetimeNow" },
    "body.TxInfAndSts.StsRsnInf.Rsn.Prtry": "body.errorInformation.errorCode",
    "body.TxInfAndSts.StsRsnInf.AddtlInf": [ "body.errorInformation.errorDescription", { "$transform": "toIsoErrorDescription" } ]
  }`
};

// src/lib/transforms/pipeline.ts
var runPipeline = async (source, target, options) => {
  if (!options.hasOwnProperty("pipelineSteps") || !Array.isArray(options.pipelineSteps)) {
    throw new Error("runPipeline: options.pipelineSteps must be an array");
  }
  const { pipelineSteps, logger: logger2, ...stepOptions } = options;
  for (const step of pipelineSteps) {
    target = await step({ source, target, options: stepOptions, logger: logger2 });
  }
  return target;
};

// src/lib/transforms/extensions.ts
var applyUnrollExtensions = (params) => {
  const { source, target, options, logger: logger2 } = params;
  let extensionListProperty;
  if (options.applyUnrollExtensions?.extensionListProperty) {
    extensionListProperty = options.applyUnrollExtensions?.extensionListProperty;
  } else if (source.body?.errorInformation) {
    extensionListProperty = "body.errorInformation.extensionList";
  } else {
    extensionListProperty = "body.extensionList";
  }
  const extension = getProp(source, `${extensionListProperty}.extension`);
  if (!options.unrollExtensions || !extension) {
    logger2.debug("Skipping unrollExtensions", { source, target, options });
    return target;
  }
  const unrolled = unrollExtensions(extension);
  logger2.debug("Unrolled extensions", { source, unrolled });
  target.body = deepMerge(target.body, unrolled);
  return target;
};
var applyRollUpUnmappedAsExtensions = (params) => {
  const { source, target, options: { mapping }, options, logger: logger2 } = params;
  if (!options.rollUpUnmappedAsExtensions) {
    logger2.debug("Skipping rollUpUnmappedAsExtensions", { source, target, mapping, options });
    return target;
  }
  const extensions = rollUpUnmappedAsExtensions(source, mapping);
  logger2.debug("Rolled up unmapped properties into extensions", { source, mapping, extensions });
  if (extensions.length === 0) {
    logger2.debug("No unmapped properties to roll up", { source, mapping });
    return target;
  }
  let extensionListProperty;
  if (options.applyRollUpUnmappedAsExtensions?.extensionListProperty) {
    extensionListProperty = options.applyRollUpUnmappedAsExtensions?.extensionListProperty;
  } else if (target.body?.errorInformation) {
    extensionListProperty = "body.errorInformation.extensionList";
  } else {
    extensionListProperty = "body.extensionList";
  }
  const extensionProperty = `${extensionListProperty}.extension`;
  if (!hasProp(target, extensionProperty)) {
    setProp(target, extensionProperty, []);
  }
  let allExtensions = getProp(target, extensionProperty);
  allExtensions.push(...extensions);
  allExtensions = deduplicateObjectsArray(allExtensions, "key");
  setProp(target, extensionProperty, allExtensions);
  logger2.debug("Rolled up unmapped properties into extensions", { source, target, mapping, extensions });
  return target;
};

// src/lib/validation/index.ts
var import_path = __toESM(require("path"));
var import_node_cache = __toESM(require("node-cache"));

// src/lib/validation/validator.ts
var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"));
var import_openapi_backend = require("openapi-backend");
var import_fast_safe_stringify = __toESM(require("fast-safe-stringify"));
var Validator = class {
  apiDoc;
  apiSpec;
  apiValidator;
  ajvOpts = { allErrors: true, coerceTypes: true, strict: false };
  /**
   * @param apiDoc - The path to the OpenAPI document or the document itself
   */
  constructor(apiDoc) {
    this.apiDoc = apiDoc;
    this.apiSpec = {};
    this.apiValidator = {};
  }
  async initialize() {
    this.apiSpec = await import_swagger_parser.default.validate(this.apiDoc);
    this.apiValidator = new import_openapi_backend.OpenAPIValidator({ definition: this.apiSpec, ajvOpts: this.ajvOpts });
  }
  validateRequest(request, returnErrors = false) {
    const validation = this.apiValidator.validateRequest(request);
    if (validation.errors && validation.errors.length > 0) {
      if (returnErrors) return validation.errors;
      throw new Error(`Validation errors: ${(0, import_fast_safe_stringify.default)(validation.errors)}`);
    }
    return true;
  }
  validateBody(partialRequest, returnErrors = false) {
    const { body, path: path2, method } = partialRequest;
    const validation = this.apiValidator.validateRequest({ path: path2, method, body, headers: {} });
    if (validation.errors) {
      const bodyErrors = validation.errors.filter((error) => error.instancePath === "/requestBody");
      if (bodyErrors && bodyErrors.length > 0) {
        if (returnErrors) return bodyErrors;
        throw new Error(`Validation errors: ${(0, import_fast_safe_stringify.default)(bodyErrors)}`);
      }
    }
    return true;
  }
  validateHeaders(partialRequest, returnErrors = false) {
    const { headers, path: path2, method } = partialRequest;
    const validation = this.apiValidator.validateRequest({ path: path2, method, headers, body: {} });
    if (validation.errors) {
      const headersErrors = validation.errors.filter((error) => error.instancePath === "/header");
      if (headersErrors && headersErrors.length > 0) {
        if (returnErrors) return headersErrors;
        throw new Error(`Validation errors: ${(0, import_fast_safe_stringify.default)(headersErrors)}`);
      }
    }
    return true;
  }
};

// src/lib/validation/index.ts
var validatorsCache = new import_node_cache.default();
var getApiSpecPath = (apiName, version) => {
  let specFile;
  switch (apiName) {
    case "fspiop" /* FSPIOP */:
      specFile = `../docs/fspiop-rest-v${version}-openapi3-snippets.yaml`;
      break;
    case "iso" /* ISO20022 */:
      specFile = `../docs/fspiop-rest-v${version}-ISO20022-openapi3-snippets.yaml`;
      break;
    default:
      throw new Error(`Invalid API name: ${apiName} in getApiSpecPath`);
  }
  const specPath = import_path.default.join(import_path.default.dirname(require.resolve("@mojaloop/api-snippets")), specFile);
  return specPath;
};
var validateBody = async (body, spec) => {
  const apiSpecPath = getApiSpecPath(spec.name, spec.version);
  let validator = validatorsCache.get(apiSpecPath);
  if (!validator) {
    validator = new Validator(apiSpecPath);
    await validator.initialize();
    validatorsCache.set(apiSpecPath, validator);
  }
  return validator.validateBody({ body, path: spec.path, method: spec.method });
};
var applyTargetValidation = async (params) => {
  const { target, options, logger: logger2 } = params;
  if (!options.validateTarget) {
    logger2.debug("Skipping target validation", { target, options });
    return target;
  }
  const targetSpec = options.applyTargetValidation?.targetSpec;
  if (!targetSpec || !targetSpec.name || !targetSpec.path || !targetSpec.method) {
    logger2.error("Missing or invalid targetSpec in applyTargetValidation options", { target, targetSpec });
    throw new Error("Missing or invalid targetSpec in applyTargetValidation options");
  }
  await validateBody(target.body, targetSpec);
  return target;
};

// src/facades/fspiop.ts
var ISO20022Version = "2.0";
var { discovery_reverse: discovery_reverse2, quotes_reverse: quotes_reverse2, transfers_reverse: transfers_reverse2, fxQuotes_reverse: fxQuotes_reverse2 } = fspiopiso20022_exports;
var Config = { logger, isTestingMode: false, unrollExtensions: false, validateTarget: false };
var afterTransformSteps = [applyUnrollExtensions, applyTargetValidation];
var targetValidationConfig = (params) => ({
  applyTargetValidation: { targetSpec: { name: "iso" /* ISO20022 */, version: ISO20022Version, path: params.path, method: params.method } }
});
var createPipelineOptions = (options, mapping) => {
  return {
    ...options,
    mapping,
    pipelineSteps: afterTransformSteps,
    logger: Config.logger,
    unrollExtensions: hasProp(options, "unrollExtensions") ? !!options.unrollExtensions : Config.unrollExtensions,
    validateTarget: hasProp(options, "validateTarget") ? !!options.validateTarget : Config.validateTarget
  };
};
var FspiopTransformFacade = {
  configure: (config) => {
    validateConfig(config);
    if (config.logger && isContextLogger(config.logger)) Config.logger = config.logger;
    if (hasProp(config, "isTestingMode")) Config.isTestingMode = !!config.isTestingMode;
    if (hasProp(config, "unrollExtensions")) Config.unrollExtensions = !!config.unrollExtensions;
    if (hasProp(config, "validateTarget")) Config.validateTarget = !!config.validateTarget;
  },
  parties: {
    put: async (source, options = {}) => {
      if (!TypeGuards.FSPIOP.parties.put.isSource(source)) {
        throw new Error("Invalid source object for put parties");
      }
      if (!source.params.IdPath) {
        source.params.IdPath = `${source.params.Type}/${source.params.ID}`;
        if (source.params.SubId) {
          source.params.IdPath += `/${source.params.SubId}`;
        }
      }
      const mapping = options.overrideMapping || discovery_reverse2.parties.put;
      const target = await transformFn(source, {
        ...options,
        logger: Config.logger,
        mapping
      });
      const stepsConfig = {
        applyUnrollExtensions: { extensionListProperty: "body.party.partyIdInfo.extensionList" },
        ...targetValidationConfig({ path: "/parties/{Type}/{ID}/{SubId}", method: "put" })
      };
      options = { ...options, ...stepsConfig };
      const pipelineOptions = createPipelineOptions(options, mapping);
      return runPipeline(source, target, pipelineOptions);
    },
    putError: async (source, options = {}) => {
      if (!TypeGuards.FSPIOP.parties.putError.isSource(source)) {
        throw new Error("Invalid source object for put parties error");
      }
      if (!source.params.IdPa