@lendi/integrations-transform 1.0.7 → 1.1.1

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

@@ -0,0 +1,189 @@
+"use strict";
+exports.__esModule = true;
+exports.generateDependants = exports.generateContact = exports.transformApplicant = exports.booleanMapping = void 0;
+var lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
+var application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+var lodash_1 = require("lodash");
+var address_tools_1 = require("../utils/address-tools");
+var country_code_1 = require("../types/enum-mappings/country-code");
+var marital_status_1 = require("../types/enum-mappings/marital-status");
+var residency_status_1 = require("../types/enum-mappings/residency-status");
+var title_1 = require("../types/enum-mappings/title");
+var public_applicant_1 = require("../types/events/public-applicant");
+var normalise_date_1 = require("../utils/normalise-date");
+var booleanMapping = function (input) {
+    if (input === void 0) { input = false; }
+    return (input === true ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No);
+};
+exports.booleanMapping = booleanMapping;
+var applicantMapping = {
+    applicationId: application_paths_1.paths.ApplicationId,
+    citizenship: "".concat(application_paths_1.paths.PersonApplicant, ".@Citizenship"),
+    contact: "".concat(application_paths_1.paths.PersonApplicant, ".Contact"),
+    dependants: 'dependants',
+    dateOfBirth: "".concat(application_paths_1.paths.PersonApplicant, ".@DateOfBirth"),
+    firstName: "".concat(application_paths_1.paths.PersonApplicant, ".PersonName.@FirstName"),
+    id: "".concat(application_paths_1.paths.PersonApplicant, ".@UniqueID"),
+    isFirstHomeBuyer: "".concat(application_paths_1.paths.PersonApplicant, ".@FirstHomeBuyer"),
+    isPrimaryApplicant: "".concat(application_paths_1.paths.PersonApplicant, ".@PrimaryApplicant"),
+    lastName: "".concat(application_paths_1.paths.PersonApplicant, ".PersonName.@Surname"),
+    maritalStatus: "".concat(application_paths_1.paths.PersonApplicant, ".@MaritalStatus"),
+    maritalDetails: "".concat(application_paths_1.paths.PersonApplicant, ".MaritalStatusDetails.@x_Spouse"),
+    middleName: "".concat(application_paths_1.paths.PersonApplicant, ".PersonName.@MiddleNames"),
+    residencyStatus: "".concat(application_paths_1.paths.PersonApplicant, ".@ResidencyStatus"),
+    title: "".concat(application_paths_1.paths.PersonName, ".@NameTitle")
+};
+/**
+ * Transforms a partial Applicant event to a partial LIXI application.
+ *
+ * @param applicant: A partial applicant.
+ * @return partialApplication an incomplete application.
+ */
+function transformApplicant(applicant) {
+    var partialApplication = {};
+    var applicantId = applicant.id, applicationId = applicant.applicationId;
+    (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'], title_1.titleMapping[applicant.title || public_applicant_1.Title.Unknown]);
+    var applicantUpdated = (0, lodash_1.omit)(applicant, ['isFirstHomeBuyer', 'isPrimaryApplicant', 'title']);
+    for (var _i = 0, _a = Object.entries(applicantUpdated); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        if (applicantMapping[key]) {
+            switch (key) {
+                case 'dateOfBirth':
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], (0, normalise_date_1.normaliseDate)(value));
+                    break;
+                case 'maritalStatus':
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], marital_status_1.maritalStatusMapping[value]);
+                    break;
+                case 'citizenship':
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], country_code_1.countryCodeMapping[value]);
+                    break;
+                case 'residencyStatus':
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], residency_status_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 === public_applicant_1.ResidencyStatus.AustralianCitizen) {
+                        (0, lodash_1.set)(partialApplication, applicantMapping.citizenship, lixi_internal_request_1.CountryCodeList.Au);
+                    }
+                    break;
+                case 'maritalDetails':
+                    var id = (0, lodash_1.get)(value, 'applicantId');
+                    if (id)
+                        (0, lodash_1.set)(partialApplication, applicantMapping[key], id);
+                    break;
+                case 'contact':
+                    var _c = generateContact(value, applicantId), lixiContact = _c.lixiContact, lixiAddresses = _c.lixiAddresses;
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], lixiContact);
+                    if (lixiAddresses.length > 0) {
+                        (0, lodash_1.set)(partialApplication, application_paths_1.paths.Addresses, lixiAddresses);
+                    }
+                    break;
+                case 'dependants':
+                    var dependants = generateDependants(value, applicantId);
+                    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Household, ".@UniqueID"), "".concat(applicationId, "-household"));
+                    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Household, ".Dependant"), dependants);
+                    break;
+                default:
+                    (0, lodash_1.set)(partialApplication, applicantMapping[key], value);
+                    break;
+            }
+        }
+    }
+    return partialApplication;
+}
+exports.transformApplicant = transformApplicant;
+var contactMapping = {
+    emailAddress: 'EmailAddress.0.@Email',
+    mobileNumber: 'Mobile.@Number',
+    currentAddress: 'CurrentAddress',
+    previousAddresses: 'PreviousAddress',
+    priorAddress: 'PriorAddress',
+    mailingAddress: 'CurrentAddress.@x_MailingAddress',
+    postSettlementAddress: 'PostSettlementAddress'
+};
+/**
+ * Generates a LIXI contact from given contact.
+ *
+ * @param contact
+ * @param id
+ */
+function generateContact(contact, id) {
+    var lixiContact = {};
+    var lixiAddresses = [];
+    for (var _i = 0, _a = Object.entries(contact); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        if (contactMapping[key]) {
+            switch (key) {
+                case 'currentAddress':
+                    {
+                        var addressId = "".concat(id, "-current");
+                        var _c = (0, address_tools_1.rebuildAddress)(value, addressId), lixiAddress = _c.lixiAddress, lixiContactAddress = _c.lixiContactAddress;
+                        lixiAddresses.push(lixiAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
+                    }
+                    break;
+                case 'postSettlementAddress':
+                    {
+                        var addressId = "".concat(id, "-postSettlement");
+                        var _d = (0, address_tools_1.rebuildAddress)({ residentialAddress: value }, addressId), lixiAddress = _d.lixiAddress, lixiContactAddress = _d.lixiContactAddress;
+                        lixiAddresses.push(lixiAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
+                    }
+                    break;
+                case 'mailingAddress':
+                    {
+                        var addressId = "".concat(id, "-mailing");
+                        var lixiAddress = (0, address_tools_1.rebuildAddress)({ residentialAddress: value }, addressId).lixiAddress;
+                        lixiAddresses.push(lixiAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], addressId);
+                    }
+                    break;
+                case 'previousAddresses':
+                    {
+                        var addressId = "".concat(id, "-previous");
+                        var previousAddresses = value.sort(function (lhs, rhs) {
+                            return lhs.endDate.localeCompare(rhs.endDate);
+                        });
+                        var previousAddress = previousAddresses.pop();
+                        var _e = (0, address_tools_1.rebuildAddress)(previousAddress, addressId), lixiAddress = _e.lixiAddress, lixiContactAddress = _e.lixiContactAddress;
+                        lixiAddresses.push(lixiAddress);
+                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
+                        // PriorAddresses
+                        previousAddresses.forEach(function (address, index) {
+                            var _a = (0, address_tools_1.rebuildAddress)(address, "".concat(id, "-prior-").concat(index)), lixiAddress = _a.lixiAddress, lixiContactAddress = _a.lixiContactAddress;
+                            lixiAddresses.push(lixiAddress);
+                            (0, lodash_1.set)(lixiContact, "".concat(contactMapping['priorAddress'], ".").concat(index), lixiContactAddress);
+                        });
+                    }
+                    break;
+                default:
+                    (0, lodash_1.set)(lixiContact, contactMapping[key], value);
+                    break;
+            }
+        }
+    }
+    return { lixiContact: lixiContact, lixiAddresses: lixiAddresses };
+}
+exports.generateContact = generateContact;
+/**
+ * Generate dependants
+ *
+ * @param dependants
+ * @param id
+ */
+function generateDependants(dependants, id) {
+    return dependants.map(function (dependant) { return ({
+        '@Age': dependant.age,
+        '@UniqueID': dependant.id,
+        FinancialProvider: [
+            {
+                '@x_Party': id
+            },
+        ]
+    }); });
+}
+exports.generateDependants = generateDependants;

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

@@ -0,0 +1,8 @@
+import { Payload as ApplicationPayload } from '../types/events/public-application';
+/**
+ * Transforms a partial opportunity event to a partial internal request.
+ *
+ * @param opportunity: Partial opportunity event.
+ * @return  partialApplication: A partial internal request.
+ */
+export declare function transformApplication(opportunity: ApplicationPayload): {};

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

@@ -0,0 +1,54 @@
+"use strict";
+exports.__esModule = true;
+exports.transformApplication = void 0;
+var lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
+var application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+var application_paths_2 = require("@lendi/integrations-credit-protocol/utils/application-paths");
+var lodash_1 = require("lodash");
+var preferred_repayment_1 = require("../types/enum-mappings/preferred-repayment");
+var transaction_type_1 = require("../types/enum-mappings/transaction-type");
+/**
+ * Transforms a partial opportunity event to a partial internal request.
+ *
+ * @param opportunity: Partial opportunity event.
+ * @return  partialApplication: A partial internal request.
+ */
+function transformApplication(opportunity) {
+    var partialApplication = {};
+    var opportunityMapping = {
+        brand: application_paths_1.paths.BusinessName,
+        id: application_paths_1.paths.ApplicationId,
+        paymentType: "".concat(application_paths_1.paths.LoanTerm, ".@PaymentType"),
+        preliminary: 'preliminary',
+        primaryPurpose: application_paths_1.paths.PurposeOfApplication,
+        brokerPrimaryPurpose: 'Package.Content.NeedsAnalysis.PurposeOfApplication[0].@Description'
+    };
+    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.LoanDetail, ".@UniqueID"), "".concat(opportunity.id, "-loanDetails"));
+    (0, lodash_1.set)(partialApplication, "".concat(application_paths_2.paths.Instructions, ".@UniqueID"), "".concat(opportunity.id, "-stage"));
+    (0, lodash_1.set)(partialApplication, "".concat(application_paths_2.paths.Instructions, ".@Name"), lixi_internal_request_1.EventNameApplicationInstructionsList.ApplicationReceived);
+    for (var _i = 0, _a = Object.entries(opportunity); _i < _a.length; _i++) {
+        var _b = _a[_i], opportunityKey = _b[0], opportunityValue = _b[1];
+        if (opportunityMapping[opportunityKey]) {
+            if (opportunityKey === 'preliminary') {
+                for (var _c = 0, _d = Object.entries(opportunityValue); _c < _d.length; _c++) {
+                    var _e = _d[_c], key = _e[0], value = _e[1];
+                    if (opportunityMapping[key]) {
+                        switch (key) {
+                            case 'paymentType':
+                                (0, lodash_1.set)(partialApplication, opportunityMapping[key], preferred_repayment_1.preferredRepaymentMapping[value]);
+                                break;
+                            case 'primaryPurpose':
+                                (0, lodash_1.set)(partialApplication, opportunityMapping[key], transaction_type_1.transactionTypeMapping[value]);
+                                break;
+                        }
+                    }
+                }
+            }
+            else {
+                (0, lodash_1.set)(partialApplication, opportunityMapping[opportunityKey], opportunityValue);
+            }
+        }
+    }
+    return partialApplication;
+}
+exports.transformApplication = transformApplication;

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

@@ -0,0 +1,37 @@
+import { LivingExpense, OtherCommitment } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { Expense, ExpenseType, Payload as ExpensePayload } from '../types/events/public-expense';
+import { PartialApplication } from '../types/partial-application';
+export declare const otherCommitmentExpenseTypes: ExpenseType[];
+/**
+ * @description Transforms expense items on the application from the event.
+ * @returns {PartialApplication} A PartialApplication returned by transforming the expense event.
+ * @param expense
+ */
+export declare function transformExpenses(expense: ExpensePayload): PartialApplication;
+/**
+ * transforms the living expense from the expense array on the event.
+ *
+ * @param expense: Array of expenses on the event.
+ * @param applicantId: Event applicantId.
+ * @param index: Index of the map.
+ * @param id: Id of the event.
+ */
+export declare function transformExpense(expense: Expense, applicantId: string, index: number, id: string): LivingExpense | OtherCommitment;
+/**
+ * @description Normalises expense by amount to 0 if not provided and scales quarterly spending up to yearly.
+ * @param {Expense} expense An expense
+ * @returns {Expense} An normalised expense.
+ */
+export declare function normaliseExpenseAmount(expense: Expense): Expense;
+/**
+ * @description Verify if expense is an OtherCommitment.
+ * @param {Expense} expense Any Expense item.
+ * @returns {boolean} Returns true if an expense type is one of other commitment expenses.
+ */
+export declare function isOtherCommitment(expense: Expense): boolean;
+/**
+ * @description Check if expense type is LivingExpenseEstimate.
+ * @param {Expense} expense An Expense item.
+ * @returns {boolean} Returns true if an expense type is LivingExpenseEstimate
+ */
+export declare function isLivingExpenseEstimate(expense: Expense): boolean;

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

@@ -0,0 +1,121 @@
+"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.isLivingExpenseEstimate = exports.isOtherCommitment = exports.normaliseExpenseAmount = exports.transformExpense = exports.transformExpenses = exports.otherCommitmentExpenseTypes = void 0;
+var application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+var lodash_1 = require("lodash");
+var expense_frequency_1 = require("../types/enum-mappings/expense-frequency");
+var living_expense_1 = require("../types/enum-mappings/living-expense");
+var public_expense_1 = require("../types/events/public-expense");
+exports.otherCommitmentExpenseTypes = [
+    public_expense_1.ExpenseType.Board,
+    public_expense_1.ExpenseType.ChildAndSpousalMaintenance,
+    public_expense_1.ExpenseType.Rent,
+];
+/**
+ * @description Transforms expense items on the application from the event.
+ * @returns {PartialApplication} A PartialApplication returned by transforming the expense event.
+ * @param expense
+ */
+function transformExpenses(expense) {
+    var partialApplication = {};
+    var applicantId = expense.applicantId, applicationId = expense.applicationId, _a = expense.expenses, expenses = _a === void 0 ? [] : _a, id = expense.id;
+    if (expenses.every(function (expense) { return expense.amount === undefined || expense.amount === null; })) {
+        return partialApplication;
+    }
+    var normalisedExpenses = expenses.map(normaliseExpenseAmount);
+    var livingExpenseEstimate = normalisedExpenses.find(isLivingExpenseEstimate);
+    var otherCommitments = normalisedExpenses.filter(isOtherCommitment);
+    var expenseBreakdown = normalisedExpenses.filter(function (item) { return !(isOtherCommitment(item) || isLivingExpenseEstimate(item)); });
+    var livingExpenseEstimateExists = (0, lodash_1.get)(livingExpenseEstimate || {}, 'amount', 0) > 0;
+    var expenseBreakdownAmountSum = (0, lodash_1.sumBy)(expenseBreakdown, 'amount');
+    var lixiLivingExpenses = [];
+    // unless all individual expenses have a value of 0 and a living estimate exists, transform them without question.
+    if (expenseBreakdownAmountSum === 0 && livingExpenseEstimateExists) {
+        var estimate = transformExpense(livingExpenseEstimate, applicantId, 0, id);
+        lixiLivingExpenses = [estimate];
+    }
+    else {
+        lixiLivingExpenses = expenseBreakdown.map(function (expense, index) {
+            return transformExpense(expense, applicantId, index, id);
+        });
+    }
+    var lixiCommitmentExpenses = otherCommitments.map(function (expense, index) { return transformExpense(expense, applicantId, index, id); });
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
+    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Household, ".@UniqueID"), "".concat(applicationId, "-household"));
+    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.PersonApplicant, ".@UniqueID"), applicantId);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.OtherCommitments, lixiCommitmentExpenses);
+    if (lixiLivingExpenses.length > 0) {
+        (0, lodash_1.set)(partialApplication, application_paths_1.paths.LivingExpenses, lixiLivingExpenses);
+    }
+    return partialApplication;
+}
+exports.transformExpenses = transformExpenses;
+/**
+ * transforms the living expense from the expense array on the event.
+ *
+ * @param expense: Array of expenses on the event.
+ * @param applicantId: Event applicantId.
+ * @param index: Index of the map.
+ * @param id: Id of the event.
+ */
+function transformExpense(expense, applicantId, index, id) {
+    return {
+        '@Amount': expense.amount,
+        '@Category': living_expense_1.livingExpenseMapping[expense.type],
+        '@Description': expense.type,
+        '@UniqueID': isOtherCommitment(expense) ? "".concat(id, "-commitment-").concat(index) : "".concat(id, "-living-expense-").concat(index),
+        '@Frequency': expense_frequency_1.frequencyMapping[expense.frequency],
+        PercentResponsible: {
+            Owner: [
+                {
+                    '@Percent': 100,
+                    '@x_Party': applicantId
+                },
+            ]
+        }
+    };
+}
+exports.transformExpense = transformExpense;
+/**
+ * @description Normalises expense by amount to 0 if not provided and scales quarterly spending up to yearly.
+ * @param {Expense} expense An expense
+ * @returns {Expense} An normalised expense.
+ */
+function normaliseExpenseAmount(expense) {
+    var _a = (0, lodash_1.pick)(expense, 'amount', 'frequency'), _b = _a.amount, amount = _b === void 0 ? 0 : _b, _c = _a.frequency, frequency = _c === void 0 ? public_expense_1.Frequency.Yearly : _c;
+    if (frequency === public_expense_1.Frequency.Quarterly) {
+        frequency = public_expense_1.Frequency.Yearly;
+        amount = amount * 4;
+    }
+    return __assign(__assign({}, expense), { amount: amount, frequency: frequency });
+}
+exports.normaliseExpenseAmount = normaliseExpenseAmount;
+/**
+ * @description Verify if expense is an OtherCommitment.
+ * @param {Expense} expense Any Expense item.
+ * @returns {boolean} Returns true if an expense type is one of other commitment expenses.
+ */
+function isOtherCommitment(expense) {
+    return exports.otherCommitmentExpenseTypes.includes(expense.type);
+}
+exports.isOtherCommitment = isOtherCommitment;
+/**
+ * @description Check if expense type is LivingExpenseEstimate.
+ * @param {Expense} expense An Expense item.
+ * @returns {boolean} Returns true if an expense type is LivingExpenseEstimate
+ */
+function isLivingExpenseEstimate(expense) {
+    return expense.type === public_expense_1.ExpenseType.LivingExpensesEstimate;
+}
+exports.isLivingExpenseEstimate = isLivingExpenseEstimate;

package/lib/types/enum-mappings/alieo-frequency.d.ts

@@ -0,0 +1,15 @@
+import { List as LIXIFrequency } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { RepaymentFrequency } from '../events/public-liability';
+import { Frequency } from '../events/public-income';
+export declare type LiabilityFrequencyMapping = {
+    [key in RepaymentFrequency]: LIXIFrequency;
+};
+export declare type IncomeExpenseFrequencyMapping = {
+    [key in RepaymentFrequency | Frequency]: LIXIFrequency;
+};
+export declare type RentalIncomeFrequencyMapping = {
+    [key in Frequency]: LIXIFrequency;
+};
+export declare const incomeExpenseFrequencyMapping: IncomeExpenseFrequencyMapping;
+export declare const liabilityFrequencyMapping: LiabilityFrequencyMapping;
+export declare const rentalIncomeFrequencyMapping: Partial<RentalIncomeFrequencyMapping>;

package/lib/types/enum-mappings/alieo-frequency.js

@@ -0,0 +1,26 @@
+"use strict";
+var _a, _b, _c;
+exports.__esModule = true;
+exports.rentalIncomeFrequencyMapping = exports.liabilityFrequencyMapping = exports.incomeExpenseFrequencyMapping = void 0;
+var lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
+var public_liability_1 = require("../events/public-liability");
+var public_income_1 = require("../events/public-income");
+exports.incomeExpenseFrequencyMapping = (_a = {},
+    _a[public_income_1.Frequency.Fortnightly] = lixi_internal_request_1.List.Fortnightly,
+    _a[public_income_1.Frequency.Monthly] = lixi_internal_request_1.List.Monthly,
+    _a[public_income_1.Frequency.Weekly] = lixi_internal_request_1.List.Weekly,
+    _a[public_income_1.Frequency.Quarterly] = lixi_internal_request_1.List.Yearly,
+    _a[public_income_1.Frequency.Yearly] = lixi_internal_request_1.List.Yearly,
+    _a);
+exports.liabilityFrequencyMapping = (_b = {},
+    _b[public_liability_1.RepaymentFrequency.Yearly] = lixi_internal_request_1.List.Yearly,
+    _b[public_liability_1.RepaymentFrequency.Monthly] = lixi_internal_request_1.List.Monthly,
+    _b[public_liability_1.RepaymentFrequency.Fortnightly] = lixi_internal_request_1.List.Fortnightly,
+    _b[public_liability_1.RepaymentFrequency.Weekly] = lixi_internal_request_1.List.Weekly,
+    _b);
+exports.rentalIncomeFrequencyMapping = (_c = {},
+    _c[public_income_1.Frequency.Fortnightly] = lixi_internal_request_1.List.Fortnightly,
+    _c[public_income_1.Frequency.Monthly] = lixi_internal_request_1.List.Monthly,
+    _c[public_income_1.Frequency.Weekly] = lixi_internal_request_1.List.Weekly,
+    _c[public_income_1.Frequency.Yearly] = lixi_internal_request_1.List.Yearly,
+    _c);

package/lib/types/enum-mappings/country-code.d.ts

@@ -0,0 +1,7 @@
+import { Countries } from '../events/public-applicant';
+import { CountryCodeList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+declare type CountryCodeMapping = {
+    [key in Countries]: CountryCodeList;
+};
+export declare const countryCodeMapping: Partial<CountryCodeMapping>;
+export {};