@lendi/act-credit-decisions-transform 1.9.0

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

@@ -0,0 +1,84 @@
+/**
+ * A set of tools for manipulating addresses in LIXI applications.
+ */
+import { AddressType, CurrentAddress, PreviousAddress } from '@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request';
+import { Address, CommonAddressProperties, Countries, 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 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 type PathMappedTransform = Record<string, MappedTransform>;
+export declare const lixiContactAddressMapping: PathMappedTransform;
+export declare const australianStates: string[];
+/**
+ * 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;
+type EventAddressType = InternalPreviousAddress | CommonAddressProperties;
+export 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;
+/**
+ * @description Extract a country from a formatted address.
+ * @param {string} formatted - A formatted Address.
+ * @returns {Countries} The country extracted from the Address.
+ */
+export declare function extractCountryFromFormatted(formatted?: string): Countries;
+/**
+ * @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.
+ */
+export declare function isOverseasAddress({ country, formatted, state }?: Address): boolean;
+export {};

package/lib/utils/address-tools.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * A set of tools for manipulating addresses in LIXI applications.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOverseasAddress = exports.extractCountryFromFormatted = exports.setCountry = exports.isMissingCountry = exports.rebuildPreviousAddress = exports.rebuildAddress = exports.mapTransform = exports.lixiAddressMapping = exports.australianStates = exports.lixiContactAddressMapping = void 0;
+const lixi_internal_request_1 = require("@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const country_code_1 = require("../types/enum-mappings/country-code");
+const housing_status_1 = require("../types/enum-mappings/housing-status");
+const public_applicant_1 = require("../types/events/public-applicant");
+const generate_address_1 = require("./generate-address");
+exports.lixiContactAddressMapping = {
+    externalId: {
+        path: '@x_ResidentialAddress',
+    },
+    housingStatus: {
+        path: '@HousingStatus',
+        transform: (value) => housing_status_1.housingStatusMapping[value],
+    },
+    startDate: {
+        path: '@StartDate',
+    },
+    endDate: {
+        path: '@EndDate',
+    },
+};
+exports.australianStates = Object.values(lixi_internal_request_1.AuStateList);
+/**
+ * The transform map used for the LIXI address
+ */
+exports.lixiAddressMapping = {
+    externalId: {
+        path: '@UniqueID',
+    },
+    'residentialAddress.city': {
+        path: '@Suburb',
+    },
+    'residentialAddress.country': {
+        path: '@Country',
+        transform: (value) => 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: (value) => 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) {
+    const finalTransform = {};
+    Object.entries(pathMappedTransform).forEach(([key, { transform, path }]) => {
+        const 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;
+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) {
+    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' };
+    }
+    const lixiAddress = mapTransform(eventAddress, exports.lixiAddressMapping);
+    const lixiContactAddress = mapTransform(eventAddress, exports.lixiContactAddressMapping);
+    lixiAddress['@UniqueID'] = addressId;
+    lixiContactAddress['@x_ResidentialAddress'] = addressId;
+    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.
+ *
+ * @param eventPreviousAddresses
+ * @param addressId
+ */
+function rebuildPreviousAddress(eventPreviousAddresses = [], addressId) {
+    if (eventPreviousAddresses.length === 0)
+        return null;
+    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) {
+    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) {
+    const formatted = (0, lodash_1.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 = '') {
+    var _a;
+    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({ country, formatted, state } = {}) {
+    if (country) {
+        return country !== public_applicant_1.Countries.Australia;
+    }
+    if (formatted) {
+        const lastPast = extractCountryFromFormatted(formatted);
+        return lastPast !== public_applicant_1.Countries.Australia;
+    }
+    if (state) {
+        return !exports.australianStates.includes(state);
+    }
+    return false;
+}
+exports.isOverseasAddress = isOverseasAddress;

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

@@ -0,0 +1,7 @@
+/**
+ * Recursively removes nulls from nested objects and arrays
+ *
+ * @param payload any
+ * @returns 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";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanUp = void 0;
+/* istanbul ignore file  */
+const clean_deep_1 = require("clean-deep");
+/**
+ * Recursively removes nulls from nested objects and arrays
+ *
+ * @param payload any
+ * @returns result of sanitised object.
+ */
+function cleanUp(payload) {
+    // cleanDeep configurations.
+    const 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/errors.d.ts

@@ -0,0 +1,28 @@
+export declare enum ErrorType {
+    ApplicationNotFound = "ApplicationNotFound",
+    BaseError = "BaseError",
+    DatabaseConditionalWriteError = "DatabaseConditionalWriteError",
+    DatabaseError = "DatabaseError",
+    Errors = "Errors",
+    InternalError = "InternalError",
+    InvalidApplication = "InvalidApplication",
+    InvalidEvent = "InvalidEvent",
+    InvalidEventNoApplicationId = "InvalidEventNoApplicationId",
+    InvalidEventNotCritical = "InvalidEventNotCritical",
+    OwnershipOutOfBounds = "OwnershipOutOfBounds",
+    ResourceNotFound = "ResourceNotFound"
+}
+export declare class BaseError extends Error {
+    origin: string;
+    path: string[];
+    type: ErrorType;
+    context: object;
+    constructor(message: string, path: string[], origin: string, context?: object);
+}
+/**
+ * InvalidEvent occurs when an incorrect/damaged event has been consumed and
+ * found to be invalid against its related schema.
+ */
+export declare class InvalidEvent extends BaseError {
+    constructor(message: string, path?: string[], origin?: string, context?: object);
+}

package/lib/utils/errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidEvent = exports.BaseError = exports.ErrorType = void 0;
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["ApplicationNotFound"] = "ApplicationNotFound";
+    ErrorType["BaseError"] = "BaseError";
+    ErrorType["DatabaseConditionalWriteError"] = "DatabaseConditionalWriteError";
+    ErrorType["DatabaseError"] = "DatabaseError";
+    ErrorType["Errors"] = "Errors";
+    ErrorType["InternalError"] = "InternalError";
+    ErrorType["InvalidApplication"] = "InvalidApplication";
+    ErrorType["InvalidEvent"] = "InvalidEvent";
+    ErrorType["InvalidEventNoApplicationId"] = "InvalidEventNoApplicationId";
+    ErrorType["InvalidEventNotCritical"] = "InvalidEventNotCritical";
+    ErrorType["OwnershipOutOfBounds"] = "OwnershipOutOfBounds";
+    ErrorType["ResourceNotFound"] = "ResourceNotFound";
+})(ErrorType = exports.ErrorType || (exports.ErrorType = {}));
+class BaseError extends Error {
+    /* istanbul ignore next */
+    constructor(message, path = [], origin, context = {}) {
+        super(message);
+        Object.setPrototypeOf(this, BaseError.prototype);
+        this.type = ErrorType.BaseError;
+        this.path = path;
+        this.origin = origin;
+        this.context = context;
+    }
+}
+exports.BaseError = BaseError;
+/**
+ * InvalidEvent occurs when an incorrect/damaged event has been consumed and
+ * found to be invalid against its related schema.
+ */
+class InvalidEvent extends BaseError {
+    /* istanbul ignore next */
+    constructor(message, path, origin, context) {
+        super(message, path, origin, context);
+        Object.setPrototypeOf(this, InvalidEvent.prototype);
+        this.type = ErrorType.InvalidEvent;
+    }
+}
+exports.InvalidEvent = InvalidEvent;

package/lib/utils/formatYesNo.d.ts

@@ -0,0 +1,8 @@
+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
+ */
+export declare const formatYesNo: (isTruthy: any) => YesNoList;

package/lib/utils/formatYesNo.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatYesNo = void 0;
+const lixi_internal_request_1 = require("@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
+ */
+const formatYesNo = (isTruthy) => (isTruthy ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No);
+exports.formatYesNo = formatYesNo;

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

@@ -0,0 +1,19 @@
+import { AddressType, Standard, StreetTypeList } from '@lendi/act-eac-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} address - An address object.
+ * @param {string} id - Id of asset 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.
+ * @returns A transformed standard object.
+ */
+export declare function generateStandard(addressStandard: AddressStandard): Standard;

package/lib/utils/generate-address.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStandard = exports.generateAddress = exports.StreetTypeArray = exports.StreetNumberMaxLength = void 0;
+const lixi_internal_request_1 = require("@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const country_code_1 = require("..//types/enum-mappings/country-code");
+const postcode_1 = require("../types/enum-mappings/postcode");
+const public_asset_1 = require("../types/events/public-asset");
+const address_tools_1 = require("./address-tools");
+exports.StreetNumberMaxLength = 16;
+exports.StreetTypeArray = Object.values(lixi_internal_request_1.StreetTypeList);
+const addressMapping = {
+    country: '@Country',
+    city: '@Suburb',
+    postcode: '@AustralianPostCode',
+    state: '@AustralianState',
+    standard: 'Standard',
+};
+const standardMapping = {
+    streetName: '@StreetName',
+    streetType: '@StreetType',
+    streetNumber: '@StreetNumber',
+    level: '@Level',
+    unit: '@Unit',
+};
+/**
+ * Generates an address for an asset.
+ *
+ * @param {Address} address - An address object.
+ * @param {string} id - Id of asset object.
+ * @returns {Partial<AddressType>} A transformed address object.
+ */
+function generateAddress(address, id) {
+    const transformedAddress = {
+        '@Country': lixi_internal_request_1.CountryCodeList.Au,
+        '@UniqueID': id,
+    };
+    const country = (0, address_tools_1.extractCountryFromFormatted)(address.formatted);
+    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 (const [key, value] of Object.entries(address)) {
+        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.
+ * @returns A transformed standard object.
+ */
+function generateStandard(addressStandard) {
+    const transformedStandard = {};
+    for (const [key, value] of Object.entries(addressStandard)) {
+        if (standardMapping[key]) {
+            switch (key) {
+                case 'streetNumber':
+                    (0, lodash_1.set)(transformedStandard, standardMapping[key], value.substring(0, exports.StreetNumberMaxLength));
+                    break;
+                case 'streetType':
+                    const streetType = exports.StreetTypeArray.find((type) => 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;
+            }
+        }
+    }
+    return transformedStandard;
+}
+exports.generateStandard = generateStandard;

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

@@ -0,0 +1,8 @@
+import { FinancialInstitutionList } from '@lendi/act-eac-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.
+ * @param institution
+ */
+export declare function getFinancialInstitution(institution: string): FinancialInstitutionList;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFinancialInstitution = void 0;
+const lixi_internal_request_1 = require("@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request");
+const 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.
+ * @param institution
+ */
+function getFinancialInstitution(institution) {
+    const institutionUpperCased = institution.toUpperCase();
+    const financialInstitution = financialInstitutions.find((item) => item.toUpperCase() === institutionUpperCased);
+    return financialInstitution || lixi_internal_request_1.FinancialInstitutionList.Other;
+}
+exports.getFinancialInstitution = getFinancialInstitution;

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

@@ -0,0 +1,25 @@
+import { Asset } from '../types/events/public-asset';
+/**
+ * @description Checks if the asset is of financial type.
+ * @param {Asset} asset asset payload.
+ * @returns {boolean} returns true if asset is a financial asset.
+ */
+export declare function isFinancialAsset(asset: Asset): boolean;
+/**
+ * @description Is Asset a Real Estate Asset.
+ * @param {Asset} asset An Asset.
+ * @returns {boolean} returns true if Asset is a Real Estate Asset.
+ */
+export declare function isRealEstateAsset(asset: Asset): boolean;
+/**
+ * @description Is Asset a Motor Vehicle.
+ * @param {Asset} asset An Asset.
+ * @returns {boolean} returns true if an Asset is a vehicle.
+ */
+export declare function isMotorVehicle(asset: Asset): boolean;
+/**
+ * @description Is Asset of LIXI type `OtherAsset`.
+ * @param {Asset} asset An Asset.
+ * @returns {boolean} returns true if asset is `OtherAsset`.
+ */
+export declare function isOtherAsset(asset: Asset): boolean;

package/lib/utils/is-asset-type.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOtherAsset = exports.isMotorVehicle = exports.isRealEstateAsset = exports.isFinancialAsset = void 0;
+const public_asset_1 = require("../types/events/public-asset");
+/**
+ * @description Checks if the asset is of financial type.
+ * @param {Asset} asset asset payload.
+ * @returns {boolean} returns true if asset is a financial asset.
+ */
+function isFinancialAsset(asset) {
+    return [
+        public_asset_1.AssetType.Shares,
+        public_asset_1.AssetType.Superannuation,
+        public_asset_1.AssetType.TermDeposit,
+        public_asset_1.AssetType.SavingCheckAccount,
+        public_asset_1.AssetType.ManagedFunds,
+    ].includes(asset.type);
+}
+exports.isFinancialAsset = isFinancialAsset;
+/**
+ * @description Is Asset a Real Estate Asset.
+ * @param {Asset} asset An Asset.
+ * @returns {boolean} returns true if Asset is a Real Estate Asset.
+ */
+function isRealEstateAsset(asset) {
+    return asset.type === public_asset_1.AssetType.Property;
+}
+exports.isRealEstateAsset = isRealEstateAsset;
+/**
+ * @description Is Asset a Motor Vehicle.
+ * @param {Asset} asset An Asset.
+ * @returns {boolean} returns true if an Asset is a vehicle.
+ */
+function isMotorVehicle(asset) {
+    return asset.type === public_asset_1.AssetType.Vehicle;
+}
+exports.isMotorVehicle = isMotorVehicle;
+/**
+ * @description Is Asset of LIXI type `OtherAsset`.
+ * @param {Asset} asset An Asset.
+ * @returns {boolean} returns true if asset is `OtherAsset`.
+ */
+function isOtherAsset(asset) {
+    return [public_asset_1.AssetType.HomeContents, public_asset_1.AssetType.Gifts, public_asset_1.AssetType.OtherAsset].includes(asset.type);
+}
+exports.isOtherAsset = isOtherAsset;