@lendi/integrations-transform 1.0.7 → 1.1.1

package/lib/types/events/public-required-document.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The Required Document event schema
+ */
+export interface PublicRequiredDocument {
+    payload: Payload;
+    type: Type;
+    /**
+     * schema version
+     */
+    version: string;
+}
+export interface Payload {
+    /**
+     * Application ID
+     */
+    applicantId: string;
+    /**
+     * Application ID
+     */
+    applicationId: string;
+    /**
+     * Created at ISO date time
+     */
+    createdAt?: string;
+    eConsent?: EConsent;
+    /**
+     * Required Document ID
+     */
+    id: string;
+    identification?: Identification;
+    /**
+     * Status
+     */
+    status?: Status;
+}
+export interface EConsent {
+    /**
+     * Consented at ISO date time
+     */
+    consentedAt?: string;
+    /**
+     * eConsent
+     */
+    hasConsented: boolean;
+}
+export interface Identification {
+    /**
+     * Gender (can be null if migrated from SF as they do not have this field)
+     */
+    gender?: Gender | null;
+    /**
+     * ID Number
+     */
+    idNumber: string;
+    /**
+     * ID Title (can be null if migrated from SF as they do not have this field)
+     */
+    idTitle?: IDTitle | null;
+    /**
+     * ID Type
+     */
+    idType: IDType;
+}
+export declare enum Gender {
+    Female = "FEMALE",
+    Male = "MALE"
+}
+export declare enum IDTitle {
+    DR = "DR",
+    MS = "MS",
+    Miss = "MISS",
+    Mr = "MR",
+    Mrs = "MRS",
+    Other = "OTHER",
+    Unknown = "UNKNOWN"
+}
+/**
+ * ID Type
+ */
+export declare enum IDType {
+    AustralianDriverLicense = "australian_driver_license",
+    NationalIDCard = "national_id_card",
+    Passport = "passport"
+}
+/**
+ * Status
+ */
+export declare enum Status {
+    Expired = "expired",
+    FailedVerification = "failed_verification",
+    NotRequired = "not_required",
+    PendingUpload = "pending_upload",
+    PendingVerification = "pending_verification",
+    Verified = "verified"
+}
+export declare enum Type {
+    RequiredDocumentCreated = "RequiredDocumentCreated",
+    RequiredDocumentUpdated = "RequiredDocumentUpdated"
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+exports.__esModule = true;
+exports.Type = exports.Status = exports.IDType = exports.IDTitle = exports.Gender = void 0;
+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 = {}));
+/**
+ * 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/integrations-protocol/lib/types/lixi-internal-request';
+import { RecursivePartial } from './recursive-partial';
+export declare type PartialApplication = RecursivePartial<InternalRequest>;

package/lib/types/partial-application.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

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

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

package/lib/types/recursive-partial.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

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

@@ -0,0 +1,69 @@
+/**
+ * A set of tools for manipulating addresses in LIXI applications.
+ */
+import { AddressType, CurrentAddress, PreviousAddress } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { CommonAddressProperties, PreviousAddress as InternalPreviousAddress } from '../types/events/public-applicant';
+/**
+ * Type definition for functions used to transform types while mapping from event values to LIXI values.
+ */
+export declare type MappingTransformFunction<I = any, O = any> = (input: I) => O;
+/**
+ * Specifies the destination path of the object in dot notation along with an optional data transform function.
+ */
+export interface MappedTransform {
+    /**
+     * A path in dot notation.
+     */
+    path: string;
+    /**
+     * An optional transform function for the value to be stored at the path.
+     */
+    transform?: MappingTransformFunction;
+}
+/**
+ * A type defining a record set of path mapped transforms
+ */
+export declare type PathMappedTransform = Record<string, MappedTransform>;
+export declare const lixiContactAddressMapping: PathMappedTransform;
+/**
+ * The transform map used for the LIXI address
+ */
+export declare const lixiAddressMapping: PathMappedTransform;
+/**
+ * Transforms a source object by applying a PathMappedTransform.
+ *
+ * @param source A source object to be mapped and transformed
+ * @param pathMappedTransform A PathMappedTransform to be applied to the source
+ */
+export declare function mapTransform<T>(source: any, pathMappedTransform: PathMappedTransform): T;
+declare type EventAddressType = InternalPreviousAddress | CommonAddressProperties;
+export declare type LixiContactAddressType = CurrentAddress | PreviousAddress;
+export interface AddressTransformedType {
+    lixiAddress: AddressType;
+    lixiContactAddress: LixiContactAddressType;
+}
+/**
+ * Converts an address object from an event model to a LIXI address and corresponding LIXI contact address object.
+ *
+ * @param eventAddress
+ * @param addressId
+ */
+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.
+ * @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;
+/**
+ * Sets the country from the last item on the formatted address.
+ *
+ * @param address
+ */
+export declare function setCountry(address: EventAddressType): EventAddressType;
+export {};

package/lib/utils/address-tools.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * A set of tools for manipulating addresses in LIXI applications.
+ */
+exports.__esModule = true;
+exports.setCountry = exports.isMissingCountry = exports.rebuildPreviousAddress = exports.rebuildAddress = exports.mapTransform = exports.lixiAddressMapping = exports.lixiContactAddressMapping = void 0;
+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 = {
+    externalId: {
+        path: '@x_ResidentialAddress'
+    },
+    housingStatus: {
+        path: '@HousingStatus',
+        transform: function (value) { return housing_status_1.housingStatusMapping[value]; }
+    },
+    startDate: {
+        path: '@StartDate'
+    },
+    endDate: {
+        path: '@EndDate'
+    }
+};
+/**
+ * The transform map used for the LIXI address
+ */
+exports.lixiAddressMapping = {
+    externalId: {
+        path: '@UniqueID'
+    },
+    'residentialAddress.city': {
+        path: '@Suburb'
+    },
+    'residentialAddress.country': {
+        path: '@Country',
+        transform: function (value) { return country_code_1.countryCodeMapping[value]; }
+    },
+    'residentialAddress.postcode': {
+        path: '@AustralianPostCode'
+    },
+    'residentialAddress.state': {
+        path: '@AustralianState'
+    },
+    'residentialAddress.standard.level': {
+        path: 'Standard.@Level'
+    },
+    'residentialAddress.standard.streetName': {
+        path: 'Standard.@StreetName'
+    },
+    'residentialAddress.standard.streetNumber': {
+        path: 'Standard.@StreetNumber',
+        transform: function (value) { return value.substring(0, generate_address_1.StreetNumberMaxLength); }
+    },
+    'residentialAddress.standard.streetType': {
+        path: 'Standard.@StreetType'
+    },
+    'residentialAddress.standard.unit': {
+        path: 'Standard.@Unit'
+    }
+};
+/**
+ * Transforms a source object by applying a PathMappedTransform.
+ *
+ * @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);
+        if (sourceValue) {
+            (0, lodash_1.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';
+/**
+ * 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) {
+    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' };
+    }
+    else {
+        exports.lixiAddressMapping[postcodePathString] = { path: '@AustralianPostCode' };
+        exports.lixiAddressMapping[statePathString] = { path: '@AustralianState' };
+    }
+    var lixiAddress = mapTransform(eventAddress, exports.lixiAddressMapping);
+    var lixiContactAddress = mapTransform(eventAddress, exports.lixiContactAddressMapping);
+    lixiAddress['@UniqueID'] = addressId;
+    lixiContactAddress['@x_ResidentialAddress'] = addressId;
+    return { lixiAddress: lixiAddress, lixiContactAddress: lixiContactAddress };
+}
+exports.rebuildAddress = rebuildAddress;
+/**
+ * * 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 = []; }
+    if (eventPreviousAddresses.length === 0)
+        return null;
+    var previousAddress = eventPreviousAddresses.sort(function (lhs, rhs) { return 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) {
+    if (addressEvent.residentialAddress && addressEvent.residentialAddress.formatted) {
+        return !(0, lodash_1.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 _a;
+    var formatted = (0, lodash_1.get)(address, 'residentialAddress.formatted');
+    if (formatted && !address.residentialAddress.country) {
+        address.residentialAddress.country = (_a = formatted.split(',').pop()) === null || _a === void 0 ? void 0 : _a.trim();
+    }
+    return address;
+}
+exports.setCountry = setCountry;

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

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

package/lib/utils/clean-up.js

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

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

@@ -0,0 +1,19 @@
+import { AddressType, Standard, StreetTypeList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { Address, AddressStandard } from '../types/events/public-asset';
+export declare const StreetNumberMaxLength = 16;
+export declare const StreetTypeArray: StreetTypeList[];
+/**
+ * Generates an address for an asset.
+
+ * @param address: An address object.
+ * @param id: Id of asset object.
+ * @return 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.
+ */
+export declare function generateStandard(addressStandard: AddressStandard): Standard;

package/lib/utils/generate-address.js

@@ -0,0 +1,102 @@
+"use strict";
+exports.__esModule = true;
+exports.generateStandard = exports.generateAddress = exports.StreetTypeArray = exports.StreetNumberMaxLength = 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 postcode_1 = require("../types/enum-mappings/postcode");
+var public_asset_1 = require("../types/events/public-asset");
+exports.StreetNumberMaxLength = 16;
+var addressMapping = {
+    country: '@Country',
+    city: '@Suburb',
+    postcode: '@AustralianPostCode',
+    state: '@AustralianState',
+    standard: 'Standard'
+};
+var standardMapping = {
+    streetName: '@StreetName',
+    streetType: '@StreetType',
+    streetNumber: '@StreetNumber',
+    level: '@Level',
+    unit: '@Unit'
+};
+exports.StreetTypeArray = Object.values(lixi_internal_request_1.StreetTypeList);
+/**
+ * Generates an address for an asset.
+
+ * @param address: An address object.
+ * @param id: Id of asset object.
+ * @return A transformed address object.
+ */
+function generateAddress(address, id) {
+    var _a;
+    var transformedAddress = {
+        '@Country': lixi_internal_request_1.CountryCodeList.Au,
+        '@UniqueID': id
+    };
+    var country = (((_a = address.formatted) === null || _a === void 0 ? void 0 : _a.split(',').pop()) || '').trim();
+    if (!address.country && country.length > 0) {
+        address.country = country;
+    }
+    if (address.country && address.country !== public_asset_1.Countries.Australia) {
+        addressMapping.postcode = '@OverseasPostCode';
+        addressMapping.state = '@OverseasState';
+    }
+    else {
+        addressMapping.postcode = '@AustralianPostCode';
+        addressMapping.state = '@AustralianState';
+        if (!address.postcode && address.state) {
+            transformedAddress['@AustralianPostCode'] = postcode_1.postcodeMapping[address.state];
+        }
+    }
+    for (var _i = 0, _b = Object.entries(address); _i < _b.length; _i++) {
+        var _c = _b[_i], key = _c[0], value = _c[1];
+        if (addressMapping[key]) {
+            switch (key) {
+                case 'standard':
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], generateStandard(value));
+                    break;
+                case 'country':
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], country_code_1.countryCodeMapping[value]);
+                    break;
+                default:
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], value);
+                    break;
+            }
+        }
+    }
+    return transformedAddress;
+}
+exports.generateAddress = generateAddress;
+/**
+ * Generates an address standard.
+ *
+ * @param addressStandard An address standard object.
+ * @return A transformed standard object.
+ */
+function generateStandard(addressStandard) {
+    var transformedStandard = {};
+    var _loop_1 = function (key, value) {
+        if (standardMapping[key]) {
+            switch (key) {
+                case 'streetNumber':
+                    (0, lodash_1.set)(transformedStandard, standardMapping[key], value.substring(0, exports.StreetNumberMaxLength));
+                    break;
+                case 'streetType':
+                    var streetType = exports.StreetTypeArray.find(function (type) { return type.toLowerCase() === value.toLowerCase(); });
+                    (0, lodash_1.set)(transformedStandard, standardMapping[key], streetType || lixi_internal_request_1.StreetTypeList.Street);
+                    break;
+                default:
+                    (0, lodash_1.set)(transformedStandard, standardMapping[key], value);
+                    break;
+            }
+        }
+    };
+    for (var _i = 0, _a = Object.entries(addressStandard); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        _loop_1(key, value);
+    }
+    return transformedStandard;
+}
+exports.generateStandard = generateStandard;

package/lib/utils/get-financial-institution.d.ts

@@ -0,0 +1,7 @@
+import { FinancialInstitutionList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+/**
+ * Returns the financialInstitution value form the Enum based on the index where it was found.
+ *
+ * @param institution: Institution value from event.
+ */
+export declare function getFinancialInstitution(institution: string): FinancialInstitutionList;

package/lib/utils/get-financial-institution.js

@@ -0,0 +1,16 @@
+"use strict";
+exports.__esModule = true;
+exports.getFinancialInstitution = void 0;
+var lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
+var financialInstitutions = Object.values(lixi_internal_request_1.FinancialInstitutionList);
+/**
+ * Returns the financialInstitution value form the Enum based on the index where it was found.
+ *
+ * @param institution: Institution value from event.
+ */
+function getFinancialInstitution(institution) {
+    var institutionUpperCased = institution.toUpperCase();
+    var financialInstitution = financialInstitutions.find(function (item) { return item.toUpperCase() === institutionUpperCased; });
+    return financialInstitution || lixi_internal_request_1.FinancialInstitutionList.Other;
+}
+exports.getFinancialInstitution = getFinancialInstitution;

package/lib/utils/is-income-type.d.ts

@@ -0,0 +1,83 @@
+import { PersonApplicant } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { IncomeType, Income, IncomeBusinessDetails } from '../types/events/public-income';
+export declare const descriptionOtherIncomeTypes: string[];
+export declare const PAYGList: string[];
+/**
+ * @description Is income type one of the PAYG income.
+ * @param {string} incomeType Income type.
+ * @returns {boolean} Returns true if Income type is a PAYG Income.
+ */
+export declare function isPaygIncome(incomeType: string): boolean;
+/**
+ * @description Is income type SelfEmployedBusinessIncome.
+ * @param {string} incomeType Income type.
+ * @returns {boolean} Returns true if Income type is SelfEmployedBusinessIncome.
+ */
+export declare function isSelfEmployedIncome(incomeType: string): boolean;
+/**
+ * @description Is income type Rental Income.
+ * @param {IncomeType} incomeType Income type.
+ * @returns {boolean} true if Income type is Rental Income.
+ */
+export declare function isRentalIncome(incomeType: string): boolean;
+/**
+ * @description Is Income type one of OtherIncome types.
+ * @param {IncomeType} incomeType Income Type.
+ * @returns {boolean} returns true for other income.
+ */
+export declare function isOtherIncome(incomeType: string): boolean;
+/**
+ * @description Is Self Employed Full Doc or Low Doc Income
+ * @param incomeType Income Type from Event
+ * @returns {boolean} True if either Full Doc or Low Doc Self Employed Income.
+ */
+export declare function isFullDocOrLowDocIncome(incomeType: IncomeType): boolean;
+/**
+ * @description Checks if an Income event is a valid rental income event.
+ * @param {Income} income Income.
+ * @returns {boolean} true if event is a valid Rental Income.
+ */
+export declare function isValidRentalIncomeEvent({ assetId, type: incomeType }: Income): boolean;
+/**
+ * @description Is event valid PAYG income event.
+ * @param {Income} income Income.
+ * @param {PersonApplicant[]} applicants An array of applicants.
+ * @returns {boolean} true if Income type is a PAYG value and event is valid PAYG event.
+ */
+export declare function isValidPaygIncomeEvent({ percentOwned, employmentId, type: incomeType }: Income, applicants?: PersonApplicant[]): boolean;
+/**
+ * @description Checks if an Income event is a valid self-employment income event.
+ * @param {Income} income Income.
+ * @param {PersonApplicant[]} applicants An array of applicants.
+ * @returns {boolean} Returns true if event is a valid self employment income event.
+ */
+export declare function isValidSelfEmployedIncomeEvent({ percentOwned, employmentId, type: incomeType }: Income, applicants?: PersonApplicant[]): boolean;
+/**
+ * @description Get the employment ids for an applicant for a specific employment type.
+ * @param {PersonApplicant} applicant An applicant
+ * @param {string} key Employment type key: PAYG or SelfEmployed.
+ * @returns {string[]} An array of employment ids for the applicant of the specified type.
+ */
+export declare function getEmploymentIds(applicant: PersonApplicant, key: 'PAYG' | 'SelfEmployed'): string[];
+/**
+ * @description Get applicantId from an array of applicants given an employmentId and employmentType.
+ * @param {PersonApplicant[]} applicants An array of applicants.
+ * @param {string} employmentId EmploymentId
+ * @param {string} key Employment type: PAYG or SelfEmployed
+ * @returns {string | undefined} Returns applicantId or undefined.
+ */
+export declare function getStoredApplicantId(applicants: PersonApplicant[], employmentId: string, key: 'PAYG' | 'SelfEmployed'): string | undefined;
+/**
+ * @description Get an applicantId from the event or the applicants.
+ * @param {Income} income Income.
+ * @param {PersonApplicant[]} applicants An array of LIXI applicants.
+ * @returns {string | undefined} An applicantId or undefined.
+ */
+export declare function getApplicantId({ percentOwned, employmentId }: Income, applicants?: PersonApplicant[]): string | undefined;
+/**
+ * @description Sort Business Income By Year.
+ * @param incomeA Income Details for Self Employed Full Doc.
+ * @param incomeB Income Details for Self Employed Full Doc.
+ * @returns {0 | - 1 | 1} Returns a number to be used for sorting income.
+ */
+export declare function sortBusinessIncome({ year: yearA }: IncomeBusinessDetails, { year: yearB }: IncomeBusinessDetails): number;