taxtank-core 0.29.19 → 0.29.21

package/fesm2015/taxtank-core.js

@@ -1368,6 +1368,7 @@ class ServiceProduct extends ServiceProduct$1 {
         return this.status === ServiceProductStatusEnum.ARCHIVED;
     }
 }
+ServiceProduct.quantity = 3;
 // const TestEnum = {
 //   4: 4,
 //   5: 7,
@@ -1402,204 +1403,325 @@ var ServiceSubscriptionStatusEnum;
     ServiceSubscriptionStatusEnum[ServiceSubscriptionStatusEnum["UNPAID"] = 6] = "UNPAID";
 })(ServiceSubscriptionStatusEnum || (ServiceSubscriptionStatusEnum = {}));
 
-class ServiceSubscription extends ServiceSubscription$1 {
-    constructor() {
-        super(...arguments);
-        // Number of days after which the trial time will be expired
-        this.lastTrialDays = 4;
+class MessageCollection extends Collection {
+    getFirstUnreadMessage(user) {
+        return this.items.find((message) => {
+            return !message.isRead() && message.isFromEmployee() !== user.isEmployee();
+        });
     }
-    get isTrial() {
-        return !this.stripeId;
+    /**
+     * Get List of unread chats
+     */
+    getUnread() {
+        return this.items.filter((message) => !message.readAt);
     }
-    get isPaid() {
-        return !!this.stripeId;
+    getFromActiveChats() {
+        return this.filter((message) => message.chat.isActive());
     }
-    get price() {
-        return this.items.reduce((sum, item) => sum + item.total, 0);
+    /**
+     * Get amount of chats that contains unread messages
+     */
+    getUnreadChatsAmount(isFromEmployee = false) {
+        // filtered messages for client/employee
+        const filteredMessages = this.filter((message) => isFromEmployee ? message.isFromEmployee() : !message.isFromEmployee());
+        return uniqBy(filteredMessages.getFromActiveChats().getUnread(), 'chat.id').length;
     }
     /**
-     * get title of subscription
+     * Check if chat has unread chats
      */
-    get title() {
-        return this.items.map((item) => item.price.product.title).join(' + ');
-        // return this.isTrial ? 'Trial period' : this.items.map((item) => item.price.product.title).join(' + ');
+    hasUnread() {
+        return !!this.getUnread().length;
     }
+}
+
+var ChatStatusEnum;
+(function (ChatStatusEnum) {
+    ChatStatusEnum[ChatStatusEnum["ACTIVE"] = 1] = "ACTIVE";
+    ChatStatusEnum[ChatStatusEnum["INACTIVE"] = 2] = "INACTIVE";
+})(ChatStatusEnum || (ChatStatusEnum = {}));
+
+class ChatCollection extends Collection {
     /**
-     * A subscription is considered active if the end date has not yet arrived and its status is "Active" or "Past due"
+     * Sort chats by last messages (newest first) + empty chats in the end
      */
-    get isActive() {
-        const isExpired = new Date(this.endDate).getTime() < new Date().getTime();
-        return !isExpired && ([ServiceSubscriptionStatusEnum.ACTIVE, ServiceSubscriptionStatusEnum.PAST_DUE].includes(this.status));
+    getSortedByNewest(messages) {
+        const chatsById = new Dictionary(this.toArray());
+        // get chats array sorted from newest to oldest
+        const chats = uniqBy(new MessageCollection(messages)
+            .filterBy('chat.id', this.getIds())
+            .sortBy('createdAt', true)
+            .toArray()
+            .map((message) => chatsById.get(message.chat.id)), 'id');
+        const emptyChats = differenceBy(this.toArray(), chats, 'id');
+        return this.create([...chats, ...emptyChats]);
     }
-    get daysRemain() {
-        const daysRemains = Math.round((new Date(this.endDate).getTime() - new Date().getTime()) / (1000 * 3600 * 24));
-        return daysRemains > 0 ? daysRemains : 0;
+    getActive() {
+        return this.filterBy('status', ChatStatusEnum.ACTIVE);
     }
+}
+
+/**
+ * Collection of MessageDocument instances
+ */
+class MessageDocumentCollection extends Collection {
     /**
-     * Check if trial expired
+     * get list of documents which are not attached to any message
      */
-    isTrialExpired() {
-        return this.daysRemain && this.daysRemain <= 0;
+    getUnattached() {
+        return new MessageDocumentCollection(this.items.filter((doc) => !doc.message));
     }
-    isTrialExpiring() {
-        return this.daysRemain > 0 && this.daysRemain <= this.lastTrialDays;
+}
+
+class LoanCollection extends Collection {
+    /**
+     * Get new collection of loans filtered by bank accounts ids
+     * @param ids list of bank accounts ids for filter
+     */
+    getByBankAccountsIds(ids) {
+        return new LoanCollection(this.items.filter((loan) => { var _a; return ids.includes((_a = loan.bankAccount) === null || _a === void 0 ? void 0 : _a.id); }));
     }
-    isRenewable() {
-        return !this.isTrial && this.isActive;
+    /**
+     * Get single loan by bank account id
+     * @param id id of bank account
+     */
+    getByBankAccountId(id) {
+        return this.items.find((loan) => { var _a; return ((_a = loan.bankAccount) === null || _a === void 0 ? void 0 : _a.id) === id; });
     }
     /**
-     * @TODO move to collection
+     * Get list of current fin year payments grouped by loan id
      */
-    get workTankItem() {
-        return this.items.find((item) => item.price.product.isWorkTank());
+    groupCurrentYearPaymentsByLoans() {
+        const dictionary = new CollectionDictionary(new LoanPaymentCollection([]));
+        this.items.forEach((loan) => dictionary.add(loan.id, new LoanPaymentCollection(loan.payments).getForCurrentYear()));
+        return dictionary;
     }
-    get soleTankItem() {
-        return this.items.find((item) => item.price.product.isSoleTank());
+    /**
+     * Get list of vehicle loans
+     */
+    getVehicleLoans() {
+        return this.filter((loan) => loan.isVehicle());
     }
-    get propertyTankItem() {
-        return this.items.find((item) => item.price.product.isProperties());
+}
+
+class PropertySaleCollection extends Collection {
+    get grossCGTAfterLoss() {
+        return this.create(this.items.filter((propertySale) => propertySale.grossCGTAfterLoss > 0)).sumBy('grossCGTAfterLoss');
     }
-    hasPropertyTank() {
-        return !!this.items.find((subscriptionItem) => {
-            return subscriptionItem.price.product.role.includes(UserRolesEnum.PROPERTY_TANK);
-        });
+    /**
+     * Property sales are CGT applicable unless it has "Principle place of residence" exemption type
+     */
+    getCGTApplicable() {
+        return this.create(this.items.filter((propertySale) => propertySale.isCGTApplicable()));
     }
-    hasWorkTank() {
-        return !!this.items.find((subscriptionItem) => {
-            return subscriptionItem.price.product.role.includes(UserRolesEnum.WORK_TANK);
-        });
+    getByPropertyShareIds(ids) {
+        return this.filterBy('share.id', ids);
     }
+}
+
+var TaxExemptionMetadataEnum;
+(function (TaxExemptionMetadataEnum) {
+    // principle place of residence
+    TaxExemptionMetadataEnum[TaxExemptionMetadataEnum["PPR_DAYS"] = 1] = "PPR_DAYS";
+    // market value once it was moved, decimal
+    TaxExemptionMetadataEnum[TaxExemptionMetadataEnum["MARKET_VALUE"] = 2] = "MARKET_VALUE";
+    TaxExemptionMetadataEnum[TaxExemptionMetadataEnum["CLAIM_PERCENT"] = 3] = "CLAIM_PERCENT";
+})(TaxExemptionMetadataEnum || (TaxExemptionMetadataEnum = {}));
+
+class PropertySaleTaxExemptionMetadataCollection extends Collection {
+    getPPRDays() {
+        var _a, _b;
+        return (_b = (_a = this.getByMetadataId(TaxExemptionMetadataEnum.PPR_DAYS)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0;
+    }
+    getMarketValue() {
+        var _a, _b;
+        return (_b = (_a = this.getByMetadataId(TaxExemptionMetadataEnum.MARKET_VALUE)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0;
+    }
+    getClaimPercent() {
+        var _a, _b;
+        return (_b = (_a = this.getByMetadataId(TaxExemptionMetadataEnum.CLAIM_PERCENT)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 100;
+    }
+    getByMetadataId(id) {
+        return this.items.find((metadata) => metadata.metadata.id === id);
+    }
+}
+
+class PropertyCollection extends Collection {
     /**
-     * bought before price updates, active for some time to let customer select a new plan
-     * impossible to update, only prolong or buy new
+     * Get new property collection filtered by category id
+     * @param id id of category for filter
      */
-    isArchived() {
-        // subscription with at least one archived product considered as archived
-        return !!this.items.filter((item) => item.price.product.isArchived()).length;
+    getByCategoryId(id) {
+        return new PropertyCollection(this.items.filter((property) => property.category.id === id));
     }
     /**
-     * Case when payment was failed, but user has a time to update payment method
+     * Get new property collection filtered by active status
      */
-    isPastDue() {
-        return this.status === ServiceSubscriptionStatusEnum.PAST_DUE;
+    getActiveProperties() {
+        return new PropertyCollection(this.items.filter((property) => property.isActive));
+    }
+    getCreatedProperties() {
+        return new PropertyCollection(this.items.filter((property) => property.isOwn()));
     }
     /**
-     * Check if current subscription has provided subscription item
+     * Get new property collection filtered by shared
      */
-    hasItem(itemToCheck) {
-        return !!this.items.find((item) => item.price.id === itemToCheck.price.id);
+    getSharedProperties() {
+        return new PropertyCollection(this.items.filter((property) => !property.isOwn()));
     }
-    hasProduct(product) {
-        return !!this.items.find((item) => item.price.product.id === product.id);
+    /**
+     * Properties that are taxed and will be included in reports (Tax summary, My tax report, e.t.c.)
+     */
+    getTaxInclusive() {
+        return this.create(this.items.filter((property) => property.category.isTaxInclusive));
+    }
+    getUnsold() {
+        return this.create(this.items.filter((property) => !property.isSold()));
     }
     /**
-     * Recommended number of properties to buy,
-     * based on the property service product and the number of properties the user has
+     * Get total purchase price for all properties in the collection
      */
-    getRecommendedPropertiesQty(propertyItem, propertiesQty) {
-        const min = propertyItem.price.product.minQty;
-        return Math.max(min, propertiesQty);
+    get purchasePrice() {
+        return this.sumBy('purchasePrice');
     }
-}
-__decorate([
-    Type(() => Date)
-], ServiceSubscription.prototype, "startDate", void 0);
-__decorate([
-    Type(() => Date)
-], ServiceSubscription.prototype, "endDate", void 0);
-__decorate([
-    Type(() => ServiceSubscriptionItem)
-], ServiceSubscription.prototype, "items", void 0);
-
-class SoleBusinessAllocation extends SoleBusinessAllocation$1 {
-}
-__decorate([
-    Type(() => BankAccount)
-], SoleBusinessAllocation.prototype, "bankAccount", void 0);
-__decorate([
-    Type(() => SoleBusiness)
-], SoleBusinessAllocation.prototype, "business", void 0);
-__decorate([
-    Transform(({ value }) => value || 100),
-    Expose()
-], SoleBusinessAllocation.prototype, "percent", void 0);
-
-class SoleBusinessLossOffsetRule extends SoleBusinessLossOffsetRule$1 {
-}
-__decorate([
-    Type(() => SoleBusinessLossOffsetRule)
-], SoleBusinessLossOffsetRule.prototype, "parent", void 0);
-
-/**
- * If a sole trader business makes a tax loss in a current year, you can generally carry forward that loss and offset profit in future years.
- * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4641357930/Rules+when+a+business+makes+a+loss+Tax+Summary#Offsetting-current-year-business-losses
- */
-class SoleBusinessLoss extends SoleBusinessLoss$1 {
-    constructor() {
-        super(...arguments);
-        this.openBalance = 0;
-        this.financialYear = new FinancialYear().year;
+    get growthPercent() {
+        return this.sumBy('growthPercent');
     }
-    get hasOffset() {
-        return !!this.offsetRule;
+    get marketValue() {
+        return this.sumBy('marketValue');
+    }
+    get firstForecastYear() {
+        return this.items.reduce((min, property) => {
+            const current = property.firstForecastYear;
+            return min > current ? current : min;
+        }, new FinancialYear().year);
+    }
+    get marketValueGrowth() {
+        return (this.marketValue - this.purchasePrice) / this.purchasePrice;
+    }
+    /**
+     * list of properties
+     */
+    getCGTApplicable() {
+        return this.create(this.items.filter((property) => property.isCGTApplicable()));
+    }
+    getOwnerOccupiedProperties() {
+        return new PropertyCollection(this.items.filter((property) => property.category.isOwnerOccupied()));
+    }
+    get earliestContractDate() {
+        return this.items.reduce((min, property) => {
+            return min < property.contractDate ? min : property.contractDate;
+        }, new FinancialYear(new Date()).startDate);
+    }
+    /**
+     * Get list of unique property categories from collection
+     */
+    getCategories() {
+        return uniqBy(this.items.map((property) => property.category), 'id');
+    }
+    /**
+     * Get property with the highest growth percent
+     */
+    getBestPerformanceGrowthProperty() {
+        return this.items.reduce((max, current) => {
+            return max.growthPercent < current.growthPercent ? current : max;
+        }, this.first);
+    }
+    /**
+     * Get property with the lowest tax position
+     */
+    getBestPerformanceTaxProperty(transactions, depreciations) {
+        const transactionsByProperty = transactions.groupBy('property.id');
+        const depreciationsByProperty = depreciations.groupBy('property.id');
+        return this.items.reduce((min, current) => {
+            const minTaxPosition = min.getTaxPosition(transactionsByProperty.get(min.id), depreciationsByProperty.get(min.id));
+            const currentTaxPosition = current.getTaxPosition(transactionsByProperty.get(current.id), depreciationsByProperty.get(current.id));
+            return minTaxPosition > currentTaxPosition ? current : min;
+        }, this.first);
+    }
+    /**
+     * Show best performance properties first
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677997/Property+Tank+Dashboard
+     */
+    sortByBestPerformance(transactions, depreciations) {
+        const activeProperties = this.getActiveProperties();
+        // nothing to sort when no active properties
+        if (!activeProperties.length) {
+            return this;
+        }
+        const bestProperties = uniqBy(this.create([
+            activeProperties.getBestPerformanceGrowthProperty(),
+            activeProperties.getBestPerformanceTaxProperty(transactions, depreciations)
+        ]).toArray(), 'id');
+        const newItems = this.remove(bestProperties).toArray();
+        newItems.unshift(...bestProperties);
+        return this.create(newItems);
     }
 }
-__decorate([
-    Type(() => SoleBusiness)
-], SoleBusinessLoss.prototype, "business", void 0);
-__decorate([
-    Type(() => SoleBusinessLossOffsetRule)
-], SoleBusinessLoss.prototype, "offsetRule", void 0);
 
-var MyAccountHistoryInitiatedByEnum;
-(function (MyAccountHistoryInitiatedByEnum) {
-    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["OWNER"] = 0] = "OWNER";
-    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["ACCOUNTANT"] = 1] = "ACCOUNTANT";
-})(MyAccountHistoryInitiatedByEnum || (MyAccountHistoryInitiatedByEnum = {}));
-
-var MyAccountHistoryStatusEnum;
-(function (MyAccountHistoryStatusEnum) {
-    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["SUCCESS"] = 0] = "SUCCESS";
-    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["ERROR"] = 1] = "ERROR";
-})(MyAccountHistoryStatusEnum || (MyAccountHistoryStatusEnum = {}));
-
-var MyAccountHistoryTypeEnum;
-(function (MyAccountHistoryTypeEnum) {
-    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["REVIEW"] = 0] = "REVIEW";
-    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPGRADE_PLAN"] = 1] = "UPGRADE_PLAN";
-    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPLOAD_DOCUMENT"] = 2] = "UPLOAD_DOCUMENT";
-})(MyAccountHistoryTypeEnum || (MyAccountHistoryTypeEnum = {}));
-
-class MyAccountHistory {
+class PropertyCategoryMovementCollection extends Collection {
+    /**
+     * @TODO TT-2355 Alex refactor propertyForecast, use separated api (then I can remove property from param)
+     */
+    getByForecast(property, forecast) {
+        const financialYear = new FinancialYear(forecast.financialYear);
+        return this.filterBy('property.id', property.id).filter((movement) => {
+            return movement.fromDate <= financialYear.endDate && !movement.toDate || movement.toDate >= financialYear.startDate;
+        });
+    }
+    hasCategory(categoryId) {
+        return !!this.findBy('propertyCategory.id', categoryId);
+    }
 }
 
-class Occupation extends Occupation$1 {
+class PropertyShareCollection extends Collection {
+    /**
+     * Get list of incoming property shares
+     * (initiated not by current user)
+     * @TODO Alex: rename
+     */
+    getIncoming() {
+        return this.filter((propertyShare) => {
+            var _a;
+            return ((_a = propertyShare.user) === null || _a === void 0 ? void 0 : _a.isLoggedIn()) && propertyShare.isPending() && propertyShare.property.user.id !== +localStorage.getItem('userId');
+        });
+    }
+    /**
+     * Get list of outcoming property shares
+     * (initiated by current user)
+     * @TODO Alex: rename
+     */
+    getOutcoming() {
+        return this.filter((propertyShare) => { var _a; return !((_a = propertyShare.user) === null || _a === void 0 ? void 0 : _a.isLoggedIn()); });
+    }
 }
 
 /**
- * role hierarchy
+ * Enum with symbols based on depreciation LVP asset type
  */
-const USER_ROLES = {
-    ROLE_FIRM_OWNER: [UserRolesEnum.FIRM_OWNER, UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
-    ROLE_FIRM_MANAGER: [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
-    ROLE_EMPLOYEE: [UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
-    ROLE_ACCOUNTANT: [UserRolesEnum.ACCOUNTANT],
-    ROLE_ADVISOR: [UserRolesEnum.ADVISOR],
-    ROLE_CLIENT: [UserRolesEnum.CLIENT],
-    ROLE_USER_SUBSCRIPTION: [UserRolesEnum.SUBSCRIPTION],
-    ROLE_USER_WORK: [UserRolesEnum.WORK_TANK],
-    ROLE_USER_PROPERTY: [UserRolesEnum.PROPERTY_TANK],
-    ROLE_USER_SOLE: [UserRolesEnum.SOLE_TANK],
-};
+var DepreciationLvpAssetTypeEnum;
+(function (DepreciationLvpAssetTypeEnum) {
+    DepreciationLvpAssetTypeEnum["PRIOR_YEARS"] = "A";
+    DepreciationLvpAssetTypeEnum["FIRST_YEAR"] = "L";
+    DepreciationLvpAssetTypeEnum["WRITTEN_OFF"] = "W";
+})(DepreciationLvpAssetTypeEnum || (DepreciationLvpAssetTypeEnum = {}));
 
-/**
- * Class with basic information about registering user
- */
-class UserToRegister {
-}
+var DepreciationTypeEnum;
+(function (DepreciationTypeEnum) {
+    DepreciationTypeEnum[DepreciationTypeEnum["PLANT_EQUIPMENT"] = 1] = "PLANT_EQUIPMENT";
+    DepreciationTypeEnum[DepreciationTypeEnum["CAPITAL_WORKS"] = 2] = "CAPITAL_WORKS";
+    DepreciationTypeEnum[DepreciationTypeEnum["BULK_DEPRECIATION"] = 3] = "BULK_DEPRECIATION";
+    DepreciationTypeEnum[DepreciationTypeEnum["BORROWING_EXPENSES"] = 4] = "BORROWING_EXPENSES";
+})(DepreciationTypeEnum || (DepreciationTypeEnum = {}));
 
-class ChartAccountsHeading extends ChartAccountsHeading$1 {
-}
+var DepreciationCalculationEnum;
+(function (DepreciationCalculationEnum) {
+    DepreciationCalculationEnum[DepreciationCalculationEnum["PRIME_COST"] = 1] = "PRIME_COST";
+    DepreciationCalculationEnum[DepreciationCalculationEnum["DIMINISHING"] = 2] = "DIMINISHING";
+    DepreciationCalculationEnum[DepreciationCalculationEnum["CAPITAL"] = 3] = "CAPITAL";
+    DepreciationCalculationEnum[DepreciationCalculationEnum["LVP"] = 4] = "LVP";
+    DepreciationCalculationEnum[DepreciationCalculationEnum["AMORTISATION"] = 5] = "AMORTISATION";
+    DepreciationCalculationEnum[DepreciationCalculationEnum["SBP"] = 6] = "SBP";
+})(DepreciationCalculationEnum || (DepreciationCalculationEnum = {}));
 
 var DocumentTypeEnum;
 (function (DocumentTypeEnum) {
@@ -1883,15 +2005,40 @@ var ChartAccountsKeepSign;
 
 // @TODO Artem TT-2308 move everything
 
-class ChartAccountsMetadata extends ChartAccountsMetadata$1 {
-    /**
-     * Check if metadata id is related to SHARE_PERCENTAGE value
-     */
-    isSharePercentage() {
-        return this.id === ChartAccountsMetadataListEnum.SHARE_PERCENTAGE;
+class DepreciationCapitalProject extends DepreciationCapitalProject$1 {
+}
+__decorate([
+    Type(() => Date)
+], DepreciationCapitalProject.prototype, "effectiveDate", void 0);
+
+class DepreciationForecast extends DepreciationForecast$1 {
+    get dailyClaimAmount() {
+        return this.claimAmount / this.daysApplied;
     }
-    isHours() {
-        return this.id === ChartAccountsMetadataListEnum.HOURS;
+    get daysApplied() {
+        return moment$1(this.toDate).diff(moment$1(this.fromDate), 'days');
+    }
+    getDaysByMonth(month) {
+        // @TODO find a better place
+        const year = this.financialYear - (month > 5 ? 1 : 0);
+        // forecast date intersect by month
+        const range = new DateRange(this.fromDate, this.toDate).intersect(new DateRange(new Date(year, month, 1), new Date(year, month + 1, 0)));
+        return range ? range.duration('days') + 1 : 0;
+    }
+    get claimOpenBalance() {
+        return this.openBalance * this.claimRate;
+    }
+    get claimCloseBalance() {
+        return this.closeBalance * this.claimRate;
+    }
+    get claimAmount() {
+        return this.amount * this.claimRate;
+    }
+    get claimRate() {
+        return this.claimPercent / 100;
+    }
+    getClaimAmountByMonth(month) {
+        return this.getDaysByMonth(month) * this.dailyClaimAmount;
     }
 }
 
@@ -1996,6 +2143,68 @@ const CHART_ACCOUNTS_CATEGORIES = {
     ]
 };
 
+/**
+ * @TODO Alex/Vik: think and create some new collection type
+ * @TODO Alex: research all constants and make the same structure
+ */
+class ChartAccountsCategoryECollection {
+    constructor(items) {
+        this.items = items || [
+            ChartAccountsCategoryEnum.PROPERTY_INCOME,
+            ChartAccountsCategoryEnum.PROPERTY_EXPENSE,
+            ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION,
+            ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS,
+            ChartAccountsCategoryEnum.WORK_DEPRECIATION,
+            ChartAccountsCategoryEnum.WORK_INCOME,
+            ChartAccountsCategoryEnum.WORK_EXPENSE,
+            ChartAccountsCategoryEnum.OTHER_INCOME,
+            ChartAccountsCategoryEnum.OTHER_EXPENSE,
+            ChartAccountsCategoryEnum.PERSONAL_INCOME,
+            ChartAccountsCategoryEnum.PERSONAL_EXPENSE,
+            ChartAccountsCategoryEnum.SOLE_INCOME,
+            ChartAccountsCategoryEnum.SOLE_EXPENSE,
+            ChartAccountsCategoryEnum.SOLE_DEPRECIATION
+        ];
+    }
+    getByType(types) {
+        if (!Array.isArray(types)) {
+            types = [types];
+        }
+        const items = [];
+        types.forEach((type) => {
+            const filtered = this.items.filter((item) => ChartAccountsCategoryEnum[item].includes(type.toUpperCase()));
+            items.push(...filtered);
+        });
+        return new ChartAccountsCategoryECollection(items);
+    }
+    getByTankType(tankTypes) {
+        if (!Array.isArray(tankTypes)) {
+            tankTypes = [tankTypes];
+        }
+        const items = [];
+        tankTypes.forEach((tankType) => {
+            const filtered = this.items.filter((item) => ChartAccountsCategoryEnum[item].includes(tankType.toUpperCase()));
+            items.push(...filtered);
+        });
+        return new ChartAccountsCategoryECollection(items);
+    }
+}
+
+class ChartAccountsHeading extends ChartAccountsHeading$1 {
+}
+
+class ChartAccountsMetadata extends ChartAccountsMetadata$1 {
+    /**
+     * Check if metadata id is related to SHARE_PERCENTAGE value
+     */
+    isSharePercentage() {
+        return this.id === ChartAccountsMetadataListEnum.SHARE_PERCENTAGE;
+    }
+    isHours() {
+        return this.id === ChartAccountsMetadataListEnum.HOURS;
+    }
+}
+
 var ChartAccountsTaxLabelsEnum;
 (function (ChartAccountsTaxLabelsEnum) {
     ChartAccountsTaxLabelsEnum["TAX_WITHHELD"] = "Tax withheld";
@@ -2217,6 +2426,30 @@ __decorate([
     Type(() => ChartAccountsMetadata)
 ], ChartAccounts.prototype, "metadata", void 0);
 
+class ChartAccountsDepreciation extends ChartAccountsDepreciation$1 {
+}
+__decorate([
+    Type(() => ChartAccounts)
+], ChartAccountsDepreciation.prototype, "chartAccounts", void 0);
+__decorate([
+    Transform(({ value }) => +value)
+], ChartAccountsDepreciation.prototype, "limit", void 0);
+__decorate([
+    Transform(({ value }) => +value)
+], ChartAccountsDepreciation.prototype, "effectiveLife", void 0);
+
+class ChartAccountsValue extends ChartAccountsValue$1 {
+}
+
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+var IncomeAmountTypeEnum;
+(function (IncomeAmountTypeEnum) {
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["NET"] = 0] = "NET";
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["GROSS"] = 1] = "GROSS";
+})(IncomeAmountTypeEnum || (IncomeAmountTypeEnum = {}));
+
 var TransactionTypeEnum;
 (function (TransactionTypeEnum) {
     TransactionTypeEnum[TransactionTypeEnum["DEBIT"] = 1] = "DEBIT";
@@ -2237,24 +2470,6 @@ var TransactionSourceEnum;
     TransactionSourceEnum[TransactionSourceEnum["BANK_TRANSACTION"] = 2] = "BANK_TRANSACTION";
 })(TransactionSourceEnum || (TransactionSourceEnum = {}));
 
-var DepreciationTypeEnum;
-(function (DepreciationTypeEnum) {
-    DepreciationTypeEnum[DepreciationTypeEnum["PLANT_EQUIPMENT"] = 1] = "PLANT_EQUIPMENT";
-    DepreciationTypeEnum[DepreciationTypeEnum["CAPITAL_WORKS"] = 2] = "CAPITAL_WORKS";
-    DepreciationTypeEnum[DepreciationTypeEnum["BULK_DEPRECIATION"] = 3] = "BULK_DEPRECIATION";
-    DepreciationTypeEnum[DepreciationTypeEnum["BORROWING_EXPENSES"] = 4] = "BORROWING_EXPENSES";
-})(DepreciationTypeEnum || (DepreciationTypeEnum = {}));
-
-var DepreciationCalculationEnum;
-(function (DepreciationCalculationEnum) {
-    DepreciationCalculationEnum[DepreciationCalculationEnum["PRIME_COST"] = 1] = "PRIME_COST";
-    DepreciationCalculationEnum[DepreciationCalculationEnum["DIMINISHING"] = 2] = "DIMINISHING";
-    DepreciationCalculationEnum[DepreciationCalculationEnum["CAPITAL"] = 3] = "CAPITAL";
-    DepreciationCalculationEnum[DepreciationCalculationEnum["LVP"] = 4] = "LVP";
-    DepreciationCalculationEnum[DepreciationCalculationEnum["AMORTISATION"] = 5] = "AMORTISATION";
-    DepreciationCalculationEnum[DepreciationCalculationEnum["SBP"] = 6] = "SBP";
-})(DepreciationCalculationEnum || (DepreciationCalculationEnum = {}));
-
 /**
  * Enum with asset types
  */
@@ -2290,68 +2505,6 @@ class TransactionReceipt extends TransactionReceipt$1 {
     }
 }
 
-/**
- * @TODO Alex/Vik: think and create some new collection type
- * @TODO Alex: research all constants and make the same structure
- */
-class ChartAccountsCategoryECollection {
-    constructor(items) {
-        this.items = items || [
-            ChartAccountsCategoryEnum.PROPERTY_INCOME,
-            ChartAccountsCategoryEnum.PROPERTY_EXPENSE,
-            ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION,
-            ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS,
-            ChartAccountsCategoryEnum.WORK_DEPRECIATION,
-            ChartAccountsCategoryEnum.WORK_INCOME,
-            ChartAccountsCategoryEnum.WORK_EXPENSE,
-            ChartAccountsCategoryEnum.OTHER_INCOME,
-            ChartAccountsCategoryEnum.OTHER_EXPENSE,
-            ChartAccountsCategoryEnum.PERSONAL_INCOME,
-            ChartAccountsCategoryEnum.PERSONAL_EXPENSE,
-            ChartAccountsCategoryEnum.SOLE_INCOME,
-            ChartAccountsCategoryEnum.SOLE_EXPENSE,
-            ChartAccountsCategoryEnum.SOLE_DEPRECIATION
-        ];
-    }
-    getByType(types) {
-        if (!Array.isArray(types)) {
-            types = [types];
-        }
-        const items = [];
-        types.forEach((type) => {
-            const filtered = this.items.filter((item) => ChartAccountsCategoryEnum[item].includes(type.toUpperCase()));
-            items.push(...filtered);
-        });
-        return new ChartAccountsCategoryECollection(items);
-    }
-    getByTankType(tankTypes) {
-        if (!Array.isArray(tankTypes)) {
-            tankTypes = [tankTypes];
-        }
-        const items = [];
-        tankTypes.forEach((tankType) => {
-            const filtered = this.items.filter((item) => ChartAccountsCategoryEnum[item].includes(tankType.toUpperCase()));
-            items.push(...filtered);
-        });
-        return new ChartAccountsCategoryECollection(items);
-    }
-}
-
-class ChartAccountsDepreciation extends ChartAccountsDepreciation$1 {
-}
-__decorate([
-    Type(() => ChartAccounts)
-], ChartAccountsDepreciation.prototype, "chartAccounts", void 0);
-__decorate([
-    Transform(({ value }) => +value)
-], ChartAccountsDepreciation.prototype, "limit", void 0);
-__decorate([
-    Transform(({ value }) => +value)
-], ChartAccountsDepreciation.prototype, "effectiveLife", void 0);
-
-class ChartAccountsValue extends ChartAccountsValue$1 {
-}
-
 var IncomeSourceTypeEnum;
 (function (IncomeSourceTypeEnum) {
     IncomeSourceTypeEnum[IncomeSourceTypeEnum["WORK"] = 1] = "WORK";
@@ -2546,413 +2699,280 @@ class BankTransaction extends BankTransaction$1 {
      * check if bank transaction is debit
      */
     isDebit() {
-        return this.type === BankTransactionTypeEnum.DEBIT;
-    }
-    /**
-     * check if bank transaction is credit
-     */
-    isCredit() {
-        return this.type === BankTransactionTypeEnum.CREDIT;
-    }
-    /**
-     * Create Transaction instance based on Bank Transaction
-     */
-    toTransaction() {
-        return plainToClass(Transaction, {
-            amount: +this.amount.toFixed(2),
-            description: this.description,
-            date: this.date,
-            source: TransactionSourceEnum.BANK_TRANSACTION,
-            operation: this.operation,
-            type: this.type,
-        });
-    }
-    /**
-     * Check if bank transaction is completely allocated
-     */
-    isAllocated(allocations) {
-        return this.amount === this.getAllocatedAmount(allocations);
-    }
-    /**
-     * Get bank transaction allocated amount
-     */
-    getAllocatedAmount(allocations) {
-        return allocations.getByBankTransactionsIds([this.id]).amount;
-    }
-    /**
-     * Get bank transaction unallocated amount
-     */
-    getUnallocatedAmount(allocations) {
-        return this.amount - this.getAllocatedAmount(allocations);
-    }
-}
-__decorate([
-    Type(() => Date)
-], BankTransaction.prototype, "date", void 0);
-
-class TransactionAllocation extends TransactionAllocation$1 {
-    /**
-     * Create a new instance of transaction allocation
-     * transaction could be empty since we can POST allocation inside a new transaction
-     */
-    static create(amount, bankTransaction, transaction) {
-        return plainToClass(TransactionAllocation, { amount, transaction, bankTransaction });
-    }
-}
-__decorate([
-    Type(() => BankTransaction)
-], TransactionAllocation.prototype, "bankTransaction", void 0);
-__decorate([
-    Type(() => Transaction)
-], TransactionAllocation.prototype, "transaction", void 0);
-
-class MessageCollection extends Collection {
-    getFirstUnreadMessage(user) {
-        return this.items.find((message) => {
-            return !message.isRead() && message.isFromEmployee() !== user.isEmployee();
-        });
-    }
-    /**
-     * Get List of unread chats
-     */
-    getUnread() {
-        return this.items.filter((message) => !message.readAt);
-    }
-    getFromActiveChats() {
-        return this.filter((message) => message.chat.isActive());
-    }
-    /**
-     * Get amount of chats that contains unread messages
-     */
-    getUnreadChatsAmount(isFromEmployee = false) {
-        // filtered messages for client/employee
-        const filteredMessages = this.filter((message) => isFromEmployee ? message.isFromEmployee() : !message.isFromEmployee());
-        return uniqBy(filteredMessages.getFromActiveChats().getUnread(), 'chat.id').length;
-    }
-    /**
-     * Check if chat has unread chats
-     */
-    hasUnread() {
-        return !!this.getUnread().length;
-    }
-}
-
-var ChatStatusEnum;
-(function (ChatStatusEnum) {
-    ChatStatusEnum[ChatStatusEnum["ACTIVE"] = 1] = "ACTIVE";
-    ChatStatusEnum[ChatStatusEnum["INACTIVE"] = 2] = "INACTIVE";
-})(ChatStatusEnum || (ChatStatusEnum = {}));
-
-class ChatCollection extends Collection {
-    /**
-     * Sort chats by last messages (newest first) + empty chats in the end
-     */
-    getSortedByNewest(messages) {
-        const chatsById = new Dictionary(this.toArray());
-        // get chats array sorted from newest to oldest
-        const chats = uniqBy(new MessageCollection(messages)
-            .filterBy('chat.id', this.getIds())
-            .sortBy('createdAt', true)
-            .toArray()
-            .map((message) => chatsById.get(message.chat.id)), 'id');
-        const emptyChats = differenceBy(this.toArray(), chats, 'id');
-        return this.create([...chats, ...emptyChats]);
-    }
-    getActive() {
-        return this.filterBy('status', ChatStatusEnum.ACTIVE);
+        return this.type === BankTransactionTypeEnum.DEBIT;
     }
-}
-
-/**
- * Collection of MessageDocument instances
- */
-class MessageDocumentCollection extends Collection {
     /**
-     * get list of documents which are not attached to any message
+     * check if bank transaction is credit
      */
-    getUnattached() {
-        return new MessageDocumentCollection(this.items.filter((doc) => !doc.message));
+    isCredit() {
+        return this.type === BankTransactionTypeEnum.CREDIT;
     }
-}
-
-class LoanCollection extends Collection {
     /**
-     * Get new collection of loans filtered by bank accounts ids
-     * @param ids list of bank accounts ids for filter
+     * Create Transaction instance based on Bank Transaction
      */
-    getByBankAccountsIds(ids) {
-        return new LoanCollection(this.items.filter((loan) => { var _a; return ids.includes((_a = loan.bankAccount) === null || _a === void 0 ? void 0 : _a.id); }));
+    toTransaction() {
+        return plainToClass(Transaction, {
+            amount: +this.amount.toFixed(2),
+            description: this.description,
+            date: this.date,
+            source: TransactionSourceEnum.BANK_TRANSACTION,
+            operation: this.operation,
+            type: this.type,
+        });
     }
     /**
-     * Get single loan by bank account id
-     * @param id id of bank account
+     * Check if bank transaction is completely allocated
      */
-    getByBankAccountId(id) {
-        return this.items.find((loan) => { var _a; return ((_a = loan.bankAccount) === null || _a === void 0 ? void 0 : _a.id) === id; });
+    isAllocated(allocations) {
+        return this.amount === this.getAllocatedAmount(allocations);
     }
     /**
-     * Get list of current fin year payments grouped by loan id
+     * Get bank transaction allocated amount
      */
-    groupCurrentYearPaymentsByLoans() {
-        const dictionary = new CollectionDictionary(new LoanPaymentCollection([]));
-        this.items.forEach((loan) => dictionary.add(loan.id, new LoanPaymentCollection(loan.payments).getForCurrentYear()));
-        return dictionary;
+    getAllocatedAmount(allocations) {
+        return allocations.getByBankTransactionsIds([this.id]).amount;
     }
     /**
-     * Get list of vehicle loans
+     * Get bank transaction unallocated amount
      */
-    getVehicleLoans() {
-        return this.filter((loan) => loan.isVehicle());
+    getUnallocatedAmount(allocations) {
+        return this.amount - this.getAllocatedAmount(allocations);
     }
 }
+__decorate([
+    Type(() => Date)
+], BankTransaction.prototype, "date", void 0);
 
-class PropertySaleCollection extends Collection {
-    get grossCGTAfterLoss() {
-        return this.create(this.items.filter((propertySale) => propertySale.grossCGTAfterLoss > 0)).sumBy('grossCGTAfterLoss');
-    }
+class TransactionAllocation extends TransactionAllocation$1 {
     /**
-     * Property sales are CGT applicable unless it has "Principle place of residence" exemption type
+     * Create a new instance of transaction allocation
+     * transaction could be empty since we can POST allocation inside a new transaction
      */
-    getCGTApplicable() {
-        return this.create(this.items.filter((propertySale) => propertySale.isCGTApplicable()));
-    }
-    getByPropertyShareIds(ids) {
-        return this.filterBy('share.id', ids);
+    static create(amount, bankTransaction, transaction) {
+        return plainToClass(TransactionAllocation, { amount, transaction, bankTransaction });
     }
 }
+__decorate([
+    Type(() => BankTransaction)
+], TransactionAllocation.prototype, "bankTransaction", void 0);
+__decorate([
+    Type(() => Transaction)
+], TransactionAllocation.prototype, "transaction", void 0);
 
-var TaxExemptionMetadataEnum;
-(function (TaxExemptionMetadataEnum) {
-    // principle place of residence
-    TaxExemptionMetadataEnum[TaxExemptionMetadataEnum["PPR_DAYS"] = 1] = "PPR_DAYS";
-    // market value once it was moved, decimal
-    TaxExemptionMetadataEnum[TaxExemptionMetadataEnum["MARKET_VALUE"] = 2] = "MARKET_VALUE";
-    TaxExemptionMetadataEnum[TaxExemptionMetadataEnum["CLAIM_PERCENT"] = 3] = "CLAIM_PERCENT";
-})(TaxExemptionMetadataEnum || (TaxExemptionMetadataEnum = {}));
-
-class PropertySaleTaxExemptionMetadataCollection extends Collection {
-    getPPRDays() {
-        var _a, _b;
-        return (_b = (_a = this.getByMetadataId(TaxExemptionMetadataEnum.PPR_DAYS)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0;
-    }
-    getMarketValue() {
-        var _a, _b;
-        return (_b = (_a = this.getByMetadataId(TaxExemptionMetadataEnum.MARKET_VALUE)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0;
+// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.
+class Transaction extends Transaction$1 {
+    constructor() {
+        super(...arguments);
+        // list of child transactions (fees)
+        this.transactions = [];
+        this.metadata = [];
+        this.allocations = [];
+        this.tax = 0;
+        this.operation = TransactionOperationEnum.FIND_AND_MATCH;
+        this.claimPercent = 100;
+        this.amount = 0;
     }
-    getClaimPercent() {
-        var _a, _b;
-        return (_b = (_a = this.getByMetadataId(TaxExemptionMetadataEnum.CLAIM_PERCENT)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 100;
+    isDebit() {
+        return this.type === TransactionTypeEnum.DEBIT;
     }
-    getByMetadataId(id) {
-        return this.items.find((metadata) => metadata.metadata.id === id);
+    isCredit() {
+        return this.type === TransactionTypeEnum.CREDIT;
     }
-}
-
-class PropertyCollection extends Collection {
     /**
-     * Get new property collection filtered by category id
-     * @param id id of category for filter
+     * @TODO move to base collection
      */
-    getByCategoryId(id) {
-        return new PropertyCollection(this.items.filter((property) => property.category.id === id));
+    isIncome() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isCredit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
     }
     /**
-     * Get new property collection filtered by active status
+     * @TODO move to base collection
      */
-    getActiveProperties() {
-        return new PropertyCollection(this.items.filter((property) => property.isActive));
+    isExpense() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isDebit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
     }
-    getCreatedProperties() {
-        return new PropertyCollection(this.items.filter((property) => property.isOwn()));
+    isPersonal() {
+        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
     }
-    /**
-     * Get new property collection filtered by shared
-     */
-    getSharedProperties() {
-        return new PropertyCollection(this.items.filter((property) => !property.isOwn()));
+    isInterest() {
+        return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+    }
+    get chartAccountsCategories() {
+        switch (true) {
+            case this.isPersonal():
+                return CHART_ACCOUNTS_CATEGORIES.personal;
+            case this.isPropertyTank():
+                return CHART_ACCOUNTS_CATEGORIES.property;
+            case this.isSoleTank():
+                return CHART_ACCOUNTS_CATEGORIES.sole;
+            default:
+                return CHART_ACCOUNTS_CATEGORIES.work;
+        }
     }
     /**
-     * Properties that are taxed and will be included in reports (Tax summary, My tax report, e.t.c.)
+     * Get transaction date
      */
-    getTaxInclusive() {
-        return this.create(this.items.filter((property) => property.category.isTaxInclusive));
-    }
-    getUnsold() {
-        return this.create(this.items.filter((property) => !property.isSold()));
+    getDate() {
+        return this.date;
     }
     /**
-     * Get total purchase price for all properties in the collection
+     * Check if transaction type is vehicle
      */
-    get purchasePrice() {
-        return this.sumBy('purchasePrice');
+    isVehicleTransaction() {
+        return this.chartAccounts.isVehicleExpense();
     }
-    get growthPercent() {
-        return this.sumBy('growthPercent');
+    get taxFreeComponent() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.TAX_FREE_COMPONENT);
     }
-    get marketValue() {
-        return this.sumBy('marketValue');
+    get frankingCredit() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.FRANKING_CREDIT);
     }
-    get firstForecastYear() {
-        return this.items.reduce((min, property) => {
-            const current = property.firstForecastYear;
-            return min > current ? current : min;
-        }, new FinancialYear().year);
+    get eligibleForReduction() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.ELIGIBLE_FOR_REDUCTION);
     }
-    get marketValueGrowth() {
-        return (this.marketValue - this.purchasePrice) / this.purchasePrice;
+    get untaxedElement() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.UNTAXED_ELEMENT);
     }
     /**
-     * list of properties
+     * Check if transaction reconcile operation if TRANSFER
+     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
      */
-    getCGTApplicable() {
-        return this.create(this.items.filter((property) => property.isCGTApplicable()));
-    }
-    getOwnerOccupiedProperties() {
-        return new PropertyCollection(this.items.filter((property) => property.category.isOwnerOccupied()));
-    }
-    get earliestContractDate() {
-        return this.items.reduce((min, property) => {
-            return min < property.contractDate ? min : property.contractDate;
-        }, new FinancialYear(new Date()).startDate);
+    get isTransfer() {
+        return this.operation === TransactionOperationEnum.TRANSFER;
     }
-    /**
-     * Get list of unique property categories from collection
-     */
-    getCategories() {
-        return uniqBy(this.items.map((property) => property.category), 'id');
+    isFindAndMatch() {
+        return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
     }
-    /**
-     * Get property with the highest growth percent
-     */
-    getBestPerformanceGrowthProperty() {
-        return this.items.reduce((max, current) => {
-            return max.growthPercent < current.growthPercent ? current : max;
-        }, this.first);
+    isMatchInvoice() {
+        return this.operation === TransactionOperationEnum.MATCH_INVOICE;
     }
-    /**
-     * Get property with the lowest tax position
-     */
-    getBestPerformanceTaxProperty(transactions, depreciations) {
-        const transactionsByProperty = transactions.groupBy('property.id');
-        const depreciationsByProperty = depreciations.groupBy('property.id');
-        return this.items.reduce((min, current) => {
-            const minTaxPosition = min.getTaxPosition(transactionsByProperty.get(min.id), depreciationsByProperty.get(min.id));
-            const currentTaxPosition = current.getTaxPosition(transactionsByProperty.get(current.id), depreciationsByProperty.get(current.id));
-            return minTaxPosition > currentTaxPosition ? current : min;
-        }, this.first);
+    get debit() {
+        return this.isDebit() ? Math.abs(this.grossAmount) : 0;
     }
-    /**
-     * Show best performance properties first
-     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677997/Property+Tank+Dashboard
-     */
-    sortByBestPerformance(transactions, depreciations) {
-        const activeProperties = this.getActiveProperties();
-        // nothing to sort when no active properties
-        if (!activeProperties.length) {
-            return this;
-        }
-        const bestProperties = uniqBy(this.create([
-            activeProperties.getBestPerformanceGrowthProperty(),
-            activeProperties.getBestPerformanceTaxProperty(transactions, depreciations)
-        ]).toArray(), 'id');
-        const newItems = this.remove(bestProperties).toArray();
-        newItems.unshift(...bestProperties);
-        return this.create(newItems);
+    get credit() {
+        return this.isCredit() ? Math.abs(this.grossAmount) : 0;
     }
-}
-
-class PropertyCategoryMovementCollection extends Collection {
     /**
-     * @TODO TT-2355 Alex refactor propertyForecast, use separated api (then I can remove property from param)
+     * Get value of transaction metadata field
+     * @param field for which value should be returned
+     * @Todo modify 'metadata' property from array to Collection
      */
-    getByForecast(property, forecast) {
-        const financialYear = new FinancialYear(forecast.financialYear);
-        return this.filterBy('property.id', property.id).filter((movement) => {
-            return movement.fromDate <= financialYear.endDate && !movement.toDate || movement.toDate >= financialYear.startDate;
-        });
+    getMetadataFieldValue(field) {
+        var _a;
+        return +((_a = this.metadata.find((transactionMetadata) => {
+            return transactionMetadata.chartAccountsMetadata.id === field;
+        })) === null || _a === void 0 ? void 0 : _a.value) || 0;
     }
-    hasCategory(categoryId) {
-        return !!this.findBy('propertyCategory.id', categoryId);
+    isCash() {
+        return this.source === TransactionSourceEnum.CASH;
     }
-}
-
-class PropertyShareCollection extends Collection {
     /**
-     * Get list of incoming property shares
-     * (initiated not by current user)
-     * @TODO Alex: rename
+     * Create Depreciation instance based on Transaction
      */
-    getIncoming() {
-        return this.filter((propertyShare) => {
-            var _a;
-            return ((_a = propertyShare.user) === null || _a === void 0 ? void 0 : _a.isLoggedIn()) && propertyShare.isPending() && propertyShare.property.user.id !== +localStorage.getItem('userId');
+    toDepreciation() {
+        return plainToClass(Depreciation, {
+            date: this.date,
+            amount: this.amount,
+            chartAccounts: this.chartAccounts,
+            description: this.description,
+            type: DepreciationTypeEnum.PLANT_EQUIPMENT,
+            claimPercent: this.claimPercent,
+            property: this.property,
+            calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST
         });
     }
     /**
-     * Get list of outcoming property shares
-     * (initiated by current user)
-     * @TODO Alex: rename
+     * Check if transaction is completely allocated
      */
-    getOutcoming() {
-        return this.filter((propertyShare) => { var _a; return !((_a = propertyShare.user) === null || _a === void 0 ? void 0 : _a.isLoggedIn()); });
-    }
-}
-
-/**
- * Enum with symbols based on depreciation LVP asset type
- */
-var DepreciationLvpAssetTypeEnum;
-(function (DepreciationLvpAssetTypeEnum) {
-    DepreciationLvpAssetTypeEnum["PRIOR_YEARS"] = "A";
-    DepreciationLvpAssetTypeEnum["FIRST_YEAR"] = "L";
-    DepreciationLvpAssetTypeEnum["WRITTEN_OFF"] = "W";
-})(DepreciationLvpAssetTypeEnum || (DepreciationLvpAssetTypeEnum = {}));
-
-class DepreciationCapitalProject extends DepreciationCapitalProject$1 {
-}
-__decorate([
-    Type(() => Date)
-], DepreciationCapitalProject.prototype, "effectiveDate", void 0);
-
-class DepreciationForecast extends DepreciationForecast$1 {
-    get dailyClaimAmount() {
-        return this.claimAmount / this.daysApplied;
-    }
-    get daysApplied() {
-        return moment$1(this.toDate).diff(moment$1(this.fromDate), 'days');
+    isAllocated(allocations) {
+        return this.netAmount === this.getAllocatedAmount(allocations);
     }
-    getDaysByMonth(month) {
-        // @TODO find a better place
-        const year = this.financialYear - (month > 5 ? 1 : 0);
-        // forecast date intersect by month
-        const range = new DateRange(this.fromDate, this.toDate).intersect(new DateRange(new Date(year, month, 1), new Date(year, month + 1, 0)));
-        return range ? range.duration('days') + 1 : 0;
+    getAllocatedAmount(allocations) {
+        return allocations.filterBy('transaction.id', this.id).sumBy('amount');
     }
-    get claimOpenBalance() {
-        return this.openBalance * this.claimRate;
+    getAllocatedClaimAmount(allocations) {
+        let coef = 1;
+        if (this.isSoleTank() && this.isIncome() && this.isGST) {
+            coef = ChartAccounts.GSTCoefficient;
+        }
+        return this.getAllocatedAmount(allocations) * this.claimRatio / coef;
     }
-    get claimCloseBalance() {
-        return this.closeBalance * this.claimRate;
+    getUnallocatedAmount(allocations) {
+        return this.netAmount - this.getAllocatedAmount(allocations);
     }
-    get claimAmount() {
-        return this.amount * this.claimRate;
+    /**
+     * Total transaction amount including taxes and other additional amounts
+     */
+    get grossAmount() {
+        let grossAmount = super.grossAmount + this.tax;
+        if (this.isExpense()) {
+            return grossAmount;
+        }
+        // salary included transactions affect parent transaction amount and as a result grossAmount, skip to avoid double sum
+        grossAmount += new Collection(this.transactions)
+            .filter((t) => { var _a; return !((_a = t.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalaryIncluded()); })
+            .sumBy('amount', true);
+        if (this.isWorkTank()) {
+            grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;
+        }
+        return +(Math.round(grossAmount * 100) / 100).toFixed(2);
     }
-    get claimRate() {
-        return this.claimPercent / 100;
+    /**
+     * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it
+     * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments
+     * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$
+     */
+    get netAmount() {
+        return new Collection(this.transactions)
+            .filter((t) => { var _a; return (_a = t.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalaryIncluded(); })
+            .sumBy('amount') + this.amountWithGst;
     }
-    getClaimAmountByMonth(month) {
-        return this.getDaysByMonth(month) * this.dailyClaimAmount;
+    /**
+     * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore
+     * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)
+     */
+    ignoreSign() {
+        var _a;
+        return !(((_a = this.chartAccounts) === null || _a === void 0 ? void 0 : _a.id) in ChartAccountsKeepSign);
     }
 }
-
-/**
- * Enum with income amount types (Net or Gross)
- */
-var IncomeAmountTypeEnum;
-(function (IncomeAmountTypeEnum) {
-    IncomeAmountTypeEnum[IncomeAmountTypeEnum["NET"] = 0] = "NET";
-    IncomeAmountTypeEnum[IncomeAmountTypeEnum["GROSS"] = 1] = "GROSS";
-})(IncomeAmountTypeEnum || (IncomeAmountTypeEnum = {}));
+__decorate([
+    Type(() => Transaction)
+], Transaction.prototype, "transactions", void 0);
+__decorate([
+    Type(() => Property)
+], Transaction.prototype, "property", void 0);
+__decorate([
+    Type(() => TransactionReceipt)
+], Transaction.prototype, "receipt", void 0);
+__decorate([
+    Type(() => ChartAccounts)
+], Transaction.prototype, "chartAccounts", void 0);
+__decorate([
+    Type(() => IncomeSource)
+], Transaction.prototype, "incomeSource", void 0);
+__decorate([
+    Type(() => TransactionMetadata)
+], Transaction.prototype, "metadata", void 0);
+__decorate([
+    Type(() => Transaction)
+], Transaction.prototype, "transfer", void 0);
+__decorate([
+    Type(() => Loan)
+], Transaction.prototype, "loan", void 0);
+__decorate([
+    Type(() => Date)
+], Transaction.prototype, "date", void 0);
+__decorate([
+    Type(() => TransactionAllocation)
+], Transaction.prototype, "allocations", void 0);
 
 var TransactionCategoryEnum;
 (function (TransactionCategoryEnum) {
@@ -3852,10 +3872,54 @@ class SoleInvoiceCollection extends Collection {
     }
 }
 
+var ServicePriceTypeEnum;
+(function (ServicePriceTypeEnum) {
+    ServicePriceTypeEnum[ServicePriceTypeEnum["DEPRECATED"] = 0] = "DEPRECATED";
+    ServicePriceTypeEnum[ServicePriceTypeEnum["MONTHLY"] = 1] = "MONTHLY";
+    ServicePriceTypeEnum[ServicePriceTypeEnum["MONTHLY_PACKAGE"] = 2] = "MONTHLY_PACKAGE";
+    ServicePriceTypeEnum[ServicePriceTypeEnum["YEARLY"] = 3] = "YEARLY";
+    ServicePriceTypeEnum[ServicePriceTypeEnum["YEARLY_PACKAGE"] = 4] = "YEARLY_PACKAGE";
+})(ServicePriceTypeEnum || (ServicePriceTypeEnum = {}));
+
+/**
+ * @TODO vik refactor
+ */
 class ServicePriceCollection extends Collection {
     getActive() {
         return this.filterBy('isActive', true);
     }
+    get monthly() {
+        return this.filterBy('type', ServicePriceTypeEnum.MONTHLY);
+    }
+    get monthlyPackage() {
+        return this.filterBy('type', ServicePriceTypeEnum.MONTHLY_PACKAGE);
+    }
+    get monthlyPackageSum() {
+        const property = this.monthlyPackage.findBy('product.id', ServiceProductIdEnum.PROPERTIES);
+        // @TODO move to const
+        return this.monthlyPackage.sumBy('amount') + property.amount * 4;
+    }
+    get annual() {
+        return this.filterBy('type', ServicePriceTypeEnum.YEARLY);
+    }
+    get annualPackage() {
+        return this.filterBy('type', ServicePriceTypeEnum.YEARLY_PACKAGE);
+    }
+    get annualPackageSum() {
+        const property = this.annualPackage.findBy('product.id', ServiceProductIdEnum.PROPERTIES);
+        // @TODO move to const
+        return this.annualPackage.sumBy('amount') + property.amount * 4;
+    }
+    getProperty(isAnnual, isPackage) {
+        let type;
+        if (isAnnual) {
+            type = isPackage ? ServicePriceTypeEnum.YEARLY_PACKAGE : ServicePriceTypeEnum.YEARLY;
+        }
+        else {
+            type = isPackage ? ServicePriceTypeEnum.MONTHLY_PACKAGE : ServicePriceTypeEnum.MONTHLY;
+        }
+        return this.filterBy('type', type).findBy('product.id', ServiceProductIdEnum.PROPERTIES);
+    }
 }
 
 class ServiceProductCollection extends Collection {
@@ -4791,220 +4855,207 @@ class UserEventTypeCollection extends Collection {
 
 // @TODO Alex move here all collections
 
-// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.
-class Transaction extends Transaction$1 {
+class ServiceSubscription extends ServiceSubscription$1 {
     constructor() {
         super(...arguments);
-        // list of child transactions (fees)
-        this.transactions = [];
-        this.metadata = [];
-        this.allocations = [];
-        this.tax = 0;
-        this.operation = TransactionOperationEnum.FIND_AND_MATCH;
-        this.claimPercent = 100;
-        this.amount = 0;
-    }
-    isDebit() {
-        return this.type === TransactionTypeEnum.DEBIT;
-    }
-    isCredit() {
-        return this.type === TransactionTypeEnum.CREDIT;
-    }
-    /**
-     * @TODO move to base collection
-     */
-    isIncome() {
-        // @TODO not used
-        if (!this.chartAccounts) {
-            return this.isCredit();
-        }
-        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
-    }
-    /**
-     * @TODO move to base collection
-     */
-    isExpense() {
-        // @TODO not used
-        if (!this.chartAccounts) {
-            return this.isDebit();
-        }
-        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
+        // Number of days after which the trial time will be expired
+        this.lastTrialDays = 4;
     }
-    isPersonal() {
-        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
+    get isTrial() {
+        return !this.stripeId;
     }
-    isInterest() {
-        return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+    get isPaid() {
+        return !!this.stripeId;
     }
-    get chartAccountsCategories() {
-        switch (true) {
-            case this.isPersonal():
-                return CHART_ACCOUNTS_CATEGORIES.personal;
-            case this.isPropertyTank():
-                return CHART_ACCOUNTS_CATEGORIES.property;
-            case this.isSoleTank():
-                return CHART_ACCOUNTS_CATEGORIES.sole;
-            default:
-                return CHART_ACCOUNTS_CATEGORIES.work;
-        }
+    get price() {
+        return this.items.reduce((sum, item) => sum + item.total, 0);
     }
     /**
-     * Get transaction date
+     * get title of subscription
      */
-    getDate() {
-        return this.date;
+    get title() {
+        return this.items.map((item) => item.price.product.title).join(' + ');
+        // return this.isTrial ? 'Trial period' : this.items.map((item) => item.price.product.title).join(' + ');
     }
     /**
-     * Check if transaction type is vehicle
+     * A subscription is considered active if the end date has not yet arrived and its status is "Active" or "Past due"
      */
-    isVehicleTransaction() {
-        return this.chartAccounts.isVehicleExpense();
-    }
-    get taxFreeComponent() {
-        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.TAX_FREE_COMPONENT);
-    }
-    get frankingCredit() {
-        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.FRANKING_CREDIT);
-    }
-    get eligibleForReduction() {
-        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.ELIGIBLE_FOR_REDUCTION);
+    get isActive() {
+        const isExpired = new Date(this.endDate).getTime() < new Date().getTime();
+        return !isExpired && ([ServiceSubscriptionStatusEnum.ACTIVE, ServiceSubscriptionStatusEnum.PAST_DUE].includes(this.status));
     }
-    get untaxedElement() {
-        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.UNTAXED_ELEMENT);
+    get daysRemain() {
+        const daysRemains = Math.round((new Date(this.endDate).getTime() - new Date().getTime()) / (1000 * 3600 * 24));
+        return daysRemains > 0 ? daysRemains : 0;
     }
     /**
-     * Check if transaction reconcile operation if TRANSFER
-     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+     * Check if trial expired
      */
-    get isTransfer() {
-        return this.operation === TransactionOperationEnum.TRANSFER;
-    }
-    isFindAndMatch() {
-        return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
+    isTrialExpired() {
+        return this.daysRemain && this.daysRemain <= 0;
     }
-    isMatchInvoice() {
-        return this.operation === TransactionOperationEnum.MATCH_INVOICE;
+    isTrialExpiring() {
+        return this.daysRemain > 0 && this.daysRemain <= this.lastTrialDays;
     }
-    get debit() {
-        return this.isDebit() ? Math.abs(this.grossAmount) : 0;
+    isRenewable() {
+        return !this.isTrial && this.isActive;
     }
-    get credit() {
-        return this.isCredit() ? Math.abs(this.grossAmount) : 0;
+    getItems() {
+        return new SubscriptionItemCollection(this.items);
     }
     /**
-     * Get value of transaction metadata field
-     * @param field for which value should be returned
-     * @Todo modify 'metadata' property from array to Collection
+     * @TODO move to collection
      */
-    getMetadataFieldValue(field) {
-        var _a;
-        return +((_a = this.metadata.find((transactionMetadata) => {
-            return transactionMetadata.chartAccountsMetadata.id === field;
-        })) === null || _a === void 0 ? void 0 : _a.value) || 0;
+    get workTankItem() {
+        return this.items.find((item) => item.price.product.isWorkTank());
     }
-    isCash() {
-        return this.source === TransactionSourceEnum.CASH;
+    get soleTankItem() {
+        return this.items.find((item) => item.price.product.isSoleTank());
     }
-    /**
-     * Create Depreciation instance based on Transaction
-     */
-    toDepreciation() {
-        return plainToClass(Depreciation, {
-            date: this.date,
-            amount: this.amount,
-            chartAccounts: this.chartAccounts,
-            description: this.description,
-            type: DepreciationTypeEnum.PLANT_EQUIPMENT,
-            claimPercent: this.claimPercent,
-            property: this.property,
-            calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST
+    get propertyTankItem() {
+        return this.items.find((item) => item.price.product.isProperties());
+    }
+    hasPropertyTank() {
+        return !!this.items.find((subscriptionItem) => {
+            return subscriptionItem.price.product.role.includes(UserRolesEnum.PROPERTY_TANK);
+        });
+    }
+    hasWorkTank() {
+        return !!this.items.find((subscriptionItem) => {
+            return subscriptionItem.price.product.role.includes(UserRolesEnum.WORK_TANK);
         });
     }
     /**
-     * Check if transaction is completely allocated
+     * bought before price updates, active for some time to let customer select a new plan
+     * impossible to update, only prolong or buy new
      */
-    isAllocated(allocations) {
-        return this.netAmount === this.getAllocatedAmount(allocations);
-    }
-    getAllocatedAmount(allocations) {
-        return allocations.filterBy('transaction.id', this.id).sumBy('amount');
-    }
-    getAllocatedClaimAmount(allocations) {
-        let coef = 1;
-        if (this.isSoleTank() && this.isIncome() && this.isGST) {
-            coef = ChartAccounts.GSTCoefficient;
-        }
-        return this.getAllocatedAmount(allocations) * this.claimRatio / coef;
-    }
-    getUnallocatedAmount(allocations) {
-        return this.netAmount - this.getAllocatedAmount(allocations);
+    isArchived() {
+        // subscription with at least one archived product considered as archived
+        return !!this.items.filter((item) => item.price.product.isArchived()).length;
     }
     /**
-     * Total transaction amount including taxes and other additional amounts
+     * Case when payment was failed, but user has a time to update payment method
      */
-    get grossAmount() {
-        let grossAmount = super.grossAmount + this.tax;
-        if (this.isExpense()) {
-            return grossAmount;
-        }
-        // salary included transactions affect parent transaction amount and as a result grossAmount, skip to avoid double sum
-        grossAmount += new Collection(this.transactions)
-            .filter((t) => { var _a; return !((_a = t.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalaryIncluded()); })
-            .sumBy('amount', true);
-        if (this.isWorkTank()) {
-            grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;
-        }
-        return +(Math.round(grossAmount * 100) / 100).toFixed(2);
+    isPastDue() {
+        return this.status === ServiceSubscriptionStatusEnum.PAST_DUE;
     }
     /**
-     * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it
-     * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments
-     * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$
+     * Check if current subscription has provided subscription item
      */
-    get netAmount() {
-        return new Collection(this.transactions)
-            .filter((t) => { var _a; return (_a = t.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalaryIncluded(); })
-            .sumBy('amount') + this.amountWithGst;
+    hasItem(itemToCheck) {
+        return !!this.items.find((item) => item.price.id === itemToCheck.price.id);
+    }
+    hasProduct(product) {
+        return !!this.items.find((item) => item.price.product.id === product.id);
+    }
+    isPackage() {
+        return this.items.length === ServiceProduct.quantity;
     }
     /**
-     * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore
-     * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)
+     * Recommended number of properties to buy,
+     * based on the property service product and the number of properties the user has
      */
-    ignoreSign() {
-        var _a;
-        return !(((_a = this.chartAccounts) === null || _a === void 0 ? void 0 : _a.id) in ChartAccountsKeepSign);
+    getRecommendedPropertiesQty(propertyItem, propertiesQty) {
+        const min = propertyItem.price.product.minQty;
+        return Math.max(min, propertiesQty);
     }
 }
 __decorate([
-    Type(() => Transaction)
-], Transaction.prototype, "transactions", void 0);
-__decorate([
-    Type(() => Property)
-], Transaction.prototype, "property", void 0);
+    Type(() => Date)
+], ServiceSubscription.prototype, "startDate", void 0);
 __decorate([
-    Type(() => TransactionReceipt)
-], Transaction.prototype, "receipt", void 0);
+    Type(() => Date)
+], ServiceSubscription.prototype, "endDate", void 0);
 __decorate([
-    Type(() => ChartAccounts)
-], Transaction.prototype, "chartAccounts", void 0);
+    Type(() => ServiceSubscriptionItem)
+], ServiceSubscription.prototype, "items", void 0);
+
+class SoleBusinessAllocation extends SoleBusinessAllocation$1 {
+}
 __decorate([
-    Type(() => IncomeSource)
-], Transaction.prototype, "incomeSource", void 0);
+    Type(() => BankAccount)
+], SoleBusinessAllocation.prototype, "bankAccount", void 0);
 __decorate([
-    Type(() => TransactionMetadata)
-], Transaction.prototype, "metadata", void 0);
+    Type(() => SoleBusiness)
+], SoleBusinessAllocation.prototype, "business", void 0);
 __decorate([
-    Type(() => Transaction)
-], Transaction.prototype, "transfer", void 0);
+    Transform(({ value }) => value || 100),
+    Expose()
+], SoleBusinessAllocation.prototype, "percent", void 0);
+
+class SoleBusinessLossOffsetRule extends SoleBusinessLossOffsetRule$1 {
+}
 __decorate([
-    Type(() => Loan)
-], Transaction.prototype, "loan", void 0);
+    Type(() => SoleBusinessLossOffsetRule)
+], SoleBusinessLossOffsetRule.prototype, "parent", void 0);
+
+/**
+ * If a sole trader business makes a tax loss in a current year, you can generally carry forward that loss and offset profit in future years.
+ * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4641357930/Rules+when+a+business+makes+a+loss+Tax+Summary#Offsetting-current-year-business-losses
+ */
+class SoleBusinessLoss extends SoleBusinessLoss$1 {
+    constructor() {
+        super(...arguments);
+        this.openBalance = 0;
+        this.financialYear = new FinancialYear().year;
+    }
+    get hasOffset() {
+        return !!this.offsetRule;
+    }
+}
 __decorate([
-    Type(() => Date)
-], Transaction.prototype, "date", void 0);
+    Type(() => SoleBusiness)
+], SoleBusinessLoss.prototype, "business", void 0);
 __decorate([
-    Type(() => TransactionAllocation)
-], Transaction.prototype, "allocations", void 0);
+    Type(() => SoleBusinessLossOffsetRule)
+], SoleBusinessLoss.prototype, "offsetRule", void 0);
+
+var MyAccountHistoryInitiatedByEnum;
+(function (MyAccountHistoryInitiatedByEnum) {
+    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["OWNER"] = 0] = "OWNER";
+    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["ACCOUNTANT"] = 1] = "ACCOUNTANT";
+})(MyAccountHistoryInitiatedByEnum || (MyAccountHistoryInitiatedByEnum = {}));
+
+var MyAccountHistoryStatusEnum;
+(function (MyAccountHistoryStatusEnum) {
+    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["SUCCESS"] = 0] = "SUCCESS";
+    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["ERROR"] = 1] = "ERROR";
+})(MyAccountHistoryStatusEnum || (MyAccountHistoryStatusEnum = {}));
+
+var MyAccountHistoryTypeEnum;
+(function (MyAccountHistoryTypeEnum) {
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["REVIEW"] = 0] = "REVIEW";
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPGRADE_PLAN"] = 1] = "UPGRADE_PLAN";
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPLOAD_DOCUMENT"] = 2] = "UPLOAD_DOCUMENT";
+})(MyAccountHistoryTypeEnum || (MyAccountHistoryTypeEnum = {}));
+
+class MyAccountHistory {
+}
+
+class Occupation extends Occupation$1 {
+}
+
+/**
+ * role hierarchy
+ */
+const USER_ROLES = {
+    ROLE_FIRM_OWNER: [UserRolesEnum.FIRM_OWNER, UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_FIRM_MANAGER: [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_EMPLOYEE: [UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_ACCOUNTANT: [UserRolesEnum.ACCOUNTANT],
+    ROLE_ADVISOR: [UserRolesEnum.ADVISOR],
+    ROLE_CLIENT: [UserRolesEnum.CLIENT],
+    ROLE_USER_SUBSCRIPTION: [UserRolesEnum.SUBSCRIPTION],
+    ROLE_USER_WORK: [UserRolesEnum.WORK_TANK],
+    ROLE_USER_PROPERTY: [UserRolesEnum.PROPERTY_TANK],
+    ROLE_USER_SOLE: [UserRolesEnum.SOLE_TANK],
+};
+
+/**
+ * Class with basic information about registering user
+ */
+class UserToRegister {
+}
 
 class SoleInvoiceItem extends SoleInvoiceItem$1 {
     constructor() {
@@ -8990,12 +9041,6 @@ var ServicePriceRecurringIntervalEnum;
     ServicePriceRecurringIntervalEnum[ServicePriceRecurringIntervalEnum["YEAR"] = 4] = "YEAR";
 })(ServicePriceRecurringIntervalEnum || (ServicePriceRecurringIntervalEnum = {}));
 
-var ServicePriceTypeEnum;
-(function (ServicePriceTypeEnum) {
-    ServicePriceTypeEnum[ServicePriceTypeEnum["ONE_TIME"] = 1] = "ONE_TIME";
-    ServicePriceTypeEnum[ServicePriceTypeEnum["RECURRING"] = 2] = "RECURRING";
-})(ServicePriceTypeEnum || (ServicePriceTypeEnum = {}));
-
 var SpareDocumentSpareTypeEnum;
 (function (SpareDocumentSpareTypeEnum) {
     SpareDocumentSpareTypeEnum[SpareDocumentSpareTypeEnum["DOCUMENT"] = 1] = "DOCUMENT";
@@ -13318,6 +13363,9 @@ class SubscriptionService extends RestService$1 {
             return newSubscription;
         }));
     }
+    getStripeClientSecret(subscription) {
+        return this.http.post(this.apiUrl, subscription).pipe(map((response) => response));
+    }
     getActive() {
         return this.get().pipe(map((subscriptions) => subscriptions.getActive()));
     }