@lendi/integrations-transform 1.5.8 → 1.5.9

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

@@ -1,18 +1,15 @@
-"use strict";
-exports.__esModule = true;
-exports.deepMergeApplication = void 0;
-var merge = require("deepmerge");
-var cleanDeep = require('clean-deep');
+import * as merge from 'deepmerge';
+const cleanDeep = require('clean-deep');
 /**
  * Deep merges the application and custom handles specific arrays
  *
  * @param newApplication new application coming from events.
  * @param existingApplication a saved dynamo application.
- * @return merged application.
+ * @returns merged application.
  */
-function deepMergeApplication(existingApplication, newApplication) {
+export function deepMergeApplication(existingApplication, newApplication) {
     // Array fields with @UniqueIDs
-    var listsWithUniqueIds = [
+    const listsWithUniqueIds = [
         'Attachment',
         'Address',
         'CompanyApplicant',
@@ -29,22 +26,22 @@ function deepMergeApplication(existingApplication, newApplication) {
         'RelatedPerson',
     ];
     // Array fields with @x_Party
-    var listsWithXParty = ['Report'];
+    const listsWithXParty = ['Report'];
     // Array fields with @x_Owner
-    var listsWithXOwner = ['RentalIncome'];
+    const listsWithXOwner = ['RentalIncome'];
     // Array fields with @x_Applicant
-    var listsWithXApplicant = ['Applicant'];
+    const listsWithXApplicant = ['Applicant'];
     // Array fields with @x_ResidentialAddress
-    var listsWithXResidentialAddress = ['PriorAddress'];
+    const listsWithXResidentialAddress = ['PriorAddress'];
     // Array fields with @x_Guarantor
-    var listsWithXGuarantor = ['Guarantor'];
+    const listsWithXGuarantor = ['Guarantor'];
     // 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
     if (!existingApplication) {
         return newApplication;
     }
-    var mergeItems = function (uniqueKey) {
-        return function (existingItem, newItem) {
+    const mergeItems = (uniqueKey) => {
+        return (existingItem, newItem) => {
             // if not array continue with merge
             if (!Array.isArray(newItem)) {
                 return merge(existingItem, newItem, options);
@@ -52,75 +49,81 @@ function deepMergeApplication(existingApplication, newApplication) {
             return findArrayItemAndMerge(existingItem, newItem, uniqueKey, options);
         };
     };
-    var options = {
-        customMerge: function (key) {
-            if (listsWithUniqueIds.find(function (item) { return item === key; })) {
+    const options = {
+        customMerge: (key) => {
+            if (listsWithUniqueIds.find((item) => item === key)) {
                 return mergeItems('@UniqueID');
             }
-            if (listsWithXParty.find(function (item) { return item === key; })) {
+            if (listsWithXParty.find((item) => item === key)) {
                 return mergeItems('@x_Party');
             }
-            if (listsWithXOwner.find(function (item) { return item === key; })) {
+            if (listsWithXOwner.find((item) => item === key)) {
                 return mergeItems('@x_Owner');
             }
-            if (listsWithXResidentialAddress.find(function (item) { return item === key; })) {
+            if (listsWithXResidentialAddress.find((item) => item === key)) {
                 return mergeItems('@x_ResidentialAddress');
             }
-            if (listsWithXApplicant.find(function (item) { return item === key; })) {
+            if (listsWithXApplicant.find((item) => item === key)) {
                 return mergeItems('@x_Applicant');
             }
-            if (listsWithXGuarantor.find(function (item) { return item === key; })) {
+            if (listsWithXGuarantor.find((item) => item === key)) {
                 return mergeItems('@x_Guarantor');
             }
             return mergeItems(key);
-        }
+        },
     };
-    var mergedApplication = merge(existingApplication, newApplication, options);
+    const mergedApplication = merge(existingApplication, newApplication, options);
     // Default configurations of cleanDeep for reference.
-    var params = {
+    const params = {
         cleanValues: [],
         emptyArrays: true,
         emptyObjects: true,
         emptyStrings: true,
         NaNValues: true,
         nullValues: true,
-        undefinedValues: true
+        undefinedValues: true,
     };
     return cleanDeep(mergedApplication, params);
 }
-exports.deepMergeApplication = deepMergeApplication;
-var arrayItemToReplaceKeys = ['Owner', 'Attendee', 'Shareholder', 'Fee', 'ContributionFunds', 'RentalIncome'];
+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(function (item) { return item['@StartDate']; })) {
+    if (uniqueKey === 'Income' && existingItem && existingItem.some((item) => item['@StartDate'])) {
         // Income array in CompanyApplicant
         return newItem;
     }
-    if (uniqueKey === 'Income' && existingItem && existingItem.some(function (item) { return item.BusinessActivityStatement; })) {
+    if (uniqueKey === 'Income' && existingItem && existingItem.some((item) => item.BusinessActivityStatement)) {
         // Income array in CompanyApplicant for Low Doc applications
         return newItem;
     }
     // Copying existing array
-    var mergedArray = existingItem.slice();
+    const mergedArray = existingItem.slice();
     // Searching whether item in the new array exists in existing array
-    newItem.forEach(function (item) {
-        var indexOfItem = mergedArray.findIndex(function (existingItem) {
+    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') {
-                var currentEmploymentKeys = Object.keys(item);
-                var existingEmploymentKeys = Object.keys(existingItem);
+                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
-                    var currentEmployment = currentEmploymentKeys.find(function (key) { return item[key]; });
+                    const currentEmployment = currentEmploymentKeys.find((key) => item[key]);
                     // Each employment can only have one of three types.
                     // @pliu 19/11/19
-                    var existingEmployment = existingEmploymentKeys[0];
+                    const existingEmployment = existingEmploymentKeys[0];
                     if (currentEmployment && existingEmployment) {
                         return existingItem[existingEmployment]['@UniqueID'] === item[currentEmployment]['@UniqueID'];
                     }

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

@@ -5,16 +5,14 @@ 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 {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[];
@@ -23,7 +21,6 @@ export declare const updatePrimaryApplicant: (newPrimaryApplicantId: string, per
  *
  * @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;

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

@@ -1,65 +1,41 @@
-"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.updatePrimaryApplicant = exports.isMultiplePersonApplicantBorrowers = void 0;
-var application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
-var lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
-var lodash_1 = require("lodash");
-var public_applicant_1 = require("../types/events/public-applicant");
+import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
+import { ApplicantTypeList, YesNoList, } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
+import { get, set } from 'lodash';
+import { ApplicantType } 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
  */
-var isMultiplePersonApplicantBorrowers = function (personApplicants) {
-    var totalBorrowerApplicants = personApplicants.filter(function (applicant) { return applicant['@ApplicantType'] === lixi_internal_request_1.ApplicantTypeList.Borrower; }).length;
+export const isMultiplePersonApplicantBorrowers = (personApplicants) => {
+    const totalBorrowerApplicants = personApplicants.filter((applicant) => applicant['@ApplicantType'] === 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 {string} newPrimaryApplicantId - New primary applicant id
  * @param {PersonApplicant[]} personApplicants - Person applicants from the updated application after deep merge
- *
  * @returns {PersonApplicant[]} - Updated person applicants
  */
-var updatePrimaryApplicant = function (newPrimaryApplicantId, personApplicants) {
-    return personApplicants.map(function (applicant) {
-        var _a;
-        return (__assign(__assign({}, applicant), (_a = {}, _a['@PrimaryApplicant'] = applicant['@UniqueID'] === newPrimaryApplicantId ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No, _a)));
-    });
-};
-exports.updatePrimaryApplicant = updatePrimaryApplicant;
+export const updatePrimaryApplicant = (newPrimaryApplicantId, personApplicants) => personApplicants.map((applicant) => (Object.assign(Object.assign({}, applicant), { ['@PrimaryApplicant']: applicant['@UniqueID'] === newPrimaryApplicantId ? YesNoList.Yes : YesNoList.No })));
 /**
  * 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
  */
-var updatePrimaryApplicantUsingGuarantor = function (application, applicantPayload) {
+const updatePrimaryApplicantUsingGuarantor = (application, applicantPayload) => {
     var _a;
-    var updatedApplication = application, personApplicants = (0, lodash_1.get)(application, application_paths_1.paths.PersonApplicants, []);
+    const updatedApplication = application, personApplicants = get(application, 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 &&
+    if (isMultiplePersonApplicantBorrowers(personApplicants) &&
+        applicantPayload.applicantType === 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));
+        set(updatedApplication, paths.PersonApplicants, updatePrimaryApplicant(applicantPayload.guarantorRelationshipToBorrower.applicantId, personApplicants));
     }
     return updatedApplication;
 };
-exports["default"] = updatePrimaryApplicantUsingGuarantor;
+export default updatePrimaryApplicantUsingGuarantor;

package/lib/utils/address-tools.d.ts

@@ -51,13 +51,15 @@ export interface AddressTransformedType {
  */
 export declare function rebuildAddress(eventAddress: EventAddressType, addressId: string): AddressTransformedType;
 /**
- * * Converts a previous address object from an event model to a LIXI address and corresponding LIXI current address object.
+ * Converts a previous address object from an event model to a LIXI address and corresponding LIXI current address object.
+ *
  * @param eventPreviousAddresses
  * @param addressId
  */
 export declare function rebuildPreviousAddress(eventPreviousAddresses: InternalPreviousAddress[], addressId: string): AddressTransformedType;
 /**
  * Checks if an event is missing country.
+ *
  * @param addressEvent
  */
 export declare function isMissingCountry(addressEvent: EventAddressType): boolean;

package/lib/utils/address-tools.js

@@ -1,67 +1,64 @@
-"use strict";
 /**
  * A set of tools for manipulating addresses in LIXI applications.
  */
-exports.__esModule = true;
-exports.isOverseasAddress = exports.extractCountryFromFormatted = exports.setCountry = exports.isMissingCountry = exports.rebuildPreviousAddress = exports.rebuildAddress = exports.mapTransform = exports.lixiAddressMapping = exports.australianStates = exports.lixiContactAddressMapping = void 0;
-var lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
-var lodash_1 = require("lodash");
-var country_code_1 = require("../types/enum-mappings/country-code");
-var housing_status_1 = require("../types/enum-mappings/housing-status");
-var public_applicant_1 = require("../types/events/public-applicant");
-var generate_address_1 = require("./generate-address");
-exports.lixiContactAddressMapping = {
+import { AuStateList, } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { get, set } from 'lodash';
+import { countryCodeMapping } from '../types/enum-mappings/country-code';
+import { housingStatusMapping } from '../types/enum-mappings/housing-status';
+import { Countries, } from '../types/events/public-applicant';
+import { StreetNumberMaxLength } from './generate-address';
+export const lixiContactAddressMapping = {
     externalId: {
-        path: '@x_ResidentialAddress'
+        path: '@x_ResidentialAddress',
     },
     housingStatus: {
         path: '@HousingStatus',
-        transform: function (value) { return housing_status_1.housingStatusMapping[value]; }
+        transform: (value) => housingStatusMapping[value],
     },
     startDate: {
-        path: '@StartDate'
+        path: '@StartDate',
     },
     endDate: {
-        path: '@EndDate'
-    }
+        path: '@EndDate',
+    },
 };
-exports.australianStates = Object.values(lixi_internal_request_1.AuStateList);
+export const australianStates = Object.values(AuStateList);
 /**
  * The transform map used for the LIXI address
  */
-exports.lixiAddressMapping = {
+export const lixiAddressMapping = {
     externalId: {
-        path: '@UniqueID'
+        path: '@UniqueID',
     },
     'residentialAddress.city': {
-        path: '@Suburb'
+        path: '@Suburb',
     },
     'residentialAddress.country': {
         path: '@Country',
-        transform: function (value) { return country_code_1.countryCodeMapping[value]; }
+        transform: (value) => countryCodeMapping[value],
     },
     'residentialAddress.postcode': {
-        path: '@AustralianPostCode'
+        path: '@AustralianPostCode',
     },
     'residentialAddress.state': {
-        path: '@AustralianState'
+        path: '@AustralianState',
     },
     'residentialAddress.standard.level': {
-        path: 'Standard.@Level'
+        path: 'Standard.@Level',
     },
     'residentialAddress.standard.streetName': {
-        path: 'Standard.@StreetName'
+        path: 'Standard.@StreetName',
     },
     'residentialAddress.standard.streetNumber': {
         path: 'Standard.@StreetNumber',
-        transform: function (value) { return value.substring(0, generate_address_1.StreetNumberMaxLength); }
+        transform: (value) => value.substring(0, StreetNumberMaxLength),
     },
     'residentialAddress.standard.streetType': {
-        path: 'Standard.@StreetType'
+        path: 'Standard.@StreetType',
     },
     'residentialAddress.standard.unit': {
-        path: 'Standard.@Unit'
-    }
+        path: 'Standard.@Unit',
+    },
 };
 /**
  * Transforms a source object by applying a PathMappedTransform.
@@ -69,110 +66,101 @@ exports.lixiAddressMapping = {
  * @param source A source object to be mapped and transformed
  * @param pathMappedTransform A PathMappedTransform to be applied to the source
  */
-function mapTransform(source, pathMappedTransform) {
-    var finalTransform = {};
-    Object.entries(pathMappedTransform).forEach(function (_a) {
-        var key = _a[0], _b = _a[1], transform = _b.transform, path = _b.path;
-        var sourceValue = (0, lodash_1.get)(source, key);
+export function mapTransform(source, pathMappedTransform) {
+    const finalTransform = {};
+    Object.entries(pathMappedTransform).forEach(([key, { transform, path }]) => {
+        const sourceValue = get(source, key);
         if (sourceValue) {
-            (0, lodash_1.set)(finalTransform, path, (transform === null || transform === void 0 ? void 0 : transform(sourceValue)) || sourceValue);
+            set(finalTransform, path, (transform === null || transform === void 0 ? void 0 : transform(sourceValue)) || sourceValue);
         }
     });
     return finalTransform;
 }
-exports.mapTransform = mapTransform;
-var postcodePathString = 'residentialAddress.postcode';
-var statePathString = 'residentialAddress.state';
+const postcodePathString = 'residentialAddress.postcode';
+const statePathString = 'residentialAddress.state';
 /**
  * Converts an address object from an event model to a LIXI address and corresponding LIXI contact address object.
  *
  * @param eventAddress
  * @param addressId
  */
-function rebuildAddress(eventAddress, addressId) {
+export function rebuildAddress(eventAddress, addressId) {
     if (isMissingCountry(eventAddress)) {
         setCountry(eventAddress);
     }
-    if ((0, lodash_1.get)(eventAddress, 'residentialAddress.country') !== public_applicant_1.Countries.Australia) {
-        exports.lixiAddressMapping[postcodePathString] = { path: '@OverseasPostCode' };
-        exports.lixiAddressMapping[statePathString] = { path: '@OverseasState' };
+    if (get(eventAddress, 'residentialAddress.country') !== Countries.Australia) {
+        lixiAddressMapping[postcodePathString] = { path: '@OverseasPostCode' };
+        lixiAddressMapping[statePathString] = { path: '@OverseasState' };
     }
     else {
-        exports.lixiAddressMapping[postcodePathString] = { path: '@AustralianPostCode' };
-        exports.lixiAddressMapping[statePathString] = { path: '@AustralianState' };
+        lixiAddressMapping[postcodePathString] = { path: '@AustralianPostCode' };
+        lixiAddressMapping[statePathString] = { path: '@AustralianState' };
     }
-    var lixiAddress = mapTransform(eventAddress, exports.lixiAddressMapping);
-    var lixiContactAddress = mapTransform(eventAddress, exports.lixiContactAddressMapping);
+    const lixiAddress = mapTransform(eventAddress, lixiAddressMapping);
+    const lixiContactAddress = mapTransform(eventAddress, lixiContactAddressMapping);
     lixiAddress['@UniqueID'] = addressId;
     lixiContactAddress['@x_ResidentialAddress'] = addressId;
-    return { lixiAddress: lixiAddress, lixiContactAddress: lixiContactAddress };
+    return { lixiAddress, lixiContactAddress };
 }
-exports.rebuildAddress = rebuildAddress;
 /**
- * * Converts a previous address object from an event model to a LIXI address and corresponding LIXI current address object.
+ * Converts a previous address object from an event model to a LIXI address and corresponding LIXI current address object.
+ *
  * @param eventPreviousAddresses
  * @param addressId
  */
-function rebuildPreviousAddress(eventPreviousAddresses, addressId) {
-    if (eventPreviousAddresses === void 0) { eventPreviousAddresses = []; }
+export function rebuildPreviousAddress(eventPreviousAddresses = [], addressId) {
     if (eventPreviousAddresses.length === 0)
         return null;
-    var previousAddress = eventPreviousAddresses.sort(function (lhs, rhs) { return lhs.endDate.localeCompare(rhs.endDate); }).pop();
+    const previousAddress = eventPreviousAddresses.sort((lhs, rhs) => lhs.endDate.localeCompare(rhs.endDate)).pop();
     return rebuildAddress(previousAddress, addressId);
 }
-exports.rebuildPreviousAddress = rebuildPreviousAddress;
 /**
  * Checks if an event is missing country.
+ *
  * @param addressEvent
  */
-function isMissingCountry(addressEvent) {
+export function isMissingCountry(addressEvent) {
     if (addressEvent.residentialAddress && addressEvent.residentialAddress.formatted) {
-        return !(0, lodash_1.get)(addressEvent, 'residentialAddress.country');
+        return !get(addressEvent, 'residentialAddress.country');
     }
     return false;
 }
-exports.isMissingCountry = isMissingCountry;
 /**
  * Sets the country from the last item on the formatted address.
  *
  * @param address
  */
-function setCountry(address) {
-    var formatted = (0, lodash_1.get)(address, 'residentialAddress.formatted');
+export function setCountry(address) {
+    const formatted = get(address, 'residentialAddress.formatted');
     if (formatted && !address.residentialAddress.country) {
         address.residentialAddress.country = extractCountryFromFormatted(formatted);
     }
     return address;
 }
-exports.setCountry = setCountry;
 /**
  * @description Extract a country from a formatted address.
  * @param {string} formatted - A formatted Address.
  * @returns {Countries} The country extracted from the Address.
  */
-function extractCountryFromFormatted(formatted) {
+export function extractCountryFromFormatted(formatted = '') {
     var _a;
-    if (formatted === void 0) { formatted = ''; }
     return (_a = formatted === null || formatted === void 0 ? void 0 : formatted.split(',').pop()) === null || _a === void 0 ? void 0 : _a.trim();
 }
-exports.extractCountryFromFormatted = extractCountryFromFormatted;
 /**
  * @description If the address has an overseas country or state, it returns true, defaults to false if no country and state found.
  * @param {Address} address - Asset Address
  * @returns {boolean} - Returns true if overseas address.
  */
-function isOverseasAddress(_a) {
-    var _b = _a === void 0 ? {} : _a, country = _b.country, formatted = _b.formatted, state = _b.state;
+export function isOverseasAddress({ country, formatted, state } = {}) {
     if (country) {
-        return country !== public_applicant_1.Countries.Australia;
+        return country !== Countries.Australia;
     }
     if (formatted) {
-        var lastPast = extractCountryFromFormatted(formatted);
-        return lastPast !== public_applicant_1.Countries.Australia;
+        const lastPast = extractCountryFromFormatted(formatted);
+        return lastPast !== Countries.Australia;
     }
     if (state) {
-        return !exports.australianStates.includes(state);
+        return !australianStates.includes(state);
     }
     return false;
 }
-exports.isOverseasAddress = isOverseasAddress;

package/lib/utils/clean-up.d.ts

@@ -2,6 +2,6 @@
  * Recursively removes nulls from nested objects and arrays
  *
  * @param payload any
- * @return result of sanitised object.
+ * @returns result of sanitised object.
  */
 export declare function cleanUp<T>(payload: T): Partial<T>;

package/lib/utils/clean-up.js

@@ -1,24 +1,20 @@
-"use strict";
-exports.__esModule = true;
-exports.cleanUp = void 0;
 /* istanbul ignore file  */
-var clean_deep_1 = require("clean-deep");
+import cleanDeep from 'clean-deep';
 /**
  * Recursively removes nulls from nested objects and arrays
  *
  * @param payload any
- * @return result of sanitised object.
+ * @returns result of sanitised object.
  */
-function cleanUp(payload) {
+export function cleanUp(payload) {
     // cleanDeep configurations.
-    var params = {
+    const params = {
         cleanValues: [],
         emptyArrays: true,
         emptyObjects: true,
         emptyStrings: false,
         nullValues: true,
-        undefinedValues: true
+        undefinedValues: true,
     };
-    return (0, clean_deep_1["default"])(payload, params);
+    return cleanDeep(payload, params);
 }
-exports.cleanUp = cleanUp;

package/lib/utils/formatYesNo.d.ts

@@ -3,7 +3,6 @@ import { YesNoList } from '@lendi/integrations-credit-protocol/types/lixi-intern
  * Formats a value as Yes or No
  *
  * @param isTruthy Some value to be formatted as Yes/No
- *
  * @returns Yes/No
  */
 export declare const formatYesNo: (isTruthy: any) => YesNoList;

package/lib/utils/formatYesNo.js

@@ -1,13 +1,8 @@
-"use strict";
-exports.__esModule = true;
-exports.formatYesNo = void 0;
-var lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
+import { YesNoList } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
 /**
  * Formats a value as Yes or No
  *
  * @param isTruthy Some value to be formatted as Yes/No
- *
  * @returns Yes/No
  */
-var formatYesNo = function (isTruthy) { return (isTruthy ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No); };
-exports.formatYesNo = formatYesNo;
+export const formatYesNo = (isTruthy) => (isTruthy ? YesNoList.Yes : YesNoList.No);

package/lib/utils/generate-address.d.ts

@@ -4,15 +4,16 @@ export declare const StreetNumberMaxLength = 16;
 export declare const StreetTypeArray: StreetTypeList[];
 /**
  * Generates an address for an asset.
+ *
  * @param {Address} address - An address object.
  * @param {string} id - Id of asset object.
- * @return {Partial<AddressType>} A transformed address object.
+ * @returns {Partial<AddressType>} A transformed address object.
  */
 export declare function generateAddress(address: Address, id: string): Partial<AddressType>;
 /**
  * Generates an address standard.
  *
  * @param addressStandard An address standard object.
- * @return A transformed standard object.
+ * @returns A transformed standard object.
  */
 export declare function generateStandard(addressStandard: AddressStandard): Standard;