@lendi/integrations-transform 1.5.6 → 1.5.9

package/lib/transform-events/transform-asset.js

@@ -1,343 +1,324 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-exports.__esModule = true;
-exports.normalizeAmounts = exports.determineOccupancy = exports.generatePropertyExpenses = exports.generateLivingExpenses = exports.getAssetMapping = exports.getPropertyType = exports.transformAsset = exports.residentialTypeList = exports.propertyTypeNameList = void 0;
-var lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
-var application_paths_1 = require("@lendi/integrations-credit-protocol/utils/application-paths");
-var lixi_internal_request_2 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
-var uuid_1 = require("uuid");
-var lodash_1 = require("lodash");
-var logger_1 = require("../logger");
-var enum_mappings_1 = require("../types/enum-mappings");
-var public_asset_1 = require("../types/events/public-asset");
-var public_expense_1 = require("../types/events/public-expense");
-var get_financial_institution_1 = require("../utils/get-financial-institution");
-var is_asset_type_1 = require("../utils/is-asset-type");
-var round_decimal_1 = require("../utils/round-decimal");
-var transform_asset_address_1 = require("./transform-asset-address");
-var transform_percent_owned_1 = require("./transform-percent-owned");
-var builder_type_1 = require("../types/enum-mappings/builder-type");
-var construction_type_1 = require("../types/enum-mappings/construction-type");
-var __1 = require("..");
-exports.propertyTypeNameList = Object.values(lixi_internal_request_2.Custom2PropertyTypeNameList);
-exports.residentialTypeList = Object.values(lixi_internal_request_1.ResidentialTypeList);
+import { Custom6TypeList, NonRealEstateAssetTypeList, OtherAssetTypeList, ResidentialTypeList, YesNoList, OccupancyList, } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
+import { paths } from '@lendi/integrations-credit-protocol/utils/application-paths';
+import { Custom1CategoryTypeNameList, Custom2PropertyTypeNameList, } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { v4 as uuidv4 } from 'uuid';
+import { isEmpty, set } from 'lodash';
+import { logger } from '../logger';
+import { assetTypeMapping, financialAssetMapping, incomeExpenseFrequencyMapping, livingExpenseMapping, primaryPurposeMapping, propertyExpenseCategoryMapping, propertyStatusMapping, propertyTypeMapping, toBePurchasedMapping, toBeUsedAsSecurityMapping, } from '../types/enum-mappings';
+import { AssetType, PropertyExpenseType, ZoneType, } from '../types/events/public-asset';
+import { Frequency } from '../types/events/public-expense';
+import { getFinancialInstitution } from '../utils/get-financial-institution';
+import { isFinancialAsset, isMotorVehicle, isOtherAsset, isRealEstateAsset } from '../utils/is-asset-type';
+import { roundDecimal } from '../utils/round-decimal';
+import { transformAddress } from './transform-asset-address';
+import { transformPercentOwned } from './transform-percent-owned';
+import { builderTypeMapping } from '../types/enum-mappings/builder-type';
+import { constructionTypeMapping } from '../types/enum-mappings/construction-type';
+import { booleanMapping } from '..';
+export const propertyTypeNameList = Object.values(Custom2PropertyTypeNameList);
+export const residentialTypeList = Object.values(ResidentialTypeList);
 // will add this path to protocol
-var constructionDetailsPath = "".concat(application_paths_1.paths.RealEstateAsset, ".ConstructionDetails");
-var constructionDetailsMapping = {
-    builderType: "".concat(constructionDetailsPath, ".@BuilderType"),
-    buildPriceAmount: "".concat(constructionDetailsPath, ".@BuildPriceAmount"),
-    constructionType: "".concat(constructionDetailsPath, ".@Type"),
-    estimatedValue: "".concat(constructionDetailsPath, ".@TotalAmount"),
-    isFixedPriceContract: "".concat(constructionDetailsPath, ".@FixedPriceContract"),
-    landEstimatedValue: "".concat(constructionDetailsPath, ".@LandValue"),
-    otherConstructionCosts: "".concat(constructionDetailsPath, ".@OutOfContractItemsCost")
+const constructionDetailsPath = `${paths.RealEstateAsset}.ConstructionDetails`;
+const constructionDetailsMapping = {
+    builderType: `${constructionDetailsPath}.@BuilderType`,
+    buildPriceAmount: `${constructionDetailsPath}.@BuildPriceAmount`,
+    constructionType: `${constructionDetailsPath}.@Type`,
+    estimatedValue: `${constructionDetailsPath}.@TotalAmount`,
+    isFixedPriceContract: `${constructionDetailsPath}.@FixedPriceContract`,
+    landEstimatedValue: `${constructionDetailsPath}.@LandValue`,
+    otherConstructionCosts: `${constructionDetailsPath}.@OutOfContractItemsCost`,
 };
 /**
  * Generates a partial internal request from a partial public asset event.
  *
  * @param {Payload} asset - A partial public asset.
- * @return {PartialApplication} A partial InternalRequest.
+ * @returns {PartialApplication} A partial InternalRequest.
  */
-function transformAsset(_a) {
-    var asset = _a.asset, applicationId = _a.applicationId, id = _a.id;
-    var isPropertyAsset = (0, is_asset_type_1.isRealEstateAsset)(asset);
-    var idPath = isPropertyAsset ? "".concat(application_paths_1.paths.RealEstateAsset, ".@UniqueID") : "".concat(application_paths_1.paths.NonRealEstateAsset, ".@UniqueID");
-    var addressId = "".concat(id, "-address");
-    var assetMapping = getAssetMapping(asset);
-    var partialApplication = {};
-    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
-    (0, lodash_1.set)(partialApplication, idPath, id);
+export function transformAsset({ asset, applicationId, id }) {
+    var _a;
+    const isPropertyAsset = isRealEstateAsset(asset);
+    const idPath = isPropertyAsset ? `${paths.RealEstateAsset}.@UniqueID` : `${paths.NonRealEstateAsset}.@UniqueID`;
+    const addressId = `${id}-address`;
+    const assetMapping = getAssetMapping(asset);
+    const partialApplication = {};
+    set(partialApplication, paths.ApplicationId, applicationId);
+    set(partialApplication, idPath, id);
     if (isPropertyAsset) {
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.RealEstateAsset, ".@MultipleDwellings"), lixi_internal_request_1.YesNoList.No);
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.RealEstateAsset, ".@x_Address"), addressId);
+        set(partialApplication, `${paths.RealEstateAsset}.@MultipleDwellings`, YesNoList.No);
+        set(partialApplication, `${paths.RealEstateAsset}.@x_Address`, addressId);
     }
     else {
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".@Type"), enum_mappings_1.assetTypeMapping[asset.type]);
+        set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, assetTypeMapping[asset.type]);
     }
-    if ((0, is_asset_type_1.isFinancialAsset)(asset)) {
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".@Type"), lixi_internal_request_1.NonRealEstateAssetTypeList.FinancialAsset);
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".FinancialAsset.@Type"), enum_mappings_1.financialAssetMapping[asset.type]);
+    if (isFinancialAsset(asset)) {
+        set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, NonRealEstateAssetTypeList.FinancialAsset);
+        set(partialApplication, `${paths.NonRealEstateAsset}.FinancialAsset.@Type`, financialAssetMapping[asset.type]);
     }
-    if ((0, is_asset_type_1.isOtherAsset)(asset)) {
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".@Type"), lixi_internal_request_1.NonRealEstateAssetTypeList.Other);
+    if (isOtherAsset(asset)) {
+        set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, NonRealEstateAssetTypeList.Other);
     }
     switch (asset.type) {
-        case public_asset_1.AssetType.Vehicle:
-            (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".@Type"), lixi_internal_request_1.NonRealEstateAssetTypeList.MotorVehicleAndTransport);
+        case AssetType.Vehicle:
+            set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, NonRealEstateAssetTypeList.MotorVehicleAndTransport);
             break;
-        case public_asset_1.AssetType.HomeContents:
-            (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".OtherAsset.@Type"), lixi_internal_request_1.OtherAssetTypeList.HomeContents);
+        case AssetType.HomeContents:
+            set(partialApplication, `${paths.NonRealEstateAsset}.OtherAsset.@Type`, OtherAssetTypeList.HomeContents);
             break;
-        case public_asset_1.AssetType.Gifts:
-            (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".OtherAsset.@Description"), asset.description || 'Asset Gifts');
+        case AssetType.Gifts:
+            set(partialApplication, `${paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description || 'Asset Gifts');
             break;
-        case public_asset_1.AssetType.OtherAsset:
+        case AssetType.OtherAsset:
             if (asset.description) {
-                (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.NonRealEstateAsset, ".OtherAsset.@Description"), asset.description);
+                set(partialApplication, `${paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description);
             }
             break;
     }
-    for (var _i = 0, _b = Object.entries(asset); _i < _b.length; _i++) {
-        var _c = _b[_i], key = _c[0], value = _c[1];
+    for (const [key, value] of Object.entries(asset)) {
         if (assetMapping[key]) {
             switch (key) {
                 case 'contractDetails':
-                    var contractDate = value.contractDate;
+                    const { contractDate } = value;
                     if (contractDate)
-                        (0, lodash_1.set)(partialApplication, assetMapping.contractDate, contractDate);
+                        set(partialApplication, assetMapping.contractDate, contractDate);
                     break;
                 case 'primaryPurpose':
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.primaryPurposeMapping[value]);
+                    set(partialApplication, assetMapping[key], primaryPurposeMapping[value]);
                     break;
                 case 'toBePurchased':
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.toBePurchasedMapping[value]);
+                    set(partialApplication, assetMapping[key], toBePurchasedMapping[value]);
                     break;
                 case 'propertyExpenses':
-                    if (!asset.percentOwned) {
+                    if (!asset.percentOwned || isEmpty((_a = asset.percentOwned) === null || _a === void 0 ? void 0 : _a.owners)) {
                         break;
                     }
-                    var propertyExpenses = generatePropertyExpenses(value);
-                    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.RealEstateAsset, ".PropertyExpense"), propertyExpenses);
-                    var livingExpenses = generateLivingExpenses(asset.percentOwned, id, value);
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], livingExpenses);
-                    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.RealEstateAsset, ".@Occupancy"), determineOccupancy(value));
+                    const propertyExpenses = generatePropertyExpenses(value);
+                    set(partialApplication, `${paths.RealEstateAsset}.PropertyExpense`, propertyExpenses);
+                    const livingExpenses = generateLivingExpenses(asset.percentOwned, id, value);
+                    set(partialApplication, assetMapping[key], livingExpenses);
+                    set(partialApplication, `${paths.RealEstateAsset}.@Occupancy`, determineOccupancy(value));
                     break;
                 case 'propertyStatus':
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.propertyStatusMapping[value]);
+                    set(partialApplication, assetMapping[key], propertyStatusMapping[value]);
                     break;
                 case 'toBeUsedAsSecurity':
                     if (isPropertyAsset)
-                        (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.toBeUsedAsSecurityMapping[value]);
+                        set(partialApplication, assetMapping[key], toBeUsedAsSecurityMapping[value]);
                     break;
                 case 'propertyType':
-                    var propertyTypeMapping_1 = getPropertyType(value);
-                    if (!propertyTypeMapping_1) {
-                        logger_1.logger.warn({ message: "Unknown propertyType ".concat(value, " for asset ").concat(id), applicationId: applicationId });
+                    const propertyTypeMapping = getPropertyType(value);
+                    if (!propertyTypeMapping) {
+                        logger.warn({ message: `Unknown propertyType ${value} for asset ${id}`, applicationId });
                     }
-                    var path = propertyTypeMapping_1.path, mappedValue = propertyTypeMapping_1.value;
-                    (0, lodash_1.set)(partialApplication, path, mappedValue);
+                    const { path, value: mappedValue } = propertyTypeMapping;
+                    set(partialApplication, path, mappedValue);
                     break;
                 case 'zoneType':
-                    if (asset.zoneType === public_asset_1.ZoneType.Commercial) {
-                        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.RealEstateAsset, ".Commercial.@Type"), lixi_internal_request_1.OtherAssetTypeList.Other);
-                        (0, lodash_1.set)(partialApplication, assetMapping[key], lixi_internal_request_1.Custom6TypeList.Commercial);
+                    if (asset.zoneType === ZoneType.Commercial) {
+                        set(partialApplication, `${paths.RealEstateAsset}.Commercial.@Type`, OtherAssetTypeList.Other);
+                        set(partialApplication, assetMapping[key], Custom6TypeList.Commercial);
                     }
                     else {
-                        (0, lodash_1.set)(partialApplication, assetMapping[key], lixi_internal_request_1.Custom6TypeList.Residential);
+                        set(partialApplication, assetMapping[key], Custom6TypeList.Residential);
                     }
                     break;
                 case 'financialInstitution':
-                    if ((0, is_asset_type_1.isFinancialAsset)(asset)) {
-                        var financialInstitution = (0, get_financial_institution_1.getFinancialInstitution)(value.toString());
-                        (0, lodash_1.set)(partialApplication, assetMapping[key], financialInstitution);
+                    if (isFinancialAsset(asset)) {
+                        const financialInstitution = getFinancialInstitution(value.toString());
+                        set(partialApplication, assetMapping[key], financialInstitution);
                     }
                     break;
                 case 'year':
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], value.toString());
+                    set(partialApplication, assetMapping[key], value.toString());
                     break;
                 case 'address':
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], (0, transform_asset_address_1.transformAddress)(value, addressId));
+                    set(partialApplication, assetMapping[key], transformAddress(value, addressId));
                     break;
                 case 'isConstruction':
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], (0, __1.booleanMapping)(value));
+                    set(partialApplication, assetMapping[key], booleanMapping(value));
                     break;
                 case 'percentOwned':
-                    var percentOwned = (0, transform_percent_owned_1.transformPercentOwned)(value);
+                    const percentOwned = transformPercentOwned(value);
                     if (percentOwned) {
-                        (0, lodash_1.set)(partialApplication, assetMapping[key], percentOwned);
+                        set(partialApplication, assetMapping[key], percentOwned);
                     }
                     break;
                 case 'constructionDetails':
-                    for (var _d = 0, _e = Object.entries(value); _d < _e.length; _d++) {
-                        var _f = _e[_d], key_1 = _f[0], constructionDetailsValue = _f[1];
-                        switch (key_1) {
+                    for (const [key, constructionDetailsValue] of Object.entries(value)) {
+                        switch (key) {
                             case 'builderType':
-                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key_1], builder_type_1.builderTypeMapping[constructionDetailsValue]);
+                                set(partialApplication, constructionDetailsMapping[key], builderTypeMapping[constructionDetailsValue]);
                                 break;
                             case 'constructionType':
-                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key_1], construction_type_1.constructionTypeMapping[constructionDetailsValue]);
+                                set(partialApplication, constructionDetailsMapping[key], constructionTypeMapping[constructionDetailsValue]);
                                 break;
                             case 'isFixedPriceContract':
-                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key_1], (0, __1.booleanMapping)(constructionDetailsValue));
+                                set(partialApplication, constructionDetailsMapping[key], booleanMapping(constructionDetailsValue));
                                 break;
                             default:
-                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key_1], constructionDetailsValue);
+                                set(partialApplication, constructionDetailsMapping[key], constructionDetailsValue);
                                 break;
                         }
                     }
                     break;
                 case 'estimatedValue':
                     if (asset.isConstruction) {
-                        (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], value);
+                        set(partialApplication, constructionDetailsMapping[key], value);
                     }
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], value);
+                    set(partialApplication, assetMapping[key], value);
                     break;
                 default:
-                    (0, lodash_1.set)(partialApplication, assetMapping[key], value);
+                    set(partialApplication, assetMapping[key], value);
                     break;
             }
         }
     }
     return partialApplication;
 }
-exports.transformAsset = transformAsset;
 /**
  * @description Map the propertyType to a RealEstateAsset path and the value.
  * @param {PropertyType} propertyType - A propertyType.
  * @returns {PropertyTypeMapping | null} A path and value to be used for property type mapping.
  */
-function getPropertyType(propertyType) {
-    var value = enum_mappings_1.propertyTypeMapping[propertyType];
-    if (exports.residentialTypeList.includes(value)) {
+export function getPropertyType(propertyType) {
+    const value = propertyTypeMapping[propertyType];
+    if (residentialTypeList.includes(value)) {
         return {
-            path: "".concat(application_paths_1.paths.RealEstateAsset, ".Residential"),
+            path: `${paths.RealEstateAsset}.Residential`,
             value: {
-                '@Type': value
-            }
+                '@Type': value,
+            },
         };
     }
-    if (exports.propertyTypeNameList.includes(value)) {
+    if (propertyTypeNameList.includes(value)) {
         return {
-            path: "".concat(application_paths_1.paths.RealEstateAsset, ".PropertyType"),
+            path: `${paths.RealEstateAsset}.PropertyType`,
             value: {
                 '@PropertyTypeName': value,
-                '@CategoryTypeName': lixi_internal_request_2.Custom1CategoryTypeNameList.Residential
-            }
+                '@CategoryTypeName': Custom1CategoryTypeNameList.Residential,
+            },
         };
     }
     return null;
 }
-exports.getPropertyType = getPropertyType;
 /**
  * @description Get the asset transform mapping for various asset types.
  * @param {Asset} asset An Asset
  * @returns {Record<string, string>} Asset Transform Mapping.
  */
-function getAssetMapping(asset) {
-    var estimatedValue = "".concat(application_paths_1.paths.NonRealEstateAsset, ".EstimatedValue.@Value");
-    var percentOwned = "".concat(application_paths_1.paths.NonRealEstateAsset, ".PercentOwned");
-    var baseMapping = {
-        estimatedValue: estimatedValue,
-        percentOwned: percentOwned
+export function getAssetMapping(asset) {
+    let estimatedValue = `${paths.NonRealEstateAsset}.EstimatedValue.@Value`;
+    let percentOwned = `${paths.NonRealEstateAsset}.PercentOwned`;
+    const baseMapping = {
+        estimatedValue,
+        percentOwned,
     };
-    if ((0, is_asset_type_1.isRealEstateAsset)(asset)) {
-        estimatedValue = "".concat(application_paths_1.paths.RealEstateAsset, ".EstimatedValue.@Value");
-        percentOwned = "".concat(application_paths_1.paths.RealEstateAsset, ".PercentOwned");
+    if (isRealEstateAsset(asset)) {
+        estimatedValue = `${paths.RealEstateAsset}.EstimatedValue.@Value`;
+        percentOwned = `${paths.RealEstateAsset}.PercentOwned`;
         return {
-            address: application_paths_1.paths.Address,
+            address: paths.Address,
             contractDetails: 'contractDetails',
-            contractDate: "".concat(application_paths_1.paths.RealEstateAsset, ".ContractDetails.@ContractDate"),
-            estimatedValue: estimatedValue,
-            percentOwned: percentOwned,
-            primaryPurpose: "".concat(application_paths_1.paths.RealEstateAsset, ".@PrimaryPurpose"),
-            propertyExpenses: application_paths_1.paths.LivingExpenses,
-            propertyStatus: "".concat(application_paths_1.paths.RealEstateAsset, ".@Status"),
-            propertyType: "".concat(application_paths_1.paths.RealEstateAsset, ".Residential"),
-            toBePurchased: "".concat(application_paths_1.paths.RealEstateAsset, ".@Transaction"),
-            toBeUsedAsSecurity: "".concat(application_paths_1.paths.RealEstateAsset, ".@ToBeUsedAsSecurity"),
-            zoneType: "".concat(application_paths_1.paths.RealEstateAsset, ".Zoning.@Type"),
-            isConstruction: "".concat(application_paths_1.paths.RealEstateAsset, ".@Construction"),
-            constructionDetails: "".concat(application_paths_1.paths.RealEstateAsset, ".ConstructionDetails")
+            contractDate: `${paths.RealEstateAsset}.ContractDetails.@ContractDate`,
+            estimatedValue,
+            percentOwned,
+            primaryPurpose: `${paths.RealEstateAsset}.@PrimaryPurpose`,
+            propertyExpenses: paths.LivingExpenses,
+            propertyStatus: `${paths.RealEstateAsset}.@Status`,
+            propertyType: `${paths.RealEstateAsset}.Residential`,
+            toBePurchased: `${paths.RealEstateAsset}.@Transaction`,
+            toBeUsedAsSecurity: `${paths.RealEstateAsset}.@ToBeUsedAsSecurity`,
+            zoneType: `${paths.RealEstateAsset}.Zoning.@Type`,
+            isConstruction: `${paths.RealEstateAsset}.@Construction`,
+            constructionDetails: `${paths.RealEstateAsset}.ConstructionDetails`,
         };
     }
-    if ((0, is_asset_type_1.isMotorVehicle)(asset)) {
-        return __assign(__assign({}, baseMapping), { make: "".concat(application_paths_1.paths.NonRealEstateAsset, ".MotorVehicle.@Make"), model: "".concat(application_paths_1.paths.NonRealEstateAsset, ".MotorVehicle.@Model"), year: "".concat(application_paths_1.paths.NonRealEstateAsset, ".MotorVehicle.@Year") });
+    if (isMotorVehicle(asset)) {
+        return Object.assign(Object.assign({}, baseMapping), { make: `${paths.NonRealEstateAsset}.MotorVehicle.@Make`, model: `${paths.NonRealEstateAsset}.MotorVehicle.@Model`, year: `${paths.NonRealEstateAsset}.MotorVehicle.@Year` });
     }
-    if ((0, is_asset_type_1.isFinancialAsset)(asset)) {
-        return __assign(__assign({}, baseMapping), { financialInstitution: "".concat(application_paths_1.paths.NonRealEstateAsset, ".FinancialAsset.AccountNumber.@FinancialInstitution"), financialInstitutionAccountNumber: "".concat(application_paths_1.paths.NonRealEstateAsset, ".FinancialAsset.AccountNumber.@AccountNumber"), financialInstitutionBsb: "".concat(application_paths_1.paths.NonRealEstateAsset, ".FinancialAsset.AccountNumber.@BSB") });
+    if (isFinancialAsset(asset)) {
+        return Object.assign(Object.assign({}, baseMapping), { financialInstitution: `${paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@FinancialInstitution`, financialInstitutionAccountNumber: `${paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@AccountNumber`, financialInstitutionBsb: `${paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@BSB` });
     }
     return baseMapping;
 }
-exports.getAssetMapping = getAssetMapping;
 /**
  * Creates living expense items from a propertyExpense object.
  *
  * @param percentOwned: owners of the property
  * @param assetId: Asset id
  * @param propertyExpenses: propertyExpenses items
+ * @param percentOwned
+ * @param assetId
+ * @param propertyExpenses
  */
-function generateLivingExpenses(percentOwned, assetId, propertyExpenses) {
-    var livingExpenses = [];
-    var filteredPropertyExpenses = propertyExpenses.filter(function (expense) { return expense.amount !== undefined; });
-    percentOwned.owners.forEach(function (owner) {
-        var expenses = filteredPropertyExpenses.map(function (expense) {
+export function generateLivingExpenses(percentOwned, assetId, propertyExpenses) {
+    let livingExpenses = [];
+    const filteredPropertyExpenses = propertyExpenses.filter((expense) => expense.amount !== undefined);
+    percentOwned.owners.forEach((owner) => {
+        const expenses = filteredPropertyExpenses.map((expense) => {
             normalizeAmounts(expense);
             return {
-                '@Amount': (0, round_decimal_1.roundDecimal)(expense.amount * owner.percent),
-                '@Category': enum_mappings_1.livingExpenseMapping[expense.type],
-                '@Frequency': enum_mappings_1.incomeExpenseFrequencyMapping[expense.frequency],
-                '@UniqueID': "".concat((0, uuid_1.v4)(), "--").concat(assetId),
+                '@Amount': roundDecimal(expense.amount * owner.percent),
+                '@Category': livingExpenseMapping[expense.type],
+                '@Frequency': incomeExpenseFrequencyMapping[expense.frequency],
+                '@UniqueID': `${uuidv4()}--${assetId}`,
                 PercentResponsible: {
                     Owner: [
                         {
                             '@Percent': 100,
-                            '@x_Party': owner.applicantId
+                            '@x_Party': owner.applicantId,
                         },
-                    ]
-                }
+                    ],
+                },
             };
         });
         livingExpenses = livingExpenses.concat(expenses);
     });
     return livingExpenses;
 }
-exports.generateLivingExpenses = generateLivingExpenses;
 /**
  * Creates PropertyExpense array on RealEstateAsset from the same array on the event.
+ *
  * @param propertyExpenses
  */
-function generatePropertyExpenses(propertyExpenses) {
+export function generatePropertyExpenses(propertyExpenses) {
     return propertyExpenses
-        .filter(function (expense) { return expense.amount !== undefined; })
-        .map(function (expense) {
+        .filter((expense) => expense.amount !== undefined)
+        .map((expense) => {
         normalizeAmounts(expense);
         return {
             '@Amount': expense.amount,
-            '@Category': enum_mappings_1.propertyExpenseCategoryMapping[expense.type],
-            '@Frequency': enum_mappings_1.incomeExpenseFrequencyMapping[expense.frequency]
+            '@Category': propertyExpenseCategoryMapping[expense.type],
+            '@Frequency': incomeExpenseFrequencyMapping[expense.frequency],
         };
     });
 }
-exports.generatePropertyExpenses = generatePropertyExpenses;
 /**
  * Determines the occupancy based on the list of property expense types available.
+ *
  * @param propertyExpenses
  */
-function determineOccupancy(propertyExpenses) {
-    var propertyExpenseCategoryList = propertyExpenses.map(function (expense) { return expense.type; });
-    if (propertyExpenseCategoryList.includes(public_asset_1.PropertyExpenseType.InvestmentPropertyRunningCosts)) {
-        return lixi_internal_request_1.OccupancyList.NonOwner;
+export function determineOccupancy(propertyExpenses) {
+    const propertyExpenseCategoryList = propertyExpenses.map((expense) => expense.type);
+    if (propertyExpenseCategoryList.includes(PropertyExpenseType.InvestmentPropertyRunningCosts)) {
+        return OccupancyList.NonOwner;
     }
-    else if (propertyExpenseCategoryList.includes(public_asset_1.PropertyExpenseType.PrimaryResidenceRunningCosts && public_asset_1.PropertyExpenseType.SecondaryResidenceRunningCosts)) {
-        return lixi_internal_request_1.OccupancyList.OwnerSecondary;
+    else if (propertyExpenseCategoryList.includes(PropertyExpenseType.PrimaryResidenceRunningCosts && PropertyExpenseType.SecondaryResidenceRunningCosts)) {
+        return OccupancyList.OwnerSecondary;
     }
-    else if (propertyExpenseCategoryList.some(function (item) {
-        return item !== public_asset_1.PropertyExpenseType.SecondaryResidenceRunningCosts &&
-            item === public_asset_1.PropertyExpenseType.PrimaryResidenceRunningCosts;
-    })) {
-        return lixi_internal_request_1.OccupancyList.OwnerPrimary;
+    else if (propertyExpenseCategoryList.some((item) => item !== PropertyExpenseType.SecondaryResidenceRunningCosts &&
+        item === PropertyExpenseType.PrimaryResidenceRunningCosts)) {
+        return OccupancyList.OwnerPrimary;
     }
 }
-exports.determineOccupancy = determineOccupancy;
 /**
  * Calculates the correct amount and frequency.
+ *
  * @param expense
  */
-function normalizeAmounts(expense) {
-    if (expense.frequency === public_expense_1.Frequency.Quarterly) {
-        expense.frequency = public_expense_1.Frequency.Yearly;
+export function normalizeAmounts(expense) {
+    if (expense.frequency === Frequency.Quarterly) {
+        expense.frequency = Frequency.Yearly;
         expense.amount *= 4;
     }
     return expense;
 }
-exports.normalizeAmounts = normalizeAmounts;

package/lib/transform-events/transform-expenses.d.ts

@@ -15,6 +15,10 @@ export declare function transformExpenses(expense: ExpensePayload): PartialAppli
  * @param applicantId: Event applicantId.
  * @param index: Index of the map.
  * @param id: Id of the event.
+ * @param expense
+ * @param applicantId
+ * @param index
+ * @param id
  */
 export declare function transformExpense(expense: Expense, applicantId: string, index: number, id: string): LivingExpense | OtherCommitment;
 /**