@lendi/act-credit-decisions-transform 2.0.0

package/lib/types/events/public-required-document.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = exports.Status = exports.IssuingCountry = exports.IDType = exports.IDTitle = exports.Gender = exports.AustralianState = void 0;
+var AustralianState;
+(function (AustralianState) {
+    AustralianState["Act"] = "ACT";
+    AustralianState["NT"] = "NT";
+    AustralianState["Nsw"] = "NSW";
+    AustralianState["Qld"] = "QLD";
+    AustralianState["Sa"] = "SA";
+    AustralianState["Tas"] = "TAS";
+    AustralianState["Vic"] = "VIC";
+    AustralianState["Wa"] = "WA";
+})(AustralianState = exports.AustralianState || (exports.AustralianState = {}));
+var Gender;
+(function (Gender) {
+    Gender["Female"] = "FEMALE";
+    Gender["Male"] = "MALE";
+})(Gender = exports.Gender || (exports.Gender = {}));
+var IDTitle;
+(function (IDTitle) {
+    IDTitle["DR"] = "DR";
+    IDTitle["MS"] = "MS";
+    IDTitle["Miss"] = "MISS";
+    IDTitle["Mr"] = "MR";
+    IDTitle["Mrs"] = "MRS";
+    IDTitle["Other"] = "OTHER";
+    IDTitle["Unknown"] = "UNKNOWN";
+})(IDTitle = exports.IDTitle || (exports.IDTitle = {}));
+/**
+ * ID Type
+ */
+var IDType;
+(function (IDType) {
+    IDType["AustralianDriverLicense"] = "australian_driver_license";
+    IDType["NationalIDCard"] = "national_id_card";
+    IDType["Passport"] = "passport";
+})(IDType = exports.IDType || (exports.IDType = {}));
+var IssuingCountry;
+(function (IssuingCountry) {
+    IssuingCountry["Afghanistan"] = "Afghanistan";
+    IssuingCountry["Albania"] = "Albania";
+    IssuingCountry["Algeria"] = "Algeria";
+    IssuingCountry["AmericanSamoa"] = "American Samoa";
+    IssuingCountry["Andorra"] = "Andorra";
+    IssuingCountry["Angola"] = "Angola";
+    IssuingCountry["Anguilla"] = "Anguilla";
+    IssuingCountry["Antarctica"] = "Antarctica";
+    IssuingCountry["AntiguaAndBarbuda"] = "Antigua And Barbuda";
+    IssuingCountry["Argentina"] = "Argentina";
+    IssuingCountry["Armenia"] = "Armenia";
+    IssuingCountry["Aruba"] = "Aruba";
+    IssuingCountry["Australia"] = "Australia";
+    IssuingCountry["Austria"] = "Austria";
+    IssuingCountry["Azerbaijan"] = "Azerbaijan";
+    IssuingCountry["Bahamas"] = "Bahamas";
+    IssuingCountry["Bahrain"] = "Bahrain";
+    IssuingCountry["Bangladesh"] = "Bangladesh";
+    IssuingCountry["Barbados"] = "Barbados";
+    IssuingCountry["Belarus"] = "Belarus";
+    IssuingCountry["Belgium"] = "Belgium";
+    IssuingCountry["Belize"] = "Belize";
+    IssuingCountry["Benin"] = "Benin";
+    IssuingCountry["Bermuda"] = "Bermuda";
+    IssuingCountry["Bhutan"] = "Bhutan";
+    IssuingCountry["Bolivia"] = "Bolivia";
+    IssuingCountry["BosniaAndHerzegovina"] = "Bosnia And Herzegovina";
+    IssuingCountry["Botswana"] = "Botswana";
+    IssuingCountry["BouvetIsland"] = "Bouvet Island";
+    IssuingCountry["Brazil"] = "Brazil";
+    IssuingCountry["BritishIndianOceanTerritory"] = "British Indian Ocean Territory";
+    IssuingCountry["BritishVirginIslands"] = "British Virgin Islands";
+    IssuingCountry["BruneiDarussalam"] = "Brunei Darussalam";
+    IssuingCountry["Bulgaria"] = "Bulgaria";
+    IssuingCountry["BurkinaFaso"] = "Burkina Faso";
+    IssuingCountry["Burundi"] = "Burundi";
+    IssuingCountry["Cambodia"] = "Cambodia";
+    IssuingCountry["Cameroon"] = "Cameroon";
+    IssuingCountry["Canada"] = "Canada";
+    IssuingCountry["CapeVerde"] = "Cape Verde";
+    IssuingCountry["CaymanIslands"] = "Cayman Islands";
+    IssuingCountry["CentralAfricanRepublic"] = "Central African Republic";
+    IssuingCountry["Chad"] = "Chad";
+    IssuingCountry["Chile"] = "Chile";
+    IssuingCountry["China"] = "China";
+    IssuingCountry["ChristmasIsland"] = "Christmas Island";
+    IssuingCountry["CocosKeelingIslands"] = "Cocos (Keeling) Islands";
+    IssuingCountry["Colombia"] = "Colombia";
+    IssuingCountry["Comoros"] = "Comoros";
+    IssuingCountry["CookIslands"] = "Cook Islands";
+    IssuingCountry["CostaRica"] = "Costa Rica";
+    IssuingCountry["CoteDIvoire"] = "Cote D'ivoire";
+    IssuingCountry["Croatia"] = "Croatia";
+    IssuingCountry["Cuba"] = "Cuba";
+    IssuingCountry["Cyprus"] = "Cyprus";
+    IssuingCountry["CzechRepublic"] = "Czech Republic";
+    IssuingCountry["DemocraticPeopleSRepublicOfKorea"] = "Democratic People's Republic of Korea";
+    IssuingCountry["DemocraticRepublicOfTheCongo"] = "Democratic Republic Of The Congo";
+    IssuingCountry["Denmark"] = "Denmark";
+    IssuingCountry["Djibouti"] = "Djibouti";
+    IssuingCountry["Dominica"] = "Dominica";
+    IssuingCountry["DominicanRepublic"] = "Dominican Republic";
+    IssuingCountry["EastTimor"] = "East Timor";
+    IssuingCountry["Ecuador"] = "Ecuador";
+    IssuingCountry["Egypt"] = "Egypt";
+    IssuingCountry["ElSalvador"] = "El Salvador";
+    IssuingCountry["EquatorialGuinea"] = "Equatorial Guinea";
+    IssuingCountry["Eritrea"] = "Eritrea";
+    IssuingCountry["Estonia"] = "Estonia";
+    IssuingCountry["Ethiopia"] = "Ethiopia";
+    IssuingCountry["FalklandIslands"] = "Falkland Islands";
+    IssuingCountry["FaroeIslands"] = "Faroe Islands";
+    IssuingCountry["FederatedStatesOfMicronesia"] = "Federated States Of Micronesia";
+    IssuingCountry["Fiji"] = "Fiji";
+    IssuingCountry["Finland"] = "Finland";
+    IssuingCountry["France"] = "France";
+    IssuingCountry["FrenchGuiana"] = "French Guiana";
+    IssuingCountry["FrenchPolynesia"] = "French Polynesia";
+    IssuingCountry["FrenchSouthernTerritories"] = "French Southern Territories";
+    IssuingCountry["Gabon"] = "Gabon";
+    IssuingCountry["Gambia"] = "Gambia";
+    IssuingCountry["Georgia"] = "Georgia";
+    IssuingCountry["Germany"] = "Germany";
+    IssuingCountry["Ghana"] = "Ghana";
+    IssuingCountry["Gibraltar"] = "Gibraltar";
+    IssuingCountry["Greece"] = "Greece";
+    IssuingCountry["Greenland"] = "Greenland";
+    IssuingCountry["Grenada"] = "Grenada";
+    IssuingCountry["Guadeloupe"] = "Guadeloupe";
+    IssuingCountry["Guam"] = "Guam";
+    IssuingCountry["Guatemala"] = "Guatemala";
+    IssuingCountry["Guinea"] = "Guinea";
+    IssuingCountry["GuineaBissau"] = "Guinea-bissau";
+    IssuingCountry["Guyana"] = "Guyana";
+    IssuingCountry["Haiti"] = "Haiti";
+    IssuingCountry["HeardIslandAndMcdonaldIslands"] = "Heard Island And Mcdonald Islands";
+    IssuingCountry["HolySeeVaticanCityState"] = "Holy See (Vatican City State)";
+    IssuingCountry["Honduras"] = "Honduras";
+    IssuingCountry["HongKong"] = "Hong Kong";
+    IssuingCountry["Hungary"] = "Hungary";
+    IssuingCountry["Iceland"] = "Iceland";
+    IssuingCountry["India"] = "India";
+    IssuingCountry["Indonesia"] = "Indonesia";
+    IssuingCountry["Iran"] = "Iran";
+    IssuingCountry["Iraq"] = "Iraq";
+    IssuingCountry["Ireland"] = "Ireland";
+    IssuingCountry["Israel"] = "Israel";
+    IssuingCountry["Italy"] = "Italy";
+    IssuingCountry["Jamaica"] = "Jamaica";
+    IssuingCountry["Japan"] = "Japan";
+    IssuingCountry["Jordan"] = "Jordan";
+    IssuingCountry["Kazakstan"] = "Kazakstan";
+    IssuingCountry["Kenya"] = "Kenya";
+    IssuingCountry["Kiribati"] = "Kiribati";
+    IssuingCountry["Kosovo"] = "Kosovo";
+    IssuingCountry["Kuwait"] = "Kuwait";
+    IssuingCountry["Kyrgyzstan"] = "Kyrgyzstan";
+    IssuingCountry["Laos"] = "Laos";
+    IssuingCountry["Latvia"] = "Latvia";
+    IssuingCountry["Lebanon"] = "Lebanon";
+    IssuingCountry["Lesotho"] = "Lesotho";
+    IssuingCountry["Liberia"] = "Liberia";
+    IssuingCountry["LibyanArabJamahiriya"] = "Libyan Arab Jamahiriya";
+    IssuingCountry["Liechtenstein"] = "Liechtenstein";
+    IssuingCountry["Lithuania"] = "Lithuania";
+    IssuingCountry["Luxembourg"] = "Luxembourg";
+    IssuingCountry["Macau"] = "Macau";
+    IssuingCountry["Macedonia"] = "Macedonia";
+    IssuingCountry["Madagascar"] = "Madagascar";
+    IssuingCountry["Malawi"] = "Malawi";
+    IssuingCountry["Malaysia"] = "Malaysia";
+    IssuingCountry["Maldives"] = "Maldives";
+    IssuingCountry["Mali"] = "Mali";
+    IssuingCountry["Malta"] = "Malta";
+    IssuingCountry["MarshallIslands"] = "Marshall Islands";
+    IssuingCountry["Martinique"] = "Martinique";
+    IssuingCountry["Mauritania"] = "Mauritania";
+    IssuingCountry["Mauritius"] = "Mauritius";
+    IssuingCountry["Mayotte"] = "Mayotte";
+    IssuingCountry["Mexico"] = "Mexico";
+    IssuingCountry["Monaco"] = "Monaco";
+    IssuingCountry["Mongolia"] = "Mongolia";
+    IssuingCountry["Montenegro"] = "Montenegro";
+    IssuingCountry["Montserrat"] = "Montserrat";
+    IssuingCountry["Morocco"] = "Morocco";
+    IssuingCountry["Mozambique"] = "Mozambique";
+    IssuingCountry["Myanmar"] = "Myanmar";
+    IssuingCountry["Namibia"] = "Namibia";
+    IssuingCountry["Nauru"] = "Nauru";
+    IssuingCountry["Nepal"] = "Nepal";
+    IssuingCountry["Netherlands"] = "Netherlands";
+    IssuingCountry["NetherlandsAntilles"] = "Netherlands Antilles";
+    IssuingCountry["NewCaledonia"] = "New Caledonia";
+    IssuingCountry["NewZealand"] = "New Zealand";
+    IssuingCountry["Nicaragua"] = "Nicaragua";
+    IssuingCountry["Niger"] = "Niger";
+    IssuingCountry["Nigeria"] = "Nigeria";
+    IssuingCountry["Niue"] = "Niue";
+    IssuingCountry["NorfolkIsland"] = "Norfolk Island";
+    IssuingCountry["NorthernMarianaIslands"] = "Northern Mariana Islands";
+    IssuingCountry["Norway"] = "Norway";
+    IssuingCountry["Oman"] = "Oman";
+    IssuingCountry["Pakistan"] = "Pakistan";
+    IssuingCountry["Palau"] = "Palau";
+    IssuingCountry["PalestinianTerritory"] = "Palestinian Territory";
+    IssuingCountry["Panama"] = "Panama";
+    IssuingCountry["PapuaNewGuinea"] = "Papua New Guinea";
+    IssuingCountry["Paraguay"] = "Paraguay";
+    IssuingCountry["Peru"] = "Peru";
+    IssuingCountry["Philippines"] = "Philippines";
+    IssuingCountry["Pitcairn"] = "Pitcairn";
+    IssuingCountry["Poland"] = "Poland";
+    IssuingCountry["Portugal"] = "Portugal";
+    IssuingCountry["PuertoRico"] = "Puerto Rico";
+    IssuingCountry["Qatar"] = "Qatar";
+    IssuingCountry["RepublicOfMoldova"] = "Republic Of Moldova";
+    IssuingCountry["Romania"] = "Romania";
+    IssuingCountry["RussianFederation"] = "Russian Federation";
+    IssuingCountry["Rwanda"] = "Rwanda";
+    IssuingCountry["SANMarino"] = "San Marino";
+    IssuingCountry["SaintHelena"] = "Saint Helena";
+    IssuingCountry["SaintKittsAndNevis"] = "Saint Kitts And Nevis";
+    IssuingCountry["SaintLucia"] = "Saint Lucia";
+    IssuingCountry["SaintPierreAndMiquelon"] = "Saint Pierre And Miquelon";
+    IssuingCountry["SaintVincentAndTheGrenadines"] = "Saint Vincent And The Grenadines";
+    IssuingCountry["Samoa"] = "Samoa";
+    IssuingCountry["SaoTomeAndPrincipe"] = "Sao Tome And Principe";
+    IssuingCountry["SaudiArabia"] = "Saudi Arabia";
+    IssuingCountry["Senegal"] = "Senegal";
+    IssuingCountry["Serbia"] = "Serbia";
+    IssuingCountry["Seychelles"] = "Seychelles";
+    IssuingCountry["SierraLeone"] = "Sierra Leone";
+    IssuingCountry["Singapore"] = "Singapore";
+    IssuingCountry["Slovakia"] = "Slovakia";
+    IssuingCountry["Slovenia"] = "Slovenia";
+    IssuingCountry["SolomonIslands"] = "Solomon Islands";
+    IssuingCountry["Somalia"] = "Somalia";
+    IssuingCountry["SouthAfrica"] = "South Africa";
+    IssuingCountry["SouthGeorgiaAndTheSouthSandwichIslands"] = "South Georgia And The South Sandwich Islands";
+    IssuingCountry["Spain"] = "Spain";
+    IssuingCountry["SriLanka"] = "Sri Lanka";
+    IssuingCountry["Sudan"] = "Sudan";
+    IssuingCountry["Suriname"] = "Suriname";
+    IssuingCountry["SvalbardAndJanMayen"] = "Svalbard And Jan Mayen";
+    IssuingCountry["Swaziland"] = "Swaziland";
+    IssuingCountry["Sweden"] = "Sweden";
+    IssuingCountry["Switzerland"] = "Switzerland";
+    IssuingCountry["SyrianArabRepublic"] = "Syrian Arab Republic";
+    IssuingCountry["Taiwan"] = "Taiwan";
+    IssuingCountry["Tajikistan"] = "Tajikistan";
+    IssuingCountry["Tanzania"] = "Tanzania";
+    IssuingCountry["Thailand"] = "Thailand";
+    IssuingCountry["TheRepublicOfSouthKorea"] = "The Republic of South Korea";
+    IssuingCountry["Togo"] = "Togo";
+    IssuingCountry["Tokelau"] = "Tokelau";
+    IssuingCountry["Tonga"] = "Tonga";
+    IssuingCountry["TrinidadAndTobago"] = "Trinidad And Tobago";
+    IssuingCountry["Tunisia"] = "Tunisia";
+    IssuingCountry["Turkey"] = "Turkey";
+    IssuingCountry["Turkmenistan"] = "Turkmenistan";
+    IssuingCountry["TurksAndCaicosIslands"] = "Turks And Caicos Islands";
+    IssuingCountry["Tuvalu"] = "Tuvalu";
+    IssuingCountry["USVirginIslands"] = "US Virgin Islands";
+    IssuingCountry["Uganda"] = "Uganda";
+    IssuingCountry["Ukraine"] = "Ukraine";
+    IssuingCountry["UnitedArabEmirates"] = "United Arab Emirates";
+    IssuingCountry["UnitedKingdom"] = "United Kingdom";
+    IssuingCountry["UnitedStatesMinorOutlyingIslands"] = "United States Minor Outlying Islands";
+    IssuingCountry["UnitedStatesOfAmerica"] = "United States of America";
+    IssuingCountry["Uruguay"] = "Uruguay";
+    IssuingCountry["Uzbekistan"] = "Uzbekistan";
+    IssuingCountry["Vanuatu"] = "Vanuatu";
+    IssuingCountry["Venezuela"] = "Venezuela";
+    IssuingCountry["Vietnam"] = "Vietnam";
+    IssuingCountry["WallisAndFutuna"] = "Wallis And Futuna";
+    IssuingCountry["WesternSahara"] = "Western Sahara";
+    IssuingCountry["Yemen"] = "Yemen";
+    IssuingCountry["Zambia"] = "Zambia";
+    IssuingCountry["Zimbabwe"] = "Zimbabwe";
+})(IssuingCountry = exports.IssuingCountry || (exports.IssuingCountry = {}));
+/**
+ * Status
+ */
+var Status;
+(function (Status) {
+    Status["Expired"] = "expired";
+    Status["FailedVerification"] = "failed_verification";
+    Status["NotRequired"] = "not_required";
+    Status["PendingUpload"] = "pending_upload";
+    Status["PendingVerification"] = "pending_verification";
+    Status["Verified"] = "verified";
+})(Status = exports.Status || (exports.Status = {}));
+var Type;
+(function (Type) {
+    Type["RequiredDocumentCreated"] = "RequiredDocumentCreated";
+    Type["RequiredDocumentUpdated"] = "RequiredDocumentUpdated";
+})(Type = exports.Type || (exports.Type = {}));

package/lib/types/partial-application.d.ts

@@ -0,0 +1,3 @@
+import { InternalRequest } from '@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request';
+import { RecursivePartial } from './recursive-partial';
+export type PartialApplication = RecursivePartial<InternalRequest>;

package/lib/types/partial-application.js

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

package/lib/types/recursive-partial.d.ts

@@ -0,0 +1,3 @@
+export type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};

package/lib/types/recursive-partial.js

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

package/lib/update-application/merge-application.d.ts

@@ -0,0 +1,14 @@
+interface DeepMergeOptions {
+    readonly secondIDEnabled?: boolean;
+}
+/**
+ * Deep merges the application and custom handles specific arrays
+ *
+ * @param existingApplication a saved dynamo application.
+ * @param newApplication new application coming from events.
+ * @param {DeepMergeOptions} options Deep merge options
+ *
+ * @returns merged application.
+ */
+export declare function deepMergeApplication(existingApplication: object | undefined, newApplication: object, options?: DeepMergeOptions): any;
+export {};

package/lib/update-application/merge-application.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMergeApplication = void 0;
+const merge = require("deepmerge");
+const cleanDeep = require('clean-deep');
+/**
+ * Deep merges the application and custom handles specific arrays
+ *
+ * @param existingApplication a saved dynamo application.
+ * @param newApplication new application coming from events.
+ * @param {DeepMergeOptions} options Deep merge options
+ *
+ * @returns merged application.
+ */
+function deepMergeApplication(existingApplication, newApplication, options = {}) {
+    if (!existingApplication) {
+        return newApplication;
+    }
+    const { secondIDEnabled = false } = options;
+    // Array fields with @UniqueIDs
+    const listsWithUniqueIds = [
+        'Attachment',
+        'Address',
+        'CompanyApplicant',
+        'Dependant',
+        'Liability',
+        'LivingExpense',
+        'LoanDetails',
+        'NonRealEstateAsset',
+        'OtherCommitment',
+        'OtherIncome',
+        'PersonApplicant',
+        'RealEstateAsset',
+        'RelatedCompany',
+        'RelatedPerson',
+        'TrustApplicant',
+    ];
+    if (secondIDEnabled) {
+        listsWithUniqueIds.push('ProofOfIdentity');
+    }
+    // Array fields with @x_Party
+    const listsWithXParty = ['Report'];
+    // Array fields with @x_Owner
+    const listsWithXOwner = ['RentalIncome'];
+    // Array fields with @x_Applicant
+    const listsWithXApplicant = ['Applicant'];
+    // Array fields with @x_ResidentialAddress
+    const listsWithXResidentialAddress = ['PriorAddress'];
+    // Array fields with @x_Guarantor
+    const listsWithXGuarantor = ['Guarantor'];
+    // Array fields with @x_Trustee
+    const listsWithXTrustee = ['Trustee'];
+    // Array fields with @x_Beneficiary
+    const listsWithXBeneficiary = ['Beneficiary'];
+    // Array fields with @x_BeneficialOwner
+    const listsWithXBeneficialOwner = ['BeneficialOwner'];
+    // Array fields with @x_Director
+    const listsWithXDirector = ['Director'];
+    // Curried function which takes a uniqueKey and returns a function which will either replace
+    // or merge the item in the array based on the uniqueKey
+    const mergeItems = (uniqueKey) => {
+        return (existingItem, newItem) => {
+            // if not array continue with merge
+            if (!Array.isArray(newItem)) {
+                return merge(existingItem, newItem, mergeOptions);
+            }
+            return findArrayItemAndMerge(existingItem, newItem, uniqueKey, mergeOptions);
+        };
+    };
+    const mergeOptions = {
+        customMerge: (key) => {
+            if (listsWithUniqueIds.find((item) => item === key)) {
+                return mergeItems('@UniqueID');
+            }
+            if (listsWithXParty.find((item) => item === key)) {
+                return mergeItems('@x_Party');
+            }
+            if (listsWithXOwner.find((item) => item === key)) {
+                return mergeItems('@x_Owner');
+            }
+            if (listsWithXResidentialAddress.find((item) => item === key)) {
+                return mergeItems('@x_ResidentialAddress');
+            }
+            if (listsWithXApplicant.find((item) => item === key)) {
+                return mergeItems('@x_Applicant');
+            }
+            if (listsWithXGuarantor.find((item) => item === key)) {
+                return mergeItems('@x_Guarantor');
+            }
+            if (listsWithXTrustee.find((item) => item === key)) {
+                return mergeItems('@x_Trustee');
+            }
+            if (listsWithXBeneficiary.find((item) => item === key)) {
+                return mergeItems('@x_Beneficiary');
+            }
+            if (listsWithXBeneficialOwner.find((item) => item === key)) {
+                return mergeItems('@x_BeneficialOwner');
+            }
+            if (listsWithXDirector.find((item) => item === key)) {
+                return mergeItems('@x_Director');
+            }
+            return mergeItems(key);
+        },
+    };
+    const mergedApplication = merge(existingApplication, newApplication, mergeOptions);
+    // Default configurations of cleanDeep for reference.
+    const params = {
+        cleanValues: [],
+        emptyArrays: true,
+        emptyObjects: true,
+        emptyStrings: true,
+        NaNValues: true,
+        nullValues: true,
+        undefinedValues: true,
+    };
+    return cleanDeep(mergedApplication, params);
+}
+exports.deepMergeApplication = deepMergeApplication;
+const arrayItemToReplaceKeys = ['Owner', 'Attendee', 'Shareholder', 'Fee', 'ContributionFunds', 'RentalIncome'];
+/**
+ *
+ * @param existingItem
+ * @param newItem
+ * @param uniqueKey
+ * @param options
+ */
+function findArrayItemAndMerge(existingItem, newItem, uniqueKey, options) {
+    // For some Key, overwritten the old value with the new data so no merge is happening.
+    if (arrayItemToReplaceKeys.includes(uniqueKey))
+        return newItem;
+    if (uniqueKey === 'Income' && existingItem && existingItem.some((item) => item['@StartDate'])) {
+        // Income array in CompanyApplicant
+        return newItem;
+    }
+    if (uniqueKey === 'Income' && existingItem && existingItem.some((item) => item.BusinessActivityStatement)) {
+        // Income array in CompanyApplicant for Low Doc applications
+        return newItem;
+    }
+    // Copying existing array
+    const mergedArray = existingItem.slice();
+    // Searching whether item in the new array exists in existing array
+    newItem.forEach((item) => {
+        const indexOfItem = mergedArray.findIndex((existingItem) => {
+            // TODO [CORE-2160] how to identify employment without go a level down.
+            // Employment needs to go one level deeper to check if the @UniqueID already exist.
+            if (uniqueKey === 'Employment') {
+                const currentEmploymentKeys = Object.keys(item);
+                const existingEmploymentKeys = Object.keys(existingItem);
+                if (currentEmploymentKeys.length && existingEmploymentKeys.length) {
+                    // Get the unique id from the field with proper value for current employment. The types with undefined value
+                    // are present in order to remove the related types from existing application.  These undefined types will be
+                    // removed from payload immediately after deep merging.
+                    // @pliu 19/11/19
+                    const currentEmployment = currentEmploymentKeys.find((key) => item[key]);
+                    // Each employment can only have one of three types.
+                    // @pliu 19/11/19
+                    const existingEmployment = existingEmploymentKeys[0];
+                    if (currentEmployment && existingEmployment) {
+                        return existingItem[existingEmployment]['@UniqueID'] === item[currentEmployment]['@UniqueID'];
+                    }
+                }
+                return -1;
+            }
+            return existingItem[uniqueKey] === item[uniqueKey];
+        });
+        // Checks if item should be added or merged
+        if (indexOfItem === -1) {
+            mergedArray.push(item);
+        }
+        else {
+            mergedArray[indexOfItem] = merge(mergedArray[indexOfItem], item, options);
+        }
+    });
+    return mergedArray;
+}

package/lib/update-application/remove-ids-not-required.d.ts

@@ -0,0 +1,11 @@
+import { InternalRequest } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
+import { Payload as RequiredDocEventPayload } from '../types/events/public-required-document';
+import { RecursivePartial } from '../types/recursive-partial';
+/**
+ * Removes ProofOfIdentity ID document that is in status Not Required
+ *
+ * @param {RecursivePartial<InternalRequest>} application - Partial LIXI CAL application
+ * @param {RequiredDocEventPayload} eventPayload - Required Document event payload
+ * @returns {RecursivePartial<InternalRequest>} Updated application
+ */
+export declare const removeIdsNotRequired: (application: RecursivePartial<InternalRequest>, eventPayload: RequiredDocEventPayload) => RecursivePartial<InternalRequest>;

package/lib/update-application/remove-ids-not-required.js

@@ -0,0 +1,63 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeIdsNotRequired = void 0;
+const application_paths_1 = require("@lendi/integrations-credit-protocol/utils/application-paths");
+const lodash_1 = require("lodash");
+const public_required_document_1 = require("../types/events/public-required-document");
+/**
+ * Remove proof of identity document from a person applicant
+ *
+ * @param {PersonApplicant} personApplicant Person applicant to remove the id document from
+ * @param {string} id Proof of identity document
+ * @param {identification} identification Identification data in RequiredDocument event
+ * @returns {PersonApplicant} Updated person applicant
+ */
+const removeIDDocumentFromApplicant = (personApplicant, id, identification) => {
+    const { ProofOfIdentity = [] } = personApplicant, rest = __rest(personApplicant, ["ProofOfIdentity"]);
+    const updatedProofOfIdentity = ProofOfIdentity.filter((proofOfId) => {
+        let shouldKeepProofOfId = true;
+        if (proofOfId['@UniqueID']) {
+            shouldKeepProofOfId = proofOfId['@UniqueID'] !== id;
+        }
+        else {
+            if (identification === null || identification === void 0 ? void 0 : identification.idNumber) {
+                shouldKeepProofOfId = proofOfId['@DocumentNumber'] !== identification.idNumber;
+            }
+        }
+        return shouldKeepProofOfId;
+    });
+    // If the updateProofOfIdentity is an empty array then we remove the ProofOfIdentity attribute from the person applicant
+    return Object.assign(Object.assign({}, rest), (updatedProofOfIdentity.length && { ProofOfIdentity: updatedProofOfIdentity }));
+};
+/**
+ * Removes ProofOfIdentity ID document that is in status Not Required
+ *
+ * @param {RecursivePartial<InternalRequest>} application - Partial LIXI CAL application
+ * @param {RequiredDocEventPayload} eventPayload - Required Document event payload
+ * @returns {RecursivePartial<InternalRequest>} Updated application
+ */
+const removeIdsNotRequired = (application, eventPayload) => {
+    const { status: verificationStatus, identification, applicantId, id } = eventPayload;
+    const personApplicants = (0, lodash_1.get)(application, application_paths_1.paths.PersonApplicants, []);
+    const updatedApplication = (0, lodash_1.cloneDeep)(application);
+    if (verificationStatus === public_required_document_1.Status.NotRequired && personApplicants.length) {
+        const personApplicantIndex = personApplicants.findIndex((personApplicant) => personApplicant['@UniqueID'] === applicantId);
+        if (personApplicantIndex !== -1) {
+            const updatedPersonApplicant = removeIDDocumentFromApplicant(personApplicants[personApplicantIndex], id, identification);
+            (0, lodash_1.set)(updatedApplication, `${application_paths_1.paths.PersonApplicants}.[${personApplicantIndex}]`, updatedPersonApplicant);
+        }
+    }
+    return updatedApplication;
+};
+exports.removeIdsNotRequired = removeIdsNotRequired;

package/lib/update-application/update-primary-applicant.d.ts

@@ -0,0 +1,27 @@
+import { PersonApplicant } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
+import { PartialApplication } from '../types/partial-application';
+import { Payload } from '../types/events/public-applicant';
+/**
+ * Checks if there are more than one person applicants with applicant type borrower
+ *
+ * @param {PersonApplicants[]} personApplicants - Person applicants on the deep merged application
+ * @returns {boolean} - Whether or not there are more than one applicant with applicant type borrower
+ */
+export declare const isMultiplePersonApplicantBorrowers: (personApplicants: PersonApplicant[]) => boolean;
+/**
+ * Updates the primary applicant of the application based on the new primary applicant id
+ *
+ * @param {string} newPrimaryApplicantId - New primary applicant id
+ * @param {PersonApplicant[]} personApplicants - Person applicants from the updated application after deep merge
+ * @returns {PersonApplicant[]} - Updated person applicants
+ */
+export declare const updatePrimaryApplicant: (newPrimaryApplicantId: string, personApplicants: PersonApplicant[]) => PersonApplicant[];
+/**
+ * Updates the primary applicant on the application based on the data in the guarantor applicant event
+ *
+ * @param {PartialApplication} application - Application after deep merge
+ * @param {Payload} applicantPayload - Public applicant event payload
+ * @returns {PartialApplication} - Updated application
+ */
+declare const updatePrimaryApplicantUsingGuarantor: (application: PartialApplication, applicantPayload: Payload) => PartialApplication;
+export default updatePrimaryApplicantUsingGuarantor;

package/lib/update-application/update-primary-applicant.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePrimaryApplicant = exports.isMultiplePersonApplicantBorrowers = void 0;
+const application_paths_1 = require("@lendi/act-eac-integrations-protocol/lib/utils/application-paths");
+const lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const public_applicant_1 = require("../types/events/public-applicant");
+/**
+ * Checks if there are more than one person applicants with applicant type borrower
+ *
+ * @param {PersonApplicants[]} personApplicants - Person applicants on the deep merged application
+ * @returns {boolean} - Whether or not there are more than one applicant with applicant type borrower
+ */
+const isMultiplePersonApplicantBorrowers = (personApplicants) => {
+    const totalBorrowerApplicants = personApplicants.filter((applicant) => applicant['@ApplicantType'] === lixi_internal_request_1.ApplicantTypeList.Borrower).length;
+    return totalBorrowerApplicants > 1;
+};
+exports.isMultiplePersonApplicantBorrowers = isMultiplePersonApplicantBorrowers;
+/**
+ * Updates the primary applicant of the application based on the new primary applicant id
+ *
+ * @param {string} newPrimaryApplicantId - New primary applicant id
+ * @param {PersonApplicant[]} personApplicants - Person applicants from the updated application after deep merge
+ * @returns {PersonApplicant[]} - Updated person applicants
+ */
+const updatePrimaryApplicant = (newPrimaryApplicantId, personApplicants) => personApplicants.map((applicant) => (Object.assign(Object.assign({}, applicant), { ['@PrimaryApplicant']: applicant['@UniqueID'] === newPrimaryApplicantId ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No })));
+exports.updatePrimaryApplicant = updatePrimaryApplicant;
+/**
+ * Updates the primary applicant on the application based on the data in the guarantor applicant event
+ *
+ * @param {PartialApplication} application - Application after deep merge
+ * @param {Payload} applicantPayload - Public applicant event payload
+ * @returns {PartialApplication} - Updated application
+ */
+const updatePrimaryApplicantUsingGuarantor = (application, applicantPayload) => {
+    var _a;
+    const updatedApplication = application, personApplicants = (0, lodash_1.get)(application, application_paths_1.paths.PersonApplicants, []);
+    // Checks if there are more than one borrower in the application and that the applicant type of the applicant event being processed is GUARANTOR
+    if ((0, exports.isMultiplePersonApplicantBorrowers)(personApplicants) &&
+        applicantPayload.applicantType === public_applicant_1.ApplicantType.Guarantor &&
+        ((_a = applicantPayload.guarantorRelationshipToBorrower) === null || _a === void 0 ? void 0 : _a.applicantId)) {
+        (0, lodash_1.set)(updatedApplication, application_paths_1.paths.PersonApplicants, (0, exports.updatePrimaryApplicant)(applicantPayload.guarantorRelationshipToBorrower.applicantId, personApplicants));
+    }
+    return updatedApplication;
+};
+exports.default = updatePrimaryApplicantUsingGuarantor;