@lendi/integrations-transform 1.6.0 → 1.6.3

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

@@ -1,27 +1,31 @@
-import { CountryCodeList, YesNoList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
-import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
-import { get, omit, set } from 'lodash';
-import { rebuildAddress } from '../utils/address-tools';
-import { countryCodeMapping, maritalStatusMapping, residencyStatusMapping, titleMapping } from '../types/enum-mappings';
-import { ResidencyStatus, Title, } from '../types/events/public-applicant';
-import { normaliseDate } from '../utils/normalise-date';
-export const booleanMapping = (input = false) => (input === true ? YesNoList.Yes : YesNoList.No);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDependants = exports.generateContact = exports.transformApplicant = exports.booleanMapping = void 0;
+const lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
+const application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+const lodash_1 = require("lodash");
+const address_tools_1 = require("../utils/address-tools");
+const enum_mappings_1 = require("../types/enum-mappings");
+const public_applicant_1 = require("../types/events/public-applicant");
+const normalise_date_1 = require("../utils/normalise-date");
+const booleanMapping = (input = false) => (input === true ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No);
+exports.booleanMapping = booleanMapping;
 const applicantMapping = {
-    applicationId: paths.ApplicationId,
-    citizenship: `${paths.PersonApplicant}.@Citizenship`,
-    contact: `${paths.PersonApplicant}.Contact`,
+    applicationId: application_paths_1.paths.ApplicationId,
+    citizenship: `${application_paths_1.paths.PersonApplicant}.@Citizenship`,
+    contact: `${application_paths_1.paths.PersonApplicant}.Contact`,
     dependants: 'dependants',
-    dateOfBirth: `${paths.PersonApplicant}.@DateOfBirth`,
-    firstName: `${paths.PersonApplicant}.PersonName.@FirstName`,
-    id: `${paths.PersonApplicant}.@UniqueID`,
-    isFirstHomeBuyer: `${paths.PersonApplicant}.@FirstHomeBuyer`,
-    isPrimaryApplicant: `${paths.PersonApplicant}.@PrimaryApplicant`,
-    lastName: `${paths.PersonApplicant}.PersonName.@Surname`,
-    maritalStatus: `${paths.PersonApplicant}.@MaritalStatus`,
-    maritalDetails: `${paths.PersonApplicant}.MaritalStatusDetails.@x_Spouse`,
-    middleName: `${paths.PersonApplicant}.PersonName.@MiddleNames`,
-    residencyStatus: `${paths.PersonApplicant}.@ResidencyStatus`,
-    title: `${paths.PersonName}.@NameTitle`,
+    dateOfBirth: `${application_paths_1.paths.PersonApplicant}.@DateOfBirth`,
+    firstName: `${application_paths_1.paths.PersonApplicant}.PersonName.@FirstName`,
+    id: `${application_paths_1.paths.PersonApplicant}.@UniqueID`,
+    isFirstHomeBuyer: `${application_paths_1.paths.PersonApplicant}.@FirstHomeBuyer`,
+    isPrimaryApplicant: `${application_paths_1.paths.PersonApplicant}.@PrimaryApplicant`,
+    lastName: `${application_paths_1.paths.PersonApplicant}.PersonName.@Surname`,
+    maritalStatus: `${application_paths_1.paths.PersonApplicant}.@MaritalStatus`,
+    maritalDetails: `${application_paths_1.paths.PersonApplicant}.MaritalStatusDetails.@x_Spouse`,
+    middleName: `${application_paths_1.paths.PersonApplicant}.PersonName.@MiddleNames`,
+    residencyStatus: `${application_paths_1.paths.PersonApplicant}.@ResidencyStatus`,
+    title: `${application_paths_1.paths.PersonName}.@NameTitle`,
 };
 /**
  * Transforms a partial Applicant event to a partial LIXI application.
@@ -30,61 +34,62 @@ const applicantMapping = {
  * @param applicant
  * @returns partialApplication an incomplete application.
  */
-export function transformApplicant(applicant) {
+function transformApplicant(applicant) {
     const partialApplication = {};
     const { id: applicantId, applicationId } = applicant;
-    set(partialApplication, applicantMapping['isFirstHomeBuyer'], booleanMapping(applicant.isFirstHomeBuyer));
-    set(partialApplication, applicantMapping['isPrimaryApplicant'], booleanMapping(applicant.isPrimaryApplicant));
-    set(partialApplication, applicantMapping['title'], titleMapping[applicant.title || Title.Unknown]);
-    const applicantUpdated = omit(applicant, ['isFirstHomeBuyer', 'isPrimaryApplicant', 'title']);
+    (0, lodash_1.set)(partialApplication, applicantMapping['isFirstHomeBuyer'], (0, exports.booleanMapping)(applicant.isFirstHomeBuyer));
+    (0, lodash_1.set)(partialApplication, applicantMapping['isPrimaryApplicant'], (0, exports.booleanMapping)(applicant.isPrimaryApplicant));
+    (0, lodash_1.set)(partialApplication, applicantMapping['title'], enum_mappings_1.titleMapping[applicant.title || public_applicant_1.Title.Unknown]);
+    const applicantUpdated = (0, lodash_1.omit)(applicant, ['isFirstHomeBuyer', 'isPrimaryApplicant', 'title']);
     for (const [key, value] of Object.entries(applicantUpdated)) {
         if (applicantMapping[key]) {
             switch (key) {
                 case 'dateOfBirth':
-                    set(partialApplication, applicantMapping[key], normaliseDate(value));
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], (0, normalise_date_1.normaliseDate)(value));
                     break;
                 case 'maritalStatus':
-                    set(partialApplication, applicantMapping[key], maritalStatusMapping[value]);
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], enum_mappings_1.maritalStatusMapping[value]);
                     break;
                 case 'citizenship':
-                    set(partialApplication, applicantMapping[key], countryCodeMapping[value]);
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], enum_mappings_1.countryCodeMapping[value]);
                     break;
                 case 'residencyStatus':
-                    set(partialApplication, applicantMapping[key], residencyStatusMapping[value]);
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], enum_mappings_1.residencyStatusMapping[value]);
                     // Certain bank integrations require the ability to differentiate between permanentResident and Citizen
                     // As lixi does not have a citizen enum for residencyStatus citizen is mapped to permanentResident
                     // Adding a @Citizenship attribute to person applicant gives us the ability to determine citizenship status
                     // If citizen this field will be always added and value will be AU.
                     // @tsilva 21/11/19
-                    if (value === ResidencyStatus.AustralianCitizen) {
-                        set(partialApplication, applicantMapping.citizenship, CountryCodeList.Au);
+                    if (value === public_applicant_1.ResidencyStatus.AustralianCitizen) {
+                        (0, lodash_1.set)(partialApplication, applicantMapping.citizenship, lixi_internal_request_1.CountryCodeList.Au);
                     }
                     break;
                 case 'maritalDetails':
-                    const id = get(value, 'applicantId');
+                    const id = (0, lodash_1.get)(value, 'applicantId');
                     if (id)
-                        set(partialApplication, applicantMapping[key], id);
+                        (0, lodash_1.set)(partialApplication, applicantMapping[key], id);
                     break;
                 case 'contact':
                     const { lixiContact, lixiAddresses } = generateContact(value, applicantId);
-                    set(partialApplication, applicantMapping[key], lixiContact);
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], lixiContact);
                     if (lixiAddresses.length > 0) {
-                        set(partialApplication, paths.Addresses, lixiAddresses);
+                        (0, lodash_1.set)(partialApplication, application_paths_1.paths.Addresses, lixiAddresses);
                     }
                     break;
                 case 'dependants':
                     const dependants = generateDependants(value, applicantId);
-                    set(partialApplication, `${paths.Household}.@UniqueID`, `${applicationId}-household`);
-                    set(partialApplication, `${paths.Household}.Dependant`, dependants);
+                    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.Household}.@UniqueID`, `${applicationId}-household`);
+                    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.Household}.Dependant`, dependants);
                     break;
                 default:
-                    set(partialApplication, applicantMapping[key], value);
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], value);
                     break;
             }
         }
     }
     return partialApplication;
 }
+exports.transformApplicant = transformApplicant;
 const contactMapping = {
     emailAddress: 'EmailAddress.0.@Email',
     mobileNumber: 'Mobile.@Number',
@@ -100,7 +105,7 @@ const contactMapping = {
  * @param contact
  * @param id
  */
-export function generateContact(contact, id) {
+function generateContact(contact, id) {
     const lixiContact = {};
     const lixiAddresses = [];
     for (const [key, value] of Object.entries(contact)) {
@@ -109,25 +114,25 @@ export function generateContact(contact, id) {
                 case 'currentAddress':
                     {
                         const addressId = `${id}-current`;
-                        const { lixiAddress, lixiContactAddress } = rebuildAddress(value, addressId);
+                        const { lixiAddress, lixiContactAddress } = (0, address_tools_1.rebuildAddress)(value, addressId);
                         lixiAddresses.push(lixiAddress);
-                        set(lixiContact, contactMapping[key], lixiContactAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
                     }
                     break;
                 case 'postSettlementAddress':
                     {
                         const addressId = `${id}-postSettlement`;
-                        const { lixiAddress, lixiContactAddress } = rebuildAddress({ residentialAddress: value }, addressId);
+                        const { lixiAddress, lixiContactAddress } = (0, address_tools_1.rebuildAddress)({ residentialAddress: value }, addressId);
                         lixiAddresses.push(lixiAddress);
-                        set(lixiContact, contactMapping[key], lixiContactAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
                     }
                     break;
                 case 'mailingAddress':
                     {
                         const addressId = `${id}-mailing`;
-                        const { lixiAddress } = rebuildAddress({ residentialAddress: value }, addressId);
+                        const { lixiAddress } = (0, address_tools_1.rebuildAddress)({ residentialAddress: value }, addressId);
                         lixiAddresses.push(lixiAddress);
-                        set(lixiContact, contactMapping[key], addressId);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], addressId);
                     }
                     break;
                 case 'previousAddresses':
@@ -135,32 +140,33 @@ export function generateContact(contact, id) {
                         const addressId = `${id}-previous`;
                         const previousAddresses = value.sort((lhs, rhs) => lhs.endDate.localeCompare(rhs.endDate));
                         const previousAddress = previousAddresses.pop();
-                        const { lixiAddress, lixiContactAddress } = rebuildAddress(previousAddress, addressId);
+                        const { lixiAddress, lixiContactAddress } = (0, address_tools_1.rebuildAddress)(previousAddress, addressId);
                         lixiAddresses.push(lixiAddress);
-                        set(lixiContact, contactMapping[key], lixiContactAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
                         // PriorAddresses
                         previousAddresses.forEach((address, index) => {
-                            const { lixiAddress, lixiContactAddress } = rebuildAddress(address, `${id}-prior-${index}`);
+                            const { lixiAddress, lixiContactAddress } = (0, address_tools_1.rebuildAddress)(address, `${id}-prior-${index}`);
                             lixiAddresses.push(lixiAddress);
-                            set(lixiContact, `${contactMapping['priorAddress']}.${index}`, lixiContactAddress);
+                            (0, lodash_1.set)(lixiContact, `${contactMapping['priorAddress']}.${index}`, lixiContactAddress);
                         });
                     }
                     break;
                 default:
-                    set(lixiContact, contactMapping[key], value);
+                    (0, lodash_1.set)(lixiContact, contactMapping[key], value);
                     break;
             }
         }
     }
     return { lixiContact, lixiAddresses };
 }
+exports.generateContact = generateContact;
 /**
  * Generate dependants
  *
  * @param dependants
  * @param id
  */
-export function generateDependants(dependants, id) {
+function generateDependants(dependants, id) {
     return dependants.map((dependant) => ({
         '@Age': dependant.age,
         '@UniqueID': dependant.id,
@@ -171,3 +177,4 @@ export function generateDependants(dependants, id) {
         ],
     }));
 }
+exports.generateDependants = generateDependants;

package/lib/transform-events/transform-application-workflow.js

@@ -1,19 +1,23 @@
-import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
-import { set } from 'lodash';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformApplicationWorkflow = void 0;
+const application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+const lodash_1 = require("lodash");
 /**
  * Generates a partial application from an ApplicationWorkflow event
  *
  * @param applicationWorkflowEventPayload ApplicationWorkflow event payload
  * @returns A partial application
  */
-export function transformApplicationWorkflow(applicationWorkflowEventPayload) {
+function transformApplicationWorkflow(applicationWorkflowEventPayload) {
     const { stage, applicationStage, applicationId } = applicationWorkflowEventPayload, partialApplication = {};
-    set(partialApplication, paths.ApplicationId, applicationId);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
     // The stage being defaulted to Unknown caters for LGSF application workflow events having stage as an optional attribute in the future
     const instructionDetails = {
         '@UniqueID': `${applicationId}-stage`,
         '@Details': applicationStage || stage || 'Unknown',
     };
-    set(partialApplication, paths.Instructions, instructionDetails);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.Instructions, instructionDetails);
     return partialApplication;
 }
+exports.transformApplicationWorkflow = transformApplicationWorkflow;

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

@@ -1,16 +1,14 @@
 import { Payload as ApplicationPayload } from '../types/events/public-application';
-interface transformApplicationOptions {
+export interface TransformApplicationOptions {
     uniqueIdSuffix?: string;
     enableRateLock?: boolean;
+    enableFastRefi?: boolean;
 }
 /**
  * Transforms a partial opportunity event to a partial internal request.
  *
- * @param opportunity: Partial opportunity event.
- * @param uniqueIdSuffix: Suffix for uniquerId
- * @param opportunity
- * @param options
- * @returns  partialApplication: A partial internal request.
+ * @param {ApplicationPayload} opportunity Public application event payload
+ * @param {TransformApplicationOptions} options Options for transforming the public application event
+ * @returns Partial application
  */
-export declare function transformApplication(opportunity: ApplicationPayload, options?: transformApplicationOptions): {};
-export {};
+export declare function transformApplication(opportunity: ApplicationPayload, options?: TransformApplicationOptions): {};

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

@@ -1,35 +1,39 @@
-import { EventNameApplicationInstructionsList } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
-import { paths as creditProtocolPaths } from '@lendi/integrations-credit-protocol/utils/application-paths';
-import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
-import { set } from 'lodash';
-import { preferredRepaymentMapping, transactionTypeMapping } from '../types/enum-mappings/';
-import { booleanMapping } from './transform-applicant';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformApplication = void 0;
+const lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
+const application_paths_1 = require("@lendi/integrations-credit-protocol/utils/application-paths");
+const application_paths_2 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+const lodash_1 = require("lodash");
+const enum_mappings_1 = require("../types/enum-mappings/");
+const transform_applicant_1 = require("./transform-applicant");
 /**
  * Transforms a partial opportunity event to a partial internal request.
  *
- * @param opportunity: Partial opportunity event.
- * @param uniqueIdSuffix: Suffix for uniquerId
- * @param opportunity
- * @param options
- * @returns  partialApplication: A partial internal request.
+ * @param {ApplicationPayload} opportunity Public application event payload
+ * @param {TransformApplicationOptions} options Options for transforming the public application event
+ * @returns Partial application
  */
-export function transformApplication(opportunity, options = {}) {
-    const { uniqueIdSuffix = 'loanDetails', enableRateLock = false } = options;
+function transformApplication(opportunity, options = {}) {
+    const { uniqueIdSuffix = 'loanDetails', enableRateLock = false, enableFastRefi = false } = options;
     const partialApplication = {};
     const opportunityMapping = {
-        brand: paths.BusinessName,
-        id: paths.ApplicationId,
-        paymentType: `${paths.LoanTerm}.@PaymentType`,
+        brand: application_paths_2.paths.BusinessName,
+        id: application_paths_2.paths.ApplicationId,
+        paymentType: `${application_paths_2.paths.LoanTerm}.@PaymentType`,
         preliminary: 'preliminary',
-        primaryPurpose: paths.PurposeOfApplication,
+        primaryPurpose: application_paths_2.paths.PurposeOfApplication,
         brokerPrimaryPurpose: 'Package.Content.NeedsAnalysis.PurposeOfApplication[0].@Description',
     };
-    set(partialApplication, `${paths.LoanDetail}.@UniqueID`, `${opportunity.id}-${uniqueIdSuffix}`);
-    set(partialApplication, `${creditProtocolPaths.Instructions}.@UniqueID`, `${opportunity.id}-stage`);
-    set(partialApplication, `${creditProtocolPaths.Instructions}.@Name`, EventNameApplicationInstructionsList.ApplicationReceived);
+    (0, lodash_1.set)(partialApplication, `${application_paths_2.paths.LoanDetail}.@UniqueID`, `${opportunity.id}-${uniqueIdSuffix}`);
+    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.Instructions}.@UniqueID`, `${opportunity.id}-stage`);
+    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.Instructions}.@Name`, lixi_internal_request_1.EventNameApplicationInstructionsList.ApplicationReceived);
+    const { hasOptedInRateLock = false, isFastRefi = false } = opportunity;
     if (enableRateLock) {
-        const { hasOptedInRateLock = false } = opportunity;
-        set(partialApplication, `${creditProtocolPaths.FeaturesSelected}.@RateLock`, booleanMapping(hasOptedInRateLock));
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.FeaturesSelected}.@RateLock`, (0, transform_applicant_1.booleanMapping)(hasOptedInRateLock));
+    }
+    if (enableFastRefi) {
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.Overview}.@FastRefinance`, (0, transform_applicant_1.booleanMapping)(isFastRefi));
     }
     for (const [opportunityKey, opportunityValue] of Object.entries(opportunity)) {
         if (opportunityMapping[opportunityKey]) {
@@ -38,19 +42,20 @@ export function transformApplication(opportunity, options = {}) {
                     if (opportunityMapping[key]) {
                         switch (key) {
                             case 'paymentType':
-                                set(partialApplication, opportunityMapping[key], preferredRepaymentMapping[value]);
+                                (0, lodash_1.set)(partialApplication, opportunityMapping[key], enum_mappings_1.preferredRepaymentMapping[value]);
                                 break;
                             case 'primaryPurpose':
-                                set(partialApplication, opportunityMapping[key], transactionTypeMapping[value]);
+                                (0, lodash_1.set)(partialApplication, opportunityMapping[key], enum_mappings_1.transactionTypeMapping[value]);
                                 break;
                         }
                     }
                 }
             }
             else {
-                set(partialApplication, opportunityMapping[opportunityKey], opportunityValue);
+                (0, lodash_1.set)(partialApplication, opportunityMapping[opportunityKey], opportunityValue);
             }
         }
     }
     return partialApplication;
 }
+exports.transformApplication = transformApplication;

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

@@ -1,22 +1,26 @@
-import { CountryCodeList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
-import { set } from 'lodash';
-import { countryCodeMapping, postcodeMapping } from '../types/enum-mappings';
-import { extractCountryFromFormatted, isOverseasAddress } from '../utils/address-tools';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStandard = exports.transformAddress = exports.standardMapping = exports.getAddressMapping = void 0;
+const lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const enum_mappings_1 = require("../types/enum-mappings");
+const address_tools_1 = require("../utils/address-tools");
 /**
  *
  * @param address
  */
-export function getAddressMapping(address) {
+function getAddressMapping(address) {
     return {
         city: '@Suburb',
         country: '@Country',
-        postcode: isOverseasAddress(address) ? '@OverseasPostCode' : '@AustralianPostCode',
-        state: isOverseasAddress(address) ? '@OverseasState' : '@AustralianState',
+        postcode: (0, address_tools_1.isOverseasAddress)(address) ? '@OverseasPostCode' : '@AustralianPostCode',
+        state: (0, address_tools_1.isOverseasAddress)(address) ? '@OverseasState' : '@AustralianState',
         standard: 'Standard',
         formatted: '@Country',
     };
 }
-export const standardMapping = {
+exports.getAddressMapping = getAddressMapping;
+exports.standardMapping = {
     streetName: '@StreetName',
     streetType: '@StreetType',
     streetNumber: '@StreetNumber',
@@ -33,49 +37,51 @@ export const standardMapping = {
  * @param id
  * @returns A transformed address object.
  */
-export function transformAddress(address, id) {
+function transformAddress(address, id) {
     const transformedAddress = {
         '@UniqueID': id,
     };
     const addressMapping = getAddressMapping(address);
     // for an Australian address: if no postcode is provided, infer one from the state:
-    if (!isOverseasAddress(address) && address.state && !address.postcode) {
-        address.postcode = postcodeMapping[address.state];
+    if (!(0, address_tools_1.isOverseasAddress)(address) && address.state && !address.postcode) {
+        address.postcode = enum_mappings_1.postcodeMapping[address.state];
     }
     for (const [key, value] of Object.entries(address)) {
         if (addressMapping[key]) {
             switch (key) {
                 case 'standard':
-                    set(transformedAddress, addressMapping[key], transformStandard(value));
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], transformStandard(value));
                     break;
                 case 'country':
-                    set(transformedAddress, addressMapping[key], isOverseasAddress(address) ? countryCodeMapping[value] : CountryCodeList.Au);
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], (0, address_tools_1.isOverseasAddress)(address) ? enum_mappings_1.countryCodeMapping[value] : lixi_internal_request_1.CountryCodeList.Au);
                     break;
                 case 'formatted':
                     if (!address.country) {
-                        const country = extractCountryFromFormatted(value);
-                        set(transformedAddress, addressMapping[key], countryCodeMapping[country]);
+                        const country = (0, address_tools_1.extractCountryFromFormatted)(value);
+                        (0, lodash_1.set)(transformedAddress, addressMapping[key], enum_mappings_1.countryCodeMapping[country]);
                     }
                     break;
                 default:
-                    set(transformedAddress, addressMapping[key], value);
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], value);
                     break;
             }
         }
     }
     return transformedAddress;
 }
+exports.transformAddress = transformAddress;
 /**
  * @description Generates an address standard.
  * @param {AddressStandard} addressStandard An address standard object.
  * @returns {Partial<Standard>} A transformed standard object.
  */
-export function transformStandard(addressStandard) {
+function transformStandard(addressStandard) {
     const transformedStandard = {};
     for (const [key, value] of Object.entries(addressStandard)) {
-        if (standardMapping[key]) {
-            set(transformedStandard, standardMapping[key], value);
+        if (exports.standardMapping[key]) {
+            (0, lodash_1.set)(transformedStandard, exports.standardMapping[key], value);
         }
     }
     return transformedStandard;
 }
+exports.transformStandard = transformStandard;