taxtank-core 0.28.110 → 0.28.111

package/fesm2015/taxtank-core.js

@@ -3531,1945 +3531,1951 @@ __decorate([
     Type(() => Transaction)
 ], TransactionAllocation.prototype, "transaction", void 0);
 
-class Depreciation$1 extends TransactionBase {
-}
-
-class DepreciationCapitalProject$1 extends AbstractModel {
-}
-
-class DepreciationCapitalProject extends DepreciationCapitalProject$1 {
-}
-__decorate([
-    Type(() => Date)
-], DepreciationCapitalProject.prototype, "effectiveDate", void 0);
-
-class DepreciationForecast$1 extends AbstractModel {
-}
-
-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');
-    }
-    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;
+class PropertySaleCollection extends Collection {
+    get grossCGT() {
+        return this.create(this.items.filter((propertySale) => propertySale.grossCGT > 0)).sumBy('grossCGT');
     }
-    get claimRate() {
-        return this.claimPercent / 100;
+    /**
+     * Property sales are CGT applicable unless it has "Principle place of residence" exemption type
+     */
+    getCGTApplicable() {
+        return this.create(this.items.filter((propertySale) => propertySale.isCGTApplicable()));
     }
-    getClaimAmountByMonth(month) {
-        return this.getDaysByMonth(month) * this.dailyClaimAmount;
+    getByPropertyShareIds(ids) {
+        return this.filterBy('share.id', ids);
     }
 }
 
-/**
- * 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 TransactionCategoryEnum;
-(function (TransactionCategoryEnum) {
-    TransactionCategoryEnum[TransactionCategoryEnum["PROPERTY"] = 0] = "PROPERTY";
-    TransactionCategoryEnum[TransactionCategoryEnum["WORK"] = 1] = "WORK";
-    TransactionCategoryEnum[TransactionCategoryEnum["SOLE"] = 2] = "SOLE";
-    TransactionCategoryEnum[TransactionCategoryEnum["PERSONAL"] = 3] = "PERSONAL";
-})(TransactionCategoryEnum || (TransactionCategoryEnum = {}));
+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 = {}));
 
-/**
- * @TODO Alex: clarify grouping rules and refactor
- */
-class Depreciation extends Depreciation$1 {
-    constructor() {
-        super(...arguments);
-        this.forecasts = [];
-        this.type = DepreciationTypeEnum.PLANT_EQUIPMENT;
-        /**
-         * @TODO remove after ? signs removed from db models
-         */
-        this.amount = 0;
-    }
-    // Type checking
-    isCapital() {
-        return this.type === DepreciationTypeEnum.CAPITAL_WORKS;
-    }
-    isBorrowingExpense() {
-        return this.type === DepreciationTypeEnum.BORROWING_EXPENSES;
-    }
-    isAsset() {
-        return this.type === DepreciationTypeEnum.PLANT_EQUIPMENT;
-    }
-    // Calculation checking
-    isSBPCalculation() {
-        return this.calculation === DepreciationCalculationEnum.SBP;
-    }
-    isPrimeCost() {
-        return this.calculation === DepreciationCalculationEnum.PRIME_COST;
+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;
     }
-    isDiminishing() {
-        return this.calculation === DepreciationCalculationEnum.DIMINISHING;
+    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;
     }
-    // Pool checking
-    isPlantEquipmentPool() {
-        return this.isAsset() && !this.isSBPCalculation() && !this.isWrittenOff() && !this.isLVP();
+    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;
     }
-    isLVP() {
-        return this.isAsset()
-            && !this.isSBPCalculation()
-            && this.isDiminishing()
-            && this.currentYearForecast.closeBalance > Depreciation.WRITTEN_OFF_THRESHOLD
-            && this.currentYearForecast.closeBalance <= Depreciation.LOW_VALUE_POOL_THRESHOLD;
+    getByMetadataId(id) {
+        return this.items.find((metadata) => metadata.metadata.id === id);
     }
-    isSBP() {
-        return this.isAsset() && this.isSBPCalculation() && !this.isWrittenOff();
+}
+
+class PropertyCollection extends Collection {
+    /**
+     * Get new property collection filtered by category id
+     * @param id id of category for filter
+     */
+    getByCategoryId(id) {
+        return new PropertyCollection(this.items.filter((property) => property.category.id === id));
     }
-    isWrittenOff() {
-        return this.writeOffYear === new FinancialYear().year;
+    /**
+     * Get new property collection filtered by active status
+     */
+    getActiveProperties() {
+        return new PropertyCollection(this.items.filter((property) => property.isActive));
     }
-    get writeOffYear() {
-        var _a;
-        if (!this.writeOffManualDate && !this.writeOffDate) {
-            return null;
-        }
-        return (_a = new FinancialYear(this.writeOffManualDate || this.writeOffDate)) === null || _a === void 0 ? void 0 : _a.year;
+    getCreatedProperties() {
+        return new PropertyCollection(this.items.filter((property) => property.isOwn()));
     }
     /**
-     * Check if depreciation chart accounts heading related to vehicles category
+     * Get new property collection filtered by shared
      */
-    isVehicleDepreciation() {
-        var _a;
-        return ((_a = this.chartAccounts.heading) === null || _a === void 0 ? void 0 : _a.id) === ChartAccountsHeadingVehicleListEnum.DEPRECIATION_VEHICLES;
+    getSharedProperties() {
+        return new PropertyCollection(this.items.filter((property) => !property.isOwn()));
     }
     /**
-     * Get depreciation purchase date
+     * Properties that are taxed and will be included in reports (Tax summary, My tax report, e.t.c.)
      */
-    getDate() {
-        return this.date;
+    getTaxInclusive() {
+        return this.create(this.items.filter((property) => property.category.isTaxInclusive));
+    }
+    getUnsold() {
+        return this.create(this.items.filter((property) => !property.isSold()));
     }
     /**
-     * @TODO Vik: Research a problem with depreciations without current year forecast
+     * Get total purchase price for all properties in the collection
      */
-    get currentYearForecast() {
-        return this.forecasts.find((forecast) => {
-            return forecast.financialYear === new FinancialYear().year;
-        }) || plainToClass(DepreciationForecast, {
-            financialYear: new FinancialYear().year,
-            openBalance: 0,
-            closeBalance: 0,
-            amount: 0,
-            claimPercent: 0
-        });
+    get purchasePrice() {
+        return this.sumBy('purchasePrice');
     }
-    getForecastByYear(year) {
-        return this.forecasts.find((forecast) => {
-            return forecast.financialYear === year;
-        });
+    get growthPercent() {
+        return this.sumBy('growthPercent');
     }
-    getClaimAmountByYear(year) {
-        var _a;
-        return ((_a = this.getForecastByYear(year)) === null || _a === void 0 ? void 0 : _a.claimAmount) || 0;
+    get marketValue() {
+        return this.sumBy('marketValue');
     }
-    getCloseBalanceByYear(year) {
-        var _a;
-        return ((_a = this.getForecastByYear(year)) === null || _a === void 0 ? void 0 : _a.closeBalance) || 0;
+    get firstForecastYear() {
+        return this.items.reduce((min, property) => {
+            const current = property.firstForecastYear;
+            return min > current ? current : min;
+        }, new FinancialYear().year);
     }
-    isBuildingAtCost() {
-        return this.chartAccounts.id === ChartAccountsListEnum.BUILDING_AT_COST;
+    get marketValueGrowth() {
+        return (this.marketValue - this.purchasePrice) / this.purchasePrice;
     }
     /**
-     * Create a new transaction from current depreciation
+     * list of properties
      */
-    toTransaction(params = {}) {
-        var _a, _b;
-        return plainToClass(Transaction, Object.assign(params, this, {
-            amount: -((_a = this.currentYearForecast) === null || _a === void 0 ? void 0 : _a.amount) || 0,
-            claimAmount: -((_b = this.currentYearForecast) === null || _b === void 0 ? void 0 : _b.claimAmount) || 0,
-        }));
+    getCGTApplicable() {
+        return this.create(this.items.filter((property) => property.isCGTApplicable()));
     }
-    /**
-     * @TODO Michael: remove and check everywhere in reports
-     */
-    get claimAmount() {
-        var _a;
-        return ((_a = this.currentYearForecast) === null || _a === void 0 ? void 0 : _a.claimAmount) || 0;
+    getOwnerOccupiedProperties() {
+        return new PropertyCollection(this.items.filter((property) => property.category.isOwnerOccupied()));
     }
-    get amountWithGst() {
-        // gst applies only to new assets
-        if (this.isNew()) {
-            return super.amountWithGst;
-        }
-        return this.amount;
+    get earliestContractDate() {
+        return this.items.reduce((min, property) => {
+            return min < property.contractDate ? min : property.contractDate;
+        }, new FinancialYear(new Date()).startDate);
     }
-    get gstClaimAmount() {
-        var _a;
-        return this.gstAmount * ((_a = this.currentYearForecast) === null || _a === void 0 ? void 0 : _a.claimRate);
+    /**
+     * Get list of unique property categories from collection
+     */
+    getCategories() {
+        return uniqBy(this.items.map((property) => property.category), 'id');
     }
     /**
-     * assets purchased in the current financial year
+     * Get property with the highest growth percent
      */
-    isNew() {
-        return new FinancialYear(this.date).year === new FinancialYear().year;
-    }
-}
-Depreciation.WRITTEN_OFF_THRESHOLD = 300;
-Depreciation.LOW_VALUE_POOL_THRESHOLD = 1000;
-__decorate([
-    Type(() => Date)
-], Depreciation.prototype, "purchaseDate", void 0);
-__decorate([
-    Type(() => Date)
-], Depreciation.prototype, "date", void 0);
-__decorate([
-    Type(() => Date)
-], Depreciation.prototype, "lowValuePoolDate", void 0);
-__decorate([
-    Type(() => Date)
-], Depreciation.prototype, "writeOffManualDate", void 0);
-__decorate([
-    Type(() => Date)
-], Depreciation.prototype, "writeOffDate", void 0);
-__decorate([
-    Type(() => DepreciationCapitalProject)
-], Depreciation.prototype, "depreciationCapitalProject", void 0);
-__decorate([
-    Type(() => DepreciationForecast),
-    Transform(({ value, obj }) => {
-        // value = array of DepreciationForecast
-        // obj = plain (whole Depreciation object)
-        // Set isLVP flag for each DepreciationForecast
-        // @TODO refactor
-        value.forEach((forecast) => {
-            forecast.isLVP =
-                forecast.closeBalance < 1000 &&
-                    obj.calculation === DepreciationCalculationEnum.DIMINISHING &&
-                    obj.type === DepreciationTypeEnum.PLANT_EQUIPMENT &&
-                    !(obj.amount > Depreciation.WRITTEN_OFF_THRESHOLD && obj.amount < Depreciation.LOW_VALUE_POOL_THRESHOLD) &&
-                    !(obj.writeOffDate && new FinancialYear(new Date(obj.writeOffDate)).year === obj.financialYear);
-        });
-        return value;
-    })
-], Depreciation.prototype, "forecasts", void 0);
-__decorate([
-    Type(() => ChartAccounts)
-], Depreciation.prototype, "chartAccounts", void 0);
-__decorate([
-    Type(() => BankTransaction)
-], Depreciation.prototype, "bankTransaction", void 0);
-__decorate([
-    Exclude()
-], Depreciation.prototype, "amountWithGst", null);
-__decorate([
-    Exclude()
-], Depreciation.prototype, "gstClaimAmount", null);
-
-// @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;
-    }
-    isDebit() {
-        return this.type === TransactionTypeEnum.DEBIT;
-    }
-    isCredit() {
-        return this.type === TransactionTypeEnum.CREDIT;
+    getBestPerformanceGrowthProperty() {
+        return this.items.reduce((max, current) => {
+            return max.growthPercent < current.growthPercent ? current : max;
+        }, this.first);
     }
     /**
-     * @TODO move to base collection
+     * Get property with the lowest tax position
      */
-    isIncome() {
-        // @TODO not used
-        if (!this.chartAccounts) {
-            return this.isCredit();
-        }
-        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
+    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);
     }
     /**
-     * @TODO move to base collection
+     * Show best performance properties first
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677997/Property+Tank+Dashboard
      */
-    isExpense() {
-        // @TODO not used
-        if (!this.chartAccounts) {
-            return this.isDebit();
+    sortByBestPerformance(transactions, depreciations) {
+        const activeProperties = this.getActiveProperties();
+        // nothing to sort when no active properties
+        if (!activeProperties.length) {
+            return this;
         }
-        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
+        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);
     }
-    isPersonal() {
-        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
+}
+
+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;
+        });
     }
-    isInterest() {
-        return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+    hasCategory(categoryId) {
+        return !!this.findBy('propertyCategory.id', categoryId);
     }
-    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;
+}
+
+class VehicleClaimCollection extends Collection {
+    /**
+     * Get remaining kilometers limit. Total limit ({@link VehicleClaim.totalKmsLimit}) - claimed kilometers from other vehicle claims
+     */
+    getKmsLimitForClaim(claim) {
+        let collection = this;
+        if (claim) {
+            collection = collection.removeBy('id', claim.id);
         }
+        return VehicleClaim.totalKmsLimit - collection.sumBy('kilometers');
     }
     /**
-     * Check if transaction has 'Kms travelled for work' chart accounts category
+     * Get remaining work usage limit. Total limit ({@link VehicleClaim.totalWorkUsagePercent}) - claimed percent from other vehicle claims
      */
-    get isKmsChartAccountsCategory() {
-        return this.chartAccounts.id === ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK;
+    getWorkUsageLimitForClaim(claim) {
+        let collection = this;
+        if (claim) {
+            collection = collection.removeBy('id', claim.id);
+        }
+        return VehicleClaim.totalWorkUsagePercent - collection.sumBy('workUsage');
     }
+}
+
+class VehicleLogbookCollection extends Collection {
     /**
-     * Get transaction date
+     * Best period may be calculated only when user has logbooks minimum for VehicleLogbook.bestPeriodWeeks
+     * @TODO Vik: Best period: move this and related logic to backend
      */
-    getDate() {
-        return this.date;
+    isBestPeriodExist() {
+        if (this.items.length < 2) {
+            return false;
+        }
+        return VehicleLogbook.bestPeriodDuration < (this.last.date.getTime() - this.first.date.getTime());
     }
     /**
-     * Check if transaction type is vehicle
+     * Get collection of non-personal logbooks (work-related, sole-related).
+     * @TODO Vik: Best period: move this and related logic to backend
      */
-    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 untaxedElement() {
-        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.UNTAXED_ELEMENT);
+    getClaimableLogbooks() {
+        return this.filterBy('isPersonal', false);
     }
     /**
-     * Check if transaction reconcile operation if TRANSFER
-     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+     * Get Logbook Period with the biggest work usage percent
+     * Best period duration is defined as VehicleLogbook.bestPeriodWeeks by the ATO
+     * @TODO Vik: Best period: move this and related logic to backend
      */
-    get isTransfer() {
-        return this.operation === TransactionOperationEnum.TRANSFER;
-    }
-    isFindAndMatch() {
-        return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
-    }
-    isMatchInvoice() {
-        return this.operation === TransactionOperationEnum.MATCH_INVOICE;
-    }
-    get debit() {
-        return this.isDebit() ? Math.abs(this.grossAmount) : 0;
-    }
-    get credit() {
-        return this.isCredit() ? Math.abs(this.grossAmount) : 0;
+    getBestPeriod() {
+        if (!this.isBestPeriodExist()) {
+            return null;
+        }
+        let bestPeriod;
+        // get list of all logbooks available for best period calculation
+        const claimableLogbooks = this.getClaimableLogbooks().toArray();
+        for (let i = 0; i < claimableLogbooks.length; i++) {
+            // no sense to check next logbooks because we already get the end of the year
+            if (bestPeriod && bestPeriod.isEndOfYear()) {
+                break;
+            }
+            // get date range started from current handling logbook date
+            const dateRange = claimableLogbooks[i].getPeriod();
+            // get all logbooks included in current logbook period
+            const logbooksInRange = this.filterByRange('date', dateRange.start, dateRange.end);
+            const currentPeriod = plainToClass(LogbookPeriod, {
+                from: dateRange.start,
+                to: dateRange.end,
+                kilometers: logbooksInRange.getClaimableLogbooks().kilometers,
+                workUsage: logbooksInRange.getWorkUsage(),
+                logbooks: logbooksInRange
+            });
+            // compare with previous best period and overwrite if needs
+            if (!bestPeriod || currentPeriod.workUsage > bestPeriod.workUsage) {
+                bestPeriod = currentPeriod;
+            }
+            else if (currentPeriod.workUsage === bestPeriod.workUsage) {
+                // if work usage is the same then get period with the biggest work usage for work tank
+                const oldWorkUsage = bestPeriod.logbooks.filterBy('tankType', TankTypeEnum.WORK).getWorkUsage();
+                const currentWorkUsage = currentPeriod.logbooks.filterBy('tankType', TankTypeEnum.WORK).getWorkUsage();
+                if (oldWorkUsage < currentWorkUsage) {
+                    bestPeriod = currentPeriod;
+                }
+            }
+        }
+        return bestPeriod;
     }
     /**
-     * Get value of transaction metadata field
-     * @param field for which value should be returned
-     * @Todo modify 'metadata' property from array to Collection
+     * Calculate total kilometers traveled
      */
-    getMetadataFieldValue(field) {
-        var _a;
-        return +((_a = this.metadata.find((transactionMetadata) => {
-            return transactionMetadata.chartAccountsMetadata.id === field;
-        })) === null || _a === void 0 ? void 0 : _a.value) || 0;
-    }
-    isCash() {
-        return this.source === TransactionSourceEnum.CASH;
+    get kilometers() {
+        return this.sumBy('kilometers');
     }
     /**
-     * Create Depreciation instance based on Transaction
+     * Calculate work usage (percent of business-related kilometers from total kilometers)
+     * @TODO Alex: TT-2089 replace with getter
      */
-    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
-        });
+    getWorkUsage() {
+        const workKilometers = this.getClaimableLogbooks().kilometers;
+        return Math.round(workKilometers / this.kilometers * 100);
     }
     /**
-     * Check if transaction is completely allocated
+     * Get list of logbooks related to passed vehicle claim
      */
-    isAllocated(allocations) {
-        return this.grossAmount === this.getAllocatedAmount(allocations);
+    getByVehicleClaim(vehicleClaim) {
+        return vehicleClaim.isSoleTank()
+            // sole tank may have multiple vehicle claims, so we need to filter by business.id
+            ? this.filterBy('business.id', vehicleClaim.business.id)
+            // work tank may have only one vehicle claim, so we need to filter by tank type
+            : this.filterBy('tankType', TankTypeEnum.WORK);
     }
-    getAllocatedAmount(allocations) {
-        return allocations.filterBy('transaction.id', this.id).sumBy('amount');
+}
+
+/**
+ * List of objects grouped by passed property
+ */
+class Dictionary {
+    constructor(items, path = 'id') {
+        this.items = {};
+        if (!items.length) {
+            return;
+        }
+        // Do nothing if provided path was not found in the 1st item
+        if (!hasIn(items[0], path.split('.')[0])) {
+            return;
+        }
+        this.groupItems(items, path);
     }
-    getAllocatedClaimAmount(allocations) {
-        return this.getAllocatedAmount(allocations) * this.claimRatio;
+    add(key, value) {
+        this.items[key] = value;
+    }
+    get(key) {
+        return this.items[key] !== undefined ? this.items[key] : null;
+    }
+    groupItems(items, path) {
+        items.forEach((item) => {
+            let key = get(item, path);
+            // if object does not have property for grouping it will be grouped as 'other'
+            if (key === undefined) {
+                key = 'other';
+            }
+            this.items[key] = item;
+        });
     }
+}
+
+class SoleBusinessLossesCollection extends Collection {
     /**
-     * Get transaction unallocated amount
+     * Business loss applied in current year, includes previous year losses and current year losses for businesses matching offset rule
      */
-    getUnallocatedAmount(allocations) {
-        return this.grossAmount - this.getAllocatedAmount(allocations);
+    calculateBusinessLossApplied(transactions) {
+        // claim amounts for businesses that can be applied to be reduced by prior year business losses
+        const claimAmountsByBusinessId = this.getClaimAmountsByBusinessId(transactions);
+        return Object.keys(claimAmountsByBusinessId.items).reduce((sum, businessId) => {
+            const loss = this.findBy('business.id', +businessId);
+            const lossOpenBalance = (loss === null || loss === void 0 ? void 0 : loss.openBalance) || 0;
+            // business loss can be applied to business profit or other income types profit in case in offset rule met
+            return sum + ((loss === null || loss === void 0 ? void 0 : loss.offsetRule) ? lossOpenBalance : Math.min(lossOpenBalance, claimAmountsByBusinessId.get(businessId)));
+        }, 0);
     }
     /**
-     * Total transaction amount including taxes and other additional amounts
+     * Get business claim amounts that can be applied to be reduced by prior year business losses:
+     * businesses with income or businesses with a loss, but which met the non-commercial loss rules
+     * https://www.ato.gov.au/Business/Non-commercial-losses/
      */
-    get grossAmount() {
-        let grossAmount = super.grossAmount + this.tax;
-        if (this.isExpense()) {
-            return grossAmount;
-        }
-        grossAmount += this.transactions.filter((t) => { var _a; return !((_a = t.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalaryIncluded()); }).reduce((sum, transaction) => sum + Math.abs(transaction.amount), 0);
-        if (this.isWorkTank()) {
-            grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;
-        }
-        return +(Math.round(grossAmount * 100) / 100).toFixed(2);
+    getClaimAmountsByBusinessId(transactions) {
+        const claimAmountsByBusinessId = new Dictionary([]);
+        const transactionsByBusinessId = new CollectionDictionary(transactions, 'business.id');
+        transactionsByBusinessId.keys.forEach((businessId) => {
+            var _a;
+            // business loss may not exist if, when creating a business, user didn't add losses for previous years
+            const lossOffsetRule = (_a = this.findBy('business.id', +businessId)) === null || _a === void 0 ? void 0 : _a.offsetRule;
+            const businessClaimAmount = transactionsByBusinessId
+                .get(businessId)
+                .getClaimAmountByBusinessId(+businessId);
+            // no way to apply loss for business without profit if offset rules not met
+            if (businessClaimAmount < 0 && !lossOffsetRule) {
+                return;
+            }
+            claimAmountsByBusinessId.add(businessId, businessClaimAmount);
+        });
+        return claimAmountsByBusinessId;
     }
 }
-__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);
 
-class SoleInvoiceItem extends SoleInvoiceItem$1 {
-    constructor() {
-        super(...arguments);
-        this.isGST = false;
+class SoleInvoiceCollection extends Collection {
+    getOverdue() {
+        return this.filter((invoice) => invoice.isOverdue());
     }
-    get totalPrice() {
-        return this.price * this.quantity;
+    getUnpaid() {
+        return this.filter((invoice) => invoice.isUnpaid());
     }
-}
-__decorate([
-    Type(() => SoleInvoice)
-], SoleInvoiceItem.prototype, "invoice", void 0);
-__decorate([
-    Type(() => ChartAccounts)
-], SoleInvoiceItem.prototype, "chartAccounts", void 0);
-__decorate([
-    Type(() => Transaction)
-], SoleInvoiceItem.prototype, "transaction", void 0);
-
-class SoleContact$1 extends AbstractModel {
-}
-
-// @TODO Alex/Vik: Create some base class for User and SoleContact with common methods and properties
-class SoleContact extends SoleContact$1 {
-    get fullName() {
-        return `${this.firstName} ${this.lastName}`;
+    getPaid() {
+        return this.filter((invoice) => invoice.isPaid());
     }
-    getPhotoPlaceholder() {
-        return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
+    getPending() {
+        return this.filter((invoice) => invoice.isPending());
     }
-    // @TODO Vik: add photo field to SoleContact
-    getPhoto() {
-        return '';
+    getTransactionsIds() {
+        return flatten(this.items.map((invoice) => invoice.getTransactionsIds()));
     }
 }
-__decorate([
-    Type(() => User)
-], SoleContact.prototype, "user", void 0);
-__decorate([
-    Type(() => Phone)
-], SoleContact.prototype, "phone", void 0);
-__decorate([
-    Type(() => Address)
-], SoleContact.prototype, "address", void 0);
-__decorate([
-    Type(() => SoleInvoice)
-], SoleContact.prototype, "invoices", void 0);
 
-class SoleInvoiceTemplate$1 extends AbstractModel {
+/**
+ * Chart serie class: chart data item
+ * @TODO consider rename to ChartSerieData
+ */
+class ChartSerie {
 }
 
-var SoleInvoiceTemplateTaxTypeEnum;
-(function (SoleInvoiceTemplateTaxTypeEnum) {
-    SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["TAX_EXCLUSIVE"] = 0] = "TAX_EXCLUSIVE";
-    SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["TAX_INCLUSIVE"] = 1] = "TAX_INCLUSIVE";
-    SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["NO_TAX"] = 2] = "NO_TAX";
-})(SoleInvoiceTemplateTaxTypeEnum || (SoleInvoiceTemplateTaxTypeEnum = {}));
-
-class SoleInvoiceTemplate extends SoleInvoiceTemplate$1 {
-    constructor() {
-        super(...arguments);
-        /**
-         * Affects to SoleInvoiceItem.isGST flag availability.
-         * When NONE: isGST is unavailable
-         * When EXCLUSIVE: GST amount added additionaly to invoice total price
-         * When INCLUSIVE: GST amount is already included to invoice total price
-         */
-        this.taxType = SoleInvoiceTemplateTaxTypeEnum.NO_TAX;
-    }
-    /**
-     * Get term duration in milliseconds
-     */
-    get termTime() {
-        return this.term * 24 * 3600 * 1000;
-    }
+/**
+ * Chart data class
+ * @TODO consider rename to ChartSerie
+ */
+class ChartData {
 }
 __decorate([
-    Type(() => SoleBusiness)
-], SoleInvoiceTemplate.prototype, "business", void 0);
-__decorate([
-    Type(() => BankAccount)
-], SoleInvoiceTemplate.prototype, "bankAccount", void 0);
-
-var SoleInvoiceStatusesEnum;
-(function (SoleInvoiceStatusesEnum) {
-    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["CANCELED"] = 0] = "CANCELED";
-    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["DRAFT"] = 1] = "DRAFT";
-    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["PENDING"] = 2] = "PENDING";
-    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["PAID"] = 3] = "PAID";
-})(SoleInvoiceStatusesEnum || (SoleInvoiceStatusesEnum = {}));
+    Type(() => ChartSerie)
+], ChartData.prototype, "data", void 0);
 
-var SoleInvoiceTaxTypeEnum;
-(function (SoleInvoiceTaxTypeEnum) {
-    SoleInvoiceTaxTypeEnum[SoleInvoiceTaxTypeEnum["TAX_EXCLUSIVE"] = 0] = "TAX_EXCLUSIVE";
-    SoleInvoiceTaxTypeEnum[SoleInvoiceTaxTypeEnum["TAX_INCLUSIVE"] = 1] = "TAX_INCLUSIVE";
-    SoleInvoiceTaxTypeEnum[SoleInvoiceTaxTypeEnum["NO_TAX"] = 2] = "NO_TAX";
-})(SoleInvoiceTaxTypeEnum || (SoleInvoiceTaxTypeEnum = {}));
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan'];
 
-class SoleInvoiceItemCollection extends Collection {
-    get gstPrice() {
-        return this.filterBy('isGST', true).sumBy('totalPrice');
+/**
+ * @TODO extend from TransactionBaseCollection
+ * Collection of transactions
+ */
+class TransactionCollection extends ExportableCollection {
+    /**
+     * @TODO use TransactionBaseCollection instead
+     * we use depreciations as expense transactions a lot
+     */
+    constructor(transactions = [], depreciations = []) {
+        super([...transactions, ...depreciations.map((depreciation) => depreciation.toTransaction())]);
     }
-}
-
-class SoleInvoice extends SoleInvoice$1 {
-    constructor() {
-        super(...arguments);
-        this.status = SoleInvoiceStatusesEnum.DRAFT;
-        this.taxType = SoleInvoiceTaxTypeEnum.NO_TAX;
+    getSoleTransactions() {
+        return this.filter((transaction) => transaction.isSoleTank());
+    }
+    get amount() {
+        return this.sumBy('amount');
+    }
+    getUnallocatedAmount(allocations) {
+        return this.items.reduce((sum, transaction) => {
+            return sum + transaction.getUnallocatedAmount(allocations.filterBy('transaction.id', transaction.id));
+        }, 0);
     }
     /**
-     * Get items array as collection
+     * get date of the last transaction
      */
-    get itemsCollection() {
-        return new SoleInvoiceItemCollection(this.items);
+    getLastTransactionDate() {
+        return new Date(Math.max.apply(Math, this.items.map((transaction) => transaction.date)));
+    }
+    get claimAmount() {
+        return this.items.reduce((sum, transaction) => sum + transaction.claimAmount, 0);
+    }
+    get grossClaimAmount() {
+        return this.items.reduce((sum, transaction) => sum + transaction.grossClaimAmount, 0);
+    }
+    get grossAmount() {
+        return this.items.reduce((sum, transaction) => sum + transaction.grossAmount, 0);
+    }
+    getByChartAccountsCategories(categories) {
+        return new TransactionCollection(this.items.filter((transaction) => categories.includes(transaction.chartAccounts.category)));
     }
     /**
-     * Total price of all items
+     * Get transactions by month
+     * @param monthIndex by which desired month should be taken
      */
-    get price() {
-        return this.itemsCollection.sumBy('totalPrice');
+    getByMonth(monthIndex) {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.date.getMonth() === monthIndex));
     }
     /**
-     * Total invoice price without GST
+     * Get collection of transactions metadata
      */
-    get netPrice() {
-        if (this.isTaxInclusive()) {
-            return this.price - this.GSTAmount;
-        }
-        return this.price;
+    getTransactionsMetadata() {
+        const metadataArray = [];
+        this.items.forEach((transaction) => {
+            metadataArray.push(...transaction.metadata);
+        });
+        return new Collection(metadataArray);
+    }
+    getIncomeTransactions() {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.isIncome()));
+    }
+    getExpenseTransactions() {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.isExpense() && !transaction.isInterest()));
+    }
+    get claimIncome() {
+        return this.getIncomeTransactions().claimAmount;
+    }
+    get claimExpense() {
+        return this.getExpenseTransactions().claimAmount;
+    }
+    getInterestTransactions() {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.isInterest()));
+    }
+    get claimInterest() {
+        return this.getInterestTransactions().claimAmount;
     }
     /**
-     * Total final price (net + GST)
+     * Get collection of transactions and properties filtered by properties ids
+     * @param ids Ids of properties for filter
      */
-    get grossPrice() {
-        if (this.isTaxExclusive()) {
-            return this.price + this.GSTAmount;
-        }
-        return this.price;
+    getByPropertiesIds(ids) {
+        return new TransactionCollection(this.items.filter((transaction) => {
+            var _a;
+            return ids.includes((_a = transaction.property) === null || _a === void 0 ? void 0 : _a.id);
+        }));
     }
     /**
-     * Total GST amount
+     * Get new collection filtered by income source id
+     * @param id id of income source for filter
      */
-    get GSTAmount() {
-        switch (this.taxType) {
-            case SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE:
-                return this.inclusiveGSTAmount;
-            case SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE:
-                return this.exclusiveGSTAmount;
-            case SoleInvoiceTaxTypeEnum.NO_TAX:
-                return 0;
-        }
+    getByIncomeSourceId(id) {
+        return new TransactionCollection(this.items.filter((transaction) => { var _a; return ((_a = transaction.incomeSource) === null || _a === void 0 ? void 0 : _a.id) === id; }));
     }
     /**
-     * When tax inclusive, GST amount is included to total price
+     * Get new collection filtered by chart accounts category
+     * @param category Chart accounts category value
      */
-    get inclusiveGSTAmount() {
-        const gstPrice = this.itemsCollection.gstPrice;
-        return +(gstPrice - (gstPrice / (1 + ChartAccounts.GSTRatio))).toFixed(2);
+    getByChartAccountsCategory(category) {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.chartAccounts.category === category));
     }
     /**
-     * When tax exclusive, GST amount should be added additionally to total price
+     * Get new collection of property transactions
      */
-    get exclusiveGSTAmount() {
-        return +(this.itemsCollection.gstPrice * ChartAccounts.GSTRatio).toFixed(2);
+    getPropertyTransactions() {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.isPropertyTank()));
     }
-    isDraft() {
-        return this.status === SoleInvoiceStatusesEnum.DRAFT;
+    getDebitTransactions() {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.isDebit()));
     }
-    isCancelled() {
-        return this.status === SoleInvoiceStatusesEnum.CANCELED;
+    getCreditTransactions() {
+        return new TransactionCollection(this.items.filter((transaction) => transaction.isCredit()));
     }
-    isPending() {
-        return this.status === SoleInvoiceStatusesEnum.PENDING;
+    getByAllocations(allocations) {
+        return new TransactionCollection(this.items.filter((transaction) => allocations.hasTransaction(transaction)));
     }
-    isPaid() {
-        return this.status === SoleInvoiceStatusesEnum.PAID;
+    /**
+     * Get transactions related to Vehicle category
+     */
+    getVehicleTransactions() {
+        return this.create(this.items.filter((transaction) => {
+            return transaction.isVehicleTransaction();
+        }));
     }
-    isOverdue() {
-        return this.isPending() && this.dateTo < new Date();
+    /**
+     * Get new transaction collection filtered by tank type
+     */
+    getByTankType(tankType) {
+        return this.create(this.items.filter((transaction) => {
+            switch (tankType) {
+                case TankTypeEnum.PROPERTY:
+                    return transaction.isPropertyTank();
+                case TankTypeEnum.WORK:
+                    return transaction.isWorkTank();
+                case TankTypeEnum.SOLE:
+                    return transaction.isSoleTank();
+                // Transaction may be not related to any tank type (personal)
+                default:
+                    return false;
+            }
+        }));
     }
-    isUnpaid() {
-        return this.isPending() && this.dateTo >= new Date();
+    getExportHeader() {
+        return ['Date', 'Description', 'Debit', 'Credit'];
+    }
+    getExportFooter() {
+        return [
+            plainToClass(ExportCell, { value: 'Total', type: ExportCellTypeEnum.STRING }),
+            plainToClass(ExportCell, { value: '', type: ExportCellTypeEnum.STRING }),
+            plainToClass(ExportCell, { value: this.sumBy('debit'), type: ExportCellTypeEnum.CURRENCY }),
+            plainToClass(ExportCell, { value: this.sumBy('credit'), type: ExportCellTypeEnum.CURRENCY })
+        ];
+    }
+    getExportBody() {
+        return this.items.map((transaction) => {
+            return [
+                plainToClass(ExportCell, { value: transaction.date, type: ExportCellTypeEnum.DATE }),
+                plainToClass(ExportCell, { value: transaction.description, type: ExportCellTypeEnum.STRING }),
+                plainToClass(ExportCell, { value: transaction.debit, type: ExportCellTypeEnum.CURRENCY }),
+                plainToClass(ExportCell, { value: transaction.credit, type: ExportCellTypeEnum.CURRENCY })
+            ];
+        });
     }
     /**
-     * GST is not available for invoices without taxes
+     * Get list of vehicle transactions filtered by vehicle claim
      */
-    isNoTax() {
-        return this.taxType === SoleInvoiceTaxTypeEnum.NO_TAX;
+    getByVehicleClaim(vehicleClaim) {
+        if (!vehicleClaim) {
+            return this.create([]);
+        }
+        return vehicleClaim.isSoleTank()
+            // sole tank may have multiple vehicle claims, so we need to filter by business.id
+            ? this.getVehicleTransactions().filterBy('business.id', vehicleClaim.business.id)
+            // work tank may have only one vehicle claim, so we need to filter by tank type
+            : this.getVehicleTransactions().filterBy('tankType', TankTypeEnum.WORK);
     }
     /**
-     * GST amount is not included in items prices for invoices with tax exclusive,
-     * we should add GST amount additionaly to subtotal price to get total price
+     * Get list of vehicle transactions except KMS transactions
      */
-    isTaxExclusive() {
-        return this.taxType === SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE;
+    getLogbookTransactions() {
+        return this
+            .getVehicleTransactions()
+            .removeBy('chartAccounts.id', [ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK, ChartAccountsListEnum.KLMS_TRAVELLED]);
     }
     /**
-     * GST amount already included in items prices for invoices with tax inclusive,
-     * we should subtract GST amount from total price to get subtotal price
+     * Build chart data with transactions cash position.
+     * Cash position = Income - Expenses (include depreciations)
+     * Chart data for each month from fin year start till current month
      */
-    isTaxInclusive() {
-        return this.taxType === SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE;
+    getCashPositionChartData() {
+        const chartData = [
+            plainToClass(ChartData, { name: 'Income', data: [] }),
+            plainToClass(ChartData, { name: 'Expense', data: [] })
+        ];
+        new FinancialYear().getPastMonths().forEach((month) => {
+            chartData[0].data.push({
+                label: MONTHS[month],
+                value: this.getIncomeTransactions().getByMonth(month).claimAmount
+            });
+            chartData[1].data.push({
+                label: MONTHS[month],
+                value: Math.abs(this.getExpenseTransactions().getByMonth(month).claimAmount)
+            });
+        });
+        return chartData;
     }
-    getNumber() {
-        return String(this.number).padStart(SoleInvoice.NUMBER_LENGTH, '0');
+    /**
+     * user pays GST only from allocated part (or paid) of income
+     */
+    calculateAllocatedClaimAmount(allocations) {
+        let allocatedClaimAmount = 0;
+        this.filterBy('isGST', true).toArray().forEach((transaction) => {
+            allocatedClaimAmount += transaction.getAllocatedClaimAmount(allocations);
+        });
+        return allocatedClaimAmount;
     }
-    get name() {
-        return `invoice-${this.getNumber()}.pdf`;
+    calculateAllocatedGST(allocations) {
+        return this.calculateAllocatedClaimAmount(allocations) * ChartAccounts.GSTRatio;
     }
-    getTransactionsIds() {
-        return new Collection(this.items).mapBy('transaction.id');
-        this.items.map((item) => item.transaction.id);
+    getAllocatedAmount(allocations) {
+        return allocations.getByTransactionsIds(this.getIds()).sumBy('amount');
     }
 }
-SoleInvoice.NUMBER_LENGTH = 4;
-__decorate([
-    Type(() => Date)
-], SoleInvoice.prototype, "dateFrom", void 0);
-__decorate([
-    Type(() => Date)
-], SoleInvoice.prototype, "dateTo", void 0);
-__decorate([
-    Type(() => User)
-], SoleInvoice.prototype, "user", void 0);
-__decorate([
-    Type(() => SoleBusiness)
-], SoleInvoice.prototype, "business", void 0);
-__decorate([
-    Type(() => SoleInvoiceItem)
-], SoleInvoice.prototype, "items", void 0);
-__decorate([
-    Type(() => SoleContact)
-], SoleInvoice.prototype, "payer", void 0);
-__decorate([
-    Type(() => SoleInvoiceTemplate)
-], SoleInvoice.prototype, "template", void 0);
-__decorate([
-    Type(() => BankAccount)
-], SoleInvoice.prototype, "bankAccount", void 0);
 
-/**
- * Class contains traveled kilometers and work usage percent in 12 weeks date range
- * @TODO Vik: Best period: move this and related logic to backend
- * @TODO Alex: check if we need this class when calculation refactored with backend
- */
-class LogbookPeriod {
-    isEndOfYear() {
-        return this.to === new FinancialYear().endDate;
-    }
-    getWorkUsageByClaim(claim) {
-        const claimKilometers = this.logbooks.getByVehicleClaim(claim).getClaimableLogbooks().kilometers;
-        return Math.round(this.workUsage * (claimKilometers / this.kilometers));
+class TransactionAllocationCollection extends Collection {
+    get amount() {
+        return this.sumBy('amount');
     }
-}
-__decorate([
-    Type(() => Date)
-], LogbookPeriod.prototype, "from", void 0);
-__decorate([
-    Type(() => Date)
-], LogbookPeriod.prototype, "to", void 0);
-
-class Vehicle$1 extends AbstractModel {
-}
-
-class VehicleLogbook$1 extends AbstractModel {
-}
-
-// problem with DateRange and typescript. See more https://github.com/rotaready/moment-range/issues/263
-const moment = extendMoment(moment$1);
-class VehicleLogbook extends VehicleLogbook$1 {
-    get kilometers() {
-        return this.odometerEnd - this.odometerStart;
+    getByTransactionsIds(ids) {
+        return new TransactionAllocationCollection(this.items.filter((allocation) => ids.includes(allocation.transaction.id)));
     }
-    get tankType() {
-        return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
+    getByBankTransactionsIds(ids) {
+        return new TransactionAllocationCollection(this.items.filter((allocation) => ids.includes(allocation.bankTransaction.id)));
     }
-    isWorkTank() {
-        return !this.business;
+    /**
+     * Group allocations by bank account via bank transactions collection
+     */
+    groupByBankAccount(bankTransactions) {
+        // Group bank transactions by bank account id
+        const bankTransactionsByBankAccount = new CollectionDictionary(bankTransactions, 'bankAccount.id');
+        // Create empty dictionary of transaction allocations
+        const allocationsByBankAccount = new CollectionDictionary(new TransactionAllocationCollection([]));
+        // Fill allocations dictionary with bank transactions dictionary keys and allocations related with each bank transaction collection
+        bankTransactionsByBankAccount.keys.forEach((key) => {
+            allocationsByBankAccount.add(key, this.getByBankTransactionsIds(bankTransactionsByBankAccount.get(key).getIds()));
+        });
+        return allocationsByBankAccount;
     }
-    isSoleTank() {
-        return !!this.business;
+    /**
+     * check if collection includes allocation of passed transaction
+     */
+    hasTransaction(transaction) {
+        return !!this.items.find((allocation) => allocation.transaction.id === transaction.id);
     }
     /**
-     * Get logbook period date range from logbook date and weeksInPeriod duration
+     * Check if bank transaction is related with current allocations
      */
-    getPeriod() {
-        return moment.rangeFromInterval('milliseconds', VehicleLogbook.bestPeriodDuration, this.date);
+    hasBankTransaction(bankTransaction) {
+        return !!this.items.find((allocation) => allocation.bankTransaction.id === bankTransaction.id);
     }
 }
-/**
- * Logbook period duration in milliseconds.
- * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/211517441/Logbook+Vehicle
- */
-VehicleLogbook.bestPeriodDuration = 12 * 7 * 24 * 3600 * 1000;
-__decorate([
-    Type(() => Date)
-], VehicleLogbook.prototype, "date", void 0);
-__decorate([
-    Type(() => SoleBusiness)
-], VehicleLogbook.prototype, "business", void 0);
 
-class Vehicle extends Vehicle$1 {
+class Depreciation$1 extends TransactionBase {
+}
+
+class DepreciationCapitalProject$1 extends AbstractModel {
+}
+
+class DepreciationCapitalProject extends DepreciationCapitalProject$1 {
 }
 __decorate([
-    Type(() => VehicleLogbook)
-], Vehicle.prototype, "logbook", void 0);
+    Type(() => Date)
+], DepreciationCapitalProject.prototype, "effectiveDate", void 0);
 
-class VehicleClaim$1 extends AbstractModel {
+class DepreciationForecast$1 extends AbstractModel {
 }
 
-class VehicleClaimDetails$1 extends AbstractModel {
+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');
+    }
+    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;
+    }
 }
 
-var VehicleClaimDetailsMethodEnum;
-(function (VehicleClaimDetailsMethodEnum) {
-    VehicleClaimDetailsMethodEnum[VehicleClaimDetailsMethodEnum["KMS"] = 1] = "KMS";
-    VehicleClaimDetailsMethodEnum[VehicleClaimDetailsMethodEnum["LOGBOOK"] = 2] = "LOGBOOK";
-})(VehicleClaimDetailsMethodEnum || (VehicleClaimDetailsMethodEnum = {}));
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+var IncomeAmountTypeEnum;
+(function (IncomeAmountTypeEnum) {
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["NET"] = 0] = "NET";
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["GROSS"] = 1] = "GROSS";
+})(IncomeAmountTypeEnum || (IncomeAmountTypeEnum = {}));
 
-class VehicleClaimDetails extends VehicleClaimDetails$1 {
+var TransactionCategoryEnum;
+(function (TransactionCategoryEnum) {
+    TransactionCategoryEnum[TransactionCategoryEnum["PROPERTY"] = 0] = "PROPERTY";
+    TransactionCategoryEnum[TransactionCategoryEnum["WORK"] = 1] = "WORK";
+    TransactionCategoryEnum[TransactionCategoryEnum["SOLE"] = 2] = "SOLE";
+    TransactionCategoryEnum[TransactionCategoryEnum["PERSONAL"] = 3] = "PERSONAL";
+})(TransactionCategoryEnum || (TransactionCategoryEnum = {}));
+
+/**
+ * @TODO Alex: clarify grouping rules and refactor
+ */
+class Depreciation extends Depreciation$1 {
     constructor() {
         super(...arguments);
+        this.forecasts = [];
+        this.type = DepreciationTypeEnum.PLANT_EQUIPMENT;
         /**
-         * Init default values for the new instances
+         * @TODO remove after ? signs removed from db models
          */
-        this.isManual = true;
-        this.method = VehicleClaimDetailsMethodEnum.KMS;
-        this.financialYear = new FinancialYear().year;
+        this.amount = 0;
     }
-    isLogbookMethod() {
-        return this.method === VehicleClaimDetailsMethodEnum.LOGBOOK;
+    // Type checking
+    isCapital() {
+        return this.type === DepreciationTypeEnum.CAPITAL_WORKS;
     }
-    isKmsMethod() {
-        return this.method === VehicleClaimDetailsMethodEnum.KMS;
+    isBorrowingExpense() {
+        return this.type === DepreciationTypeEnum.BORROWING_EXPENSES;
     }
-}
-__decorate([
-    Type(() => User)
-], VehicleClaimDetails.prototype, "user", void 0);
-
-class VehicleClaim extends VehicleClaim$1 {
-    constructor() {
-        super(...arguments);
-        this.kilometers = 0;
-        this.workUsage = 0;
+    isAsset() {
+        return this.type === DepreciationTypeEnum.PLANT_EQUIPMENT;
     }
-    isWorkTank() {
-        return !this.business;
+    // Calculation checking
+    isSBPCalculation() {
+        return this.calculation === DepreciationCalculationEnum.SBP;
     }
-    isSoleTank() {
-        return !!this.business;
+    isPrimeCost() {
+        return this.calculation === DepreciationCalculationEnum.PRIME_COST;
     }
-    get tankType() {
-        return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
+    isDiminishing() {
+        return this.calculation === DepreciationCalculationEnum.DIMINISHING;
+    }
+    // Pool checking
+    isPlantEquipmentPool() {
+        return this.isAsset() && !this.isSBPCalculation() && !this.isWrittenOff() && !this.isLVP();
+    }
+    isLVP() {
+        return this.isAsset()
+            && !this.isSBPCalculation()
+            && this.isDiminishing()
+            && this.currentYearForecast.closeBalance > Depreciation.WRITTEN_OFF_THRESHOLD
+            && this.currentYearForecast.closeBalance <= Depreciation.LOW_VALUE_POOL_THRESHOLD;
+    }
+    isSBP() {
+        return this.isAsset() && this.isSBPCalculation() && !this.isWrittenOff();
+    }
+    isWrittenOff() {
+        return this.writeOffYear === new FinancialYear().year;
+    }
+    get writeOffYear() {
+        var _a;
+        if (!this.writeOffManualDate && !this.writeOffDate) {
+            return null;
+        }
+        return (_a = new FinancialYear(this.writeOffManualDate || this.writeOffDate)) === null || _a === void 0 ? void 0 : _a.year;
     }
     /**
-     * Claim amount for KMs method. Exists only for KMs method.
+     * Check if depreciation chart accounts heading related to vehicles category
      */
-    getKMSClaimAmount(vehicleClaimRate) {
-        return +(this.kilometers * vehicleClaimRate).toFixed(2);
+    isVehicleDepreciation() {
+        var _a;
+        return ((_a = this.chartAccounts.heading) === null || _a === void 0 ? void 0 : _a.id) === ChartAccountsHeadingVehicleListEnum.DEPRECIATION_VEHICLES;
     }
     /**
-     * Get logbook claim amount. Exists only for logbook method.
-     * ClaimAmount = WorkUsage * transaction/depreciation amount
+     * Get depreciation purchase date
      */
-    getLogbookClaimAmount(transactions) {
-        const transactionsAmount = transactions
-            .getByVehicleClaim(this)
-            .getLogbookTransactions()
-            .sumBy('amount');
-        // Math.abs because amount will be negative (because we sum expenses), but we don't want negative percent value
-        return Math.abs(transactionsAmount) * this.workUsage / 100;
-    }
-    getAverageWeeklyKMS() {
-        return this.kilometers / FinancialYear.weeksInYear;
-    }
-    static getKMSChartAccountsIdByTankType(tankType) {
-        return tankType === TankTypeEnum.WORK
-            ? ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK
-            : ChartAccountsListEnum.KLMS_TRAVELLED;
+    getDate() {
+        return this.date;
     }
-}
-/**
- * limit for kms claim method
- */
-VehicleClaim.totalKmsLimit = 5000;
-/**
- * limit for work usage claim method
-  */
-VehicleClaim.totalWorkUsagePercent = 100;
-__decorate([
-    Type(() => VehicleClaimDetails)
-], VehicleClaim.prototype, "details", void 0);
-__decorate([
-    Type(() => SoleBusiness)
-], VehicleClaim.prototype, "business", void 0);
-
-class SoleBusinessActivity$1 extends AbstractModel {
-}
-
-class SoleBusiness extends SoleBusiness$1 {
-    getPhotoPlaceholder() {
-        return `${this.name[0]}${this.name[1]}`;
-    }
-    getPhoto() {
-        return this.logo;
+    /**
+     * @TODO Vik: Research a problem with depreciations without current year forecast
+     */
+    get currentYearForecast() {
+        return this.forecasts.find((forecast) => {
+            return forecast.financialYear === new FinancialYear().year;
+        }) || plainToClass(DepreciationForecast, {
+            financialYear: new FinancialYear().year,
+            openBalance: 0,
+            closeBalance: 0,
+            amount: 0,
+            claimPercent: 0
+        });
     }
-}
-/**
- * Maximum number of businesses that a person can have, according to the ATO
- */
-SoleBusiness.businessesLimit = 6;
-__decorate([
-    Type(() => User)
-], SoleBusiness.prototype, "user", void 0);
-__decorate([
-    Type(() => SoleBusinessAllocation)
-], SoleBusiness.prototype, "allocations", void 0);
-__decorate([
-    Type(() => SoleBusinessLoss)
-], SoleBusiness.prototype, "losses", void 0);
-__decorate([
-    Type(() => SoleInvoice)
-], SoleBusiness.prototype, "invoices", void 0);
-__decorate([
-    Type(() => SoleInvoiceTemplate)
-], SoleBusiness.prototype, "invoiceTemplates", void 0);
-__decorate([
-    Type(() => VehicleClaim)
-], SoleBusiness.prototype, "vehicleClaims", void 0);
-__decorate([
-    Type(() => Transaction)
-], SoleBusiness.prototype, "transactions", void 0);
-__decorate([
-    Type(() => Depreciation)
-], SoleBusiness.prototype, "depreciations", void 0);
-__decorate([
-    Type(() => SoleBusinessActivity$1)
-], SoleBusiness.prototype, "activity", void 0);
-__decorate([
-    Type(() => IncomeSource)
-], SoleBusiness.prototype, "incomeSource", void 0);
-
-class SoleBusinessActivity extends SoleBusinessActivity$1 {
-}
-
-class SoleDepreciationMethod$1 extends AbstractModel {
-}
-
-var SoleDepreciationMethodEnum;
-(function (SoleDepreciationMethodEnum) {
-    SoleDepreciationMethodEnum[SoleDepreciationMethodEnum["SBP"] = 1] = "SBP";
-    SoleDepreciationMethodEnum[SoleDepreciationMethodEnum["DEPRECIATION"] = 2] = "DEPRECIATION";
-})(SoleDepreciationMethodEnum || (SoleDepreciationMethodEnum = {}));
-
-class SoleDepreciationMethod extends SoleDepreciationMethod$1 {
-    isSBP() {
-        return this.method === SoleDepreciationMethodEnum.SBP;
+    getForecastByYear(year) {
+        return this.forecasts.find((forecast) => {
+            return forecast.financialYear === year;
+        });
     }
-}
-
-class SoleDetails$1 extends AbstractModel {
-}
-
-class SoleDetails extends SoleDetails$1 {
-}
-__decorate([
-    Type(() => User)
-], SoleDetails.prototype, "user", void 0);
-
-class BasReport$1 extends AbstractModel {
-}
-
-class BasReport extends BasReport$1 {
-    get taxWithheldTotal() {
-        return this.taxWithheldSalary + this.taxWithheldNoABN;
+    getClaimAmountByYear(year) {
+        var _a;
+        return ((_a = this.getForecastByYear(year)) === null || _a === void 0 ? void 0 : _a.claimAmount) || 0;
     }
-    get paygTaxInstalmentOwedToATO() {
-        return this.paygTaxInstalment > 0 ? this.paygTaxInstalment : 0;
+    getCloseBalanceByYear(year) {
+        var _a;
+        return ((_a = this.getForecastByYear(year)) === null || _a === void 0 ? void 0 : _a.closeBalance) || 0;
     }
-    get paygTaxInstalmentOwedByATO() {
-        return this.paygTaxInstalment < 0 ? Math.abs(this.paygTaxInstalment) : 0;
+    isBuildingAtCost() {
+        return this.chartAccounts.id === ChartAccountsListEnum.BUILDING_AT_COST;
     }
-    get fuelTaxCreditOwedToATO() {
-        return this.fuelTaxCredit < 0 ? this.fuelTaxCredit : 0;
+    /**
+     * Create a new transaction from current depreciation
+     */
+    toTransaction(params = {}) {
+        var _a, _b;
+        return plainToClass(Transaction, Object.assign(params, this, {
+            amount: -((_a = this.currentYearForecast) === null || _a === void 0 ? void 0 : _a.amount) || 0,
+            claimAmount: -((_b = this.currentYearForecast) === null || _b === void 0 ? void 0 : _b.claimAmount) || 0,
+        }));
     }
-    get fuelTaxCreditOwedByATO() {
-        return this.fuelTaxCredit > 0 ? Math.abs(this.fuelTaxCredit) : 0;
+    /**
+     * @TODO Michael: remove and check everywhere in reports
+     */
+    get claimAmount() {
+        var _a;
+        return ((_a = this.currentYearForecast) === null || _a === void 0 ? void 0 : _a.claimAmount) || 0;
     }
-    get owesToATO() {
-        return this.incomeGST + this.taxWithheldTotal + this.paygTaxInstalmentOwedToATO + this.fuelTaxCreditOwedToATO;
+    get amountWithGst() {
+        // gst applies only to new assets
+        if (this.isNew()) {
+            return super.amountWithGst;
+        }
+        return this.amount;
     }
-    get owedByATO() {
-        return this.expenseGST + this.paygTaxInstalmentOwedByATO + this.fuelTaxCreditOwedByATO;
+    get gstClaimAmount() {
+        var _a;
+        return this.gstAmount * ((_a = this.currentYearForecast) === null || _a === void 0 ? void 0 : _a.claimRate);
     }
     /**
-     * GST payable to the ATO, or refundable from the ATO in case it's negative
+     * assets purchased in the current financial year
      */
-    get gst() {
-        return this.incomeGST + this.expenseGST + this.taxWithheldTotal + this.paygTaxInstalment - this.fuelTaxCredit;
+    isNew() {
+        return new FinancialYear(this.date).year === new FinancialYear().year;
     }
 }
+Depreciation.WRITTEN_OFF_THRESHOLD = 300;
+Depreciation.LOW_VALUE_POOL_THRESHOLD = 1000;
 __decorate([
     Type(() => Date)
-], BasReport.prototype, "dateFrom", void 0);
+], Depreciation.prototype, "purchaseDate", void 0);
 __decorate([
     Type(() => Date)
-], BasReport.prototype, "dateTo", void 0);
-
-/**
- * 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],
-};
+], Depreciation.prototype, "date", void 0);
+__decorate([
+    Type(() => Date)
+], Depreciation.prototype, "lowValuePoolDate", void 0);
+__decorate([
+    Type(() => Date)
+], Depreciation.prototype, "writeOffManualDate", void 0);
+__decorate([
+    Type(() => Date)
+], Depreciation.prototype, "writeOffDate", void 0);
+__decorate([
+    Type(() => DepreciationCapitalProject)
+], Depreciation.prototype, "depreciationCapitalProject", void 0);
+__decorate([
+    Type(() => DepreciationForecast),
+    Transform(({ value, obj }) => {
+        // value = array of DepreciationForecast
+        // obj = plain (whole Depreciation object)
+        // Set isLVP flag for each DepreciationForecast
+        // @TODO refactor
+        value.forEach((forecast) => {
+            forecast.isLVP =
+                forecast.closeBalance < 1000 &&
+                    obj.calculation === DepreciationCalculationEnum.DIMINISHING &&
+                    obj.type === DepreciationTypeEnum.PLANT_EQUIPMENT &&
+                    !(obj.amount > Depreciation.WRITTEN_OFF_THRESHOLD && obj.amount < Depreciation.LOW_VALUE_POOL_THRESHOLD) &&
+                    !(obj.writeOffDate && new FinancialYear(new Date(obj.writeOffDate)).year === obj.financialYear);
+        });
+        return value;
+    })
+], Depreciation.prototype, "forecasts", void 0);
+__decorate([
+    Type(() => ChartAccounts)
+], Depreciation.prototype, "chartAccounts", void 0);
+__decorate([
+    Type(() => BankTransaction)
+], Depreciation.prototype, "bankTransaction", void 0);
+__decorate([
+    Exclude()
+], Depreciation.prototype, "amountWithGst", null);
+__decorate([
+    Exclude()
+], Depreciation.prototype, "gstClaimAmount", null);
 
-class User extends User$1 {
-    get fullName() {
-        return `${this.firstName} ${this.lastName}`;
-    }
-    get activeSubscription() {
-        return this.subscriptions.find((ss) => ss.isActive);
-    }
-    get lastSubscription() {
-        return this.subscriptions[this.subscriptions.length - 1];
-    }
-    /**
-     * @TODO refactor
-     *
-     */
-    get position() {
-        switch (true) {
-            case this.isFirmOwner():
-                return USER_WORK_POSITION[UserRolesEnum.FIRM_OWNER];
-            case this.isManager():
-                return USER_WORK_POSITION[UserRolesEnum.FIRM_MANAGER];
-            case this.isEmployee():
-                return USER_WORK_POSITION[UserRolesEnum.EMPLOYEE];
-            default:
-                return '';
-        }
-    }
-    /**
-     * search roles including hierarchy
-     */
-    hasRoles(roles) {
-        roles = roles instanceof Array ? roles : [roles];
-        if (!roles.length) {
-            return true;
-        }
-        roles = flatten(roles.map((role) => USER_ROLES[role]));
-        return !!intersection(this.roles, roles).length;
-    }
-    isOnboarding() {
-        return this.status === UserStatusEnum.ON_BOARDING;
-    }
-    hasSubscription() {
-        return this.roles.includes(UserRolesEnum.SUBSCRIPTION);
-    }
-    isLoggedIn() {
-        return this.id === +localStorage.getItem('userId');
-    }
-    isClient() {
-        return this.roles.includes(UserRolesEnum.CLIENT);
+/**
+ * used to combine transactions/depreciations
+ */
+class TransactionBaseCollection extends Collection {
+    getClaimAmountByBusinessId(businessId) {
+        return +this.filterBy('business.id', businessId).items.map((transaction) => transaction instanceof Depreciation ? -transaction.claimAmount : transaction['claimAmount']).reduce((sum, claimAmount) => sum + claimAmount, 0).toFixed(2);
     }
-    isEmployee() {
-        return this.isAccountant() || this.isAdvisor();
+    getSoleTransactions() {
+        return this.filter((transaction) => transaction.isSoleTank());
     }
-    isAccountant() {
-        return this.roles.includes(UserRolesEnum.ACCOUNTANT);
+}
+
+// @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 {
+    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;
     }
-    isAdvisor() {
-        return this.roles.includes(UserRolesEnum.ADVISOR);
+    isDebit() {
+        return this.type === TransactionTypeEnum.DEBIT;
     }
-    isImpersonator() {
-        return this.roles.includes(UserRolesEnum.SWITCH_USER);
+    isCredit() {
+        return this.type === TransactionTypeEnum.CREDIT;
     }
     /**
-     * Check if current user is firm owner
+     * @TODO move to base collection
      */
-    isFirmOwner() {
-        return this.roles.includes(UserRolesEnum.FIRM_OWNER);
+    isIncome() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isCredit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
     }
     /**
-     * Check if current user is firm manager
+     * @TODO move to base collection
      */
-    isManager() {
-        return this.roles.includes(UserRolesEnum.FIRM_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);
+    isExpense() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isDebit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
     }
-    /**
-     * check if user has property tank access
-     */
-    hasPropertyTank() {
-        return this.roles ?
-            this.roles.includes(UserRolesEnum.PROPERTY_TANK) :
-            !!this.getSubscriptionRole(UserRolesEnum.PROPERTY_TANK);
+    isPersonal() {
+        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
     }
-    /**
-     * check if user has property tank access
-     */
-    hasWorkTank() {
-        return this.roles ?
-            this.roles.includes(UserRolesEnum.WORK_TANK) :
-            !!this.getSubscriptionRole(UserRolesEnum.WORK_TANK);
+    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;
+        }
     }
     /**
-     * Get user subscription role by provided role type
-     * @param roleType by which role should be returned
+     * Check if transaction has 'Kms travelled for work' chart accounts category
      */
-    getSubscriptionRole(roleType) {
-        var _a;
-        /**
-         * Add @TODO for Alex to check if we should use getLastSubscription here
-         */
-        return (_a = this.activeSubscription) === null || _a === void 0 ? void 0 : _a.items.find((subscriptionItem) => subscriptionItem.price.product.role.includes(roleType));
+    get isKmsChartAccountsCategory() {
+        return this.chartAccounts.id === ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK;
     }
     /**
-     * Get user's photo link
+     * Get transaction date
      */
-    getPhoto() {
-        return this.photo;
+    getDate() {
+        return this.date;
     }
     /**
-     * get user's initials
+     * Check if transaction type is vehicle
      */
-    getPhotoPlaceholder() {
-        return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
+    isVehicleTransaction() {
+        return this.chartAccounts.isVehicleExpense();
     }
-}
-__decorate([
-    Type(() => ServiceSubscription)
-], User.prototype, "subscriptions", void 0);
-__decorate([
-    Type(() => ClientDetails)
-], User.prototype, "clientDetails", void 0);
-__decorate([
-    Type(() => EmployeeDetails)
-], User.prototype, "employeeDetails", void 0);
-__decorate([
-    Type(() => SoleDetails)
-], User.prototype, "soleDetails", void 0);
-__decorate([
-    Type(() => Address)
-], User.prototype, "address", void 0);
-__decorate([
-    Type(() => Phone)
-], User.prototype, "phone", void 0);
-__decorate([
-    Type(() => Date)
-], User.prototype, "createdAt", void 0);
-__decorate([
-    Type(() => User)
-], User.prototype, "clients", void 0);
-
-class PropertySubscription extends PropertySubscription$1 {
-}
-__decorate([
-    Type(() => Date)
-], PropertySubscription.prototype, "createdAt", void 0);
-__decorate([
-    Type(() => User)
-], PropertySubscription.prototype, "user", void 0);
-
-class PropertyCategory$1 extends AbstractModel {
-}
-
-var PropertyCategoryListEnum;
-(function (PropertyCategoryListEnum) {
-    PropertyCategoryListEnum[PropertyCategoryListEnum["OWNER_OCCUPIED"] = 3] = "OWNER_OCCUPIED";
-    PropertyCategoryListEnum[PropertyCategoryListEnum["SHARED"] = 4] = "SHARED";
-    PropertyCategoryListEnum[PropertyCategoryListEnum["VACANT_LAND"] = 5] = "VACANT_LAND";
-})(PropertyCategoryListEnum || (PropertyCategoryListEnum = {}));
-
-class PropertyCategory extends PropertyCategory$1 {
-    // @Todo check if category is Owner Occupied. If will be needed to check more categories - move the checking to the backend
-    isOwnerOccupied() {
-        return this.id === PropertyCategoryListEnum.OWNER_OCCUPIED;
+    get taxFreeComponent() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.TAX_FREE_COMPONENT);
     }
-    isVacantLand() {
-        return this.id === PropertyCategoryListEnum.VACANT_LAND;
+    get frankingCredit() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.FRANKING_CREDIT);
     }
-    isShared() {
-        return this.id === PropertyCategoryListEnum.SHARED;
+    get eligibleForReduction() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.ELIGIBLE_FOR_REDUCTION);
     }
-}
-
-class PropertyValuation$1 extends AbstractModel {
-}
-
-class PropertyDocument$1 extends AbstractModel {
-    getApiUrlPrefix() {
-        return '';
+    get untaxedElement() {
+        return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.UNTAXED_ELEMENT);
     }
-    getEntity() {
-        return undefined;
+    /**
+     * Check if transaction reconcile operation if TRANSFER
+     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+     */
+    get isTransfer() {
+        return this.operation === TransactionOperationEnum.TRANSFER;
     }
-}
-
-class PropertyDocument extends PropertyDocument$1 {
-    constructor() {
-        super(...arguments);
-        this.type = AssetTypeEnum.DOCUMENT;
-        this.entityType = AssetEntityTypeEnum.PROPERTIES;
+    isFindAndMatch() {
+        return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
     }
-    getApiUrlPrefix() {
-        return '';
+    isMatchInvoice() {
+        return this.operation === TransactionOperationEnum.MATCH_INVOICE;
     }
-    getEntity() {
-        return this.property;
+    get debit() {
+        return this.isDebit() ? Math.abs(this.grossAmount) : 0;
     }
-}
-
-class PropertyValuation extends PropertyValuation$1 {
-    get financialYear() {
-        return new FinancialYear(this.date).year;
+    get credit() {
+        return this.isCredit() ? Math.abs(this.grossAmount) : 0;
     }
-    isCurrentYear() {
-        return this.financialYear === new FinancialYear(new Date()).year;
+    /**
+     * Get value of transaction metadata field
+     * @param field for which value should be returned
+     * @Todo modify 'metadata' property from array 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;
     }
-}
-__decorate([
-    Type(() => Date)
-], PropertyValuation.prototype, "date", void 0);
-__decorate([
-    Type(() => PropertyDocument)
-], PropertyValuation.prototype, "document", void 0);
-__decorate([
-    Exclude()
-], PropertyValuation.prototype, "documentFile", void 0);
-
-class PropertyForecast$1 extends AbstractModel {
-}
-
-class PropertyForecast extends PropertyForecast$1 {
-    constructor() {
-        super(...arguments);
-        this.financialYear = new FinancialYear(new Date()).year;
+    isCash() {
+        return this.source === TransactionSourceEnum.CASH;
     }
     /**
-     * Get cash position
-     * Cash Position = Income - Expense - Interest
+     * Create Depreciation instance based on Transaction
      */
-    get cashPosition() {
-        return this.income + this.expense + this.interest;
+    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 tax position
-     * Tax Position = Income - Expense - Interest - Depreciation
+     * Check if transaction is completely allocated
      */
-    get taxPosition() {
-        return this.cashPosition + this.depreciation;
+    isAllocated(allocations) {
+        return this.grossAmount === this.getAllocatedAmount(allocations);
+    }
+    getAllocatedAmount(allocations) {
+        return allocations.filterBy('transaction.id', this.id).sumBy('amount');
+    }
+    getAllocatedClaimAmount(allocations) {
+        return this.getAllocatedAmount(allocations) * this.claimRatio;
+    }
+    getUnallocatedAmount(allocations) {
+        return this.netAmount - this.getAllocatedAmount(allocations);
     }
     /**
-     * Get rental return percent
-     * Rental Return = Income / Market Value
+     * Total transaction amount including taxes and other additional amounts
      */
-    get rentalReturn() {
-        return this.income / this.marketValue;
+    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');
+        if (this.isWorkTank()) {
+            grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;
+        }
+        return +(Math.round(grossAmount * 100) / 100).toFixed(2);
     }
     /**
-     * Check if forecast is for real current fin year (not selected in the sidebar)
+     * 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$
      */
-    isCurrentYear() {
-        return this.financialYear === new FinancialYear(new Date()).year;
+    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;
     }
 }
 __decorate([
-    Transform(({ value }) => +value)
-], PropertyForecast.prototype, "income", void 0);
+    Type(() => Transaction)
+], Transaction.prototype, "transactions", void 0);
 __decorate([
-    Transform(({ value }) => -Math.abs(+value))
-], PropertyForecast.prototype, "expense", void 0);
+    Type(() => Property)
+], Transaction.prototype, "property", void 0);
 __decorate([
-    Transform(({ value }) => -Math.abs(+value))
-], PropertyForecast.prototype, "interest", void 0);
+    Type(() => TransactionReceipt)
+], Transaction.prototype, "receipt", void 0);
 __decorate([
-    Transform(({ value }) => -Math.abs(+value))
-], PropertyForecast.prototype, "depreciation", void 0);
+    Type(() => ChartAccounts)
+], Transaction.prototype, "chartAccounts", void 0);
 __decorate([
-    Transform(({ value }) => +value)
-], PropertyForecast.prototype, "loanBalance", void 0);
+    Type(() => IncomeSource)
+], Transaction.prototype, "incomeSource", void 0);
 __decorate([
-    Transform(({ value }) => +value)
-], PropertyForecast.prototype, "marketValue", void 0);
+    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);
 
-class PropertyCategoryMovement$1 extends AbstractModel {
+class SoleInvoiceItem extends SoleInvoiceItem$1 {
+    constructor() {
+        super(...arguments);
+        this.isGST = false;
+    }
+    get totalPrice() {
+        return this.price * this.quantity;
+    }
 }
+__decorate([
+    Type(() => SoleInvoice)
+], SoleInvoiceItem.prototype, "invoice", void 0);
+__decorate([
+    Type(() => ChartAccounts)
+], SoleInvoiceItem.prototype, "chartAccounts", void 0);
+__decorate([
+    Type(() => Transaction)
+], SoleInvoiceItem.prototype, "transaction", void 0);
 
-class PropertyCategoryMovement extends PropertyCategoryMovement$1 {
+class SoleContact$1 extends AbstractModel {
+}
+
+// @TODO Alex/Vik: Create some base class for User and SoleContact with common methods and properties
+class SoleContact extends SoleContact$1 {
+    get fullName() {
+        return `${this.firstName} ${this.lastName}`;
+    }
+    getPhotoPlaceholder() {
+        return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
+    }
+    // @TODO Vik: add photo field to SoleContact
+    getPhoto() {
+        return '';
+    }
 }
 __decorate([
-    Type(() => PropertyValuation)
-], PropertyCategoryMovement.prototype, "valuation", void 0);
+    Type(() => User)
+], SoleContact.prototype, "user", void 0);
 __decorate([
-    Type(() => PropertyCategory)
-], PropertyCategoryMovement.prototype, "propertyCategory", void 0);
+    Type(() => Phone)
+], SoleContact.prototype, "phone", void 0);
 __decorate([
-    Type(() => Date)
-], PropertyCategoryMovement.prototype, "fromDate", void 0);
+    Type(() => Address)
+], SoleContact.prototype, "address", void 0);
 __decorate([
-    Type(() => Date)
-], PropertyCategoryMovement.prototype, "toDate", void 0);
+    Type(() => SoleInvoice)
+], SoleContact.prototype, "invoices", void 0);
 
-var TaxExemptionEnum;
-(function (TaxExemptionEnum) {
-    TaxExemptionEnum[TaxExemptionEnum["ONE_YEAR_RULE"] = 1] = "ONE_YEAR_RULE";
-    // principle place of residence
-    TaxExemptionEnum[TaxExemptionEnum["PPR"] = 2] = "PPR";
-    TaxExemptionEnum[TaxExemptionEnum["SIX_YEARS_RULE"] = 3] = "SIX_YEARS_RULE";
-    TaxExemptionEnum[TaxExemptionEnum["INVESTMENT_TO_PPR"] = 4] = "INVESTMENT_TO_PPR";
-    TaxExemptionEnum[TaxExemptionEnum["PPR_TO_INVESTMENT"] = 5] = "PPR_TO_INVESTMENT";
-    TaxExemptionEnum[TaxExemptionEnum["TRANSFER"] = 6] = "TRANSFER";
-    TaxExemptionEnum[TaxExemptionEnum["OTHER"] = 7] = "OTHER";
-})(TaxExemptionEnum || (TaxExemptionEnum = {}));
+class SoleInvoiceTemplate$1 extends AbstractModel {
+}
 
-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 = {}));
+var SoleInvoiceTemplateTaxTypeEnum;
+(function (SoleInvoiceTemplateTaxTypeEnum) {
+    SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["TAX_EXCLUSIVE"] = 0] = "TAX_EXCLUSIVE";
+    SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["TAX_INCLUSIVE"] = 1] = "TAX_INCLUSIVE";
+    SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["NO_TAX"] = 2] = "NO_TAX";
+})(SoleInvoiceTemplateTaxTypeEnum || (SoleInvoiceTemplateTaxTypeEnum = {}));
 
-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;
+class SoleInvoiceTemplate extends SoleInvoiceTemplate$1 {
+    constructor() {
+        super(...arguments);
+        /**
+         * Affects to SoleInvoiceItem.isGST flag availability.
+         * When NONE: isGST is unavailable
+         * When EXCLUSIVE: GST amount added additionaly to invoice total price
+         * When INCLUSIVE: GST amount is already included to invoice total price
+         */
+        this.taxType = SoleInvoiceTemplateTaxTypeEnum.NO_TAX;
     }
-    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;
+    /**
+     * Get term duration in milliseconds
+     */
+    get termTime() {
+        return this.term * 24 * 3600 * 1000;
     }
-    getByMetadataId(id) {
-        return this.items.find((metadata) => metadata.metadata.id === id);
+}
+__decorate([
+    Type(() => SoleBusiness)
+], SoleInvoiceTemplate.prototype, "business", void 0);
+__decorate([
+    Type(() => BankAccount)
+], SoleInvoiceTemplate.prototype, "bankAccount", void 0);
+
+var SoleInvoiceStatusesEnum;
+(function (SoleInvoiceStatusesEnum) {
+    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["CANCELED"] = 0] = "CANCELED";
+    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["DRAFT"] = 1] = "DRAFT";
+    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["PENDING"] = 2] = "PENDING";
+    SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["PAID"] = 3] = "PAID";
+})(SoleInvoiceStatusesEnum || (SoleInvoiceStatusesEnum = {}));
+
+var SoleInvoiceTaxTypeEnum;
+(function (SoleInvoiceTaxTypeEnum) {
+    SoleInvoiceTaxTypeEnum[SoleInvoiceTaxTypeEnum["TAX_EXCLUSIVE"] = 0] = "TAX_EXCLUSIVE";
+    SoleInvoiceTaxTypeEnum[SoleInvoiceTaxTypeEnum["TAX_INCLUSIVE"] = 1] = "TAX_INCLUSIVE";
+    SoleInvoiceTaxTypeEnum[SoleInvoiceTaxTypeEnum["NO_TAX"] = 2] = "NO_TAX";
+})(SoleInvoiceTaxTypeEnum || (SoleInvoiceTaxTypeEnum = {}));
+
+class SoleInvoiceItemCollection extends Collection {
+    get gstPrice() {
+        return this.filterBy('isGST', true).sumBy('totalPrice');
     }
 }
 
-class PropertySaleCollection extends Collection {
-    get grossCGT() {
-        return this.create(this.items.filter((propertySale) => propertySale.grossCGT > 0)).sumBy('grossCGT');
+class SoleInvoice extends SoleInvoice$1 {
+    constructor() {
+        super(...arguments);
+        this.status = SoleInvoiceStatusesEnum.DRAFT;
+        this.taxType = SoleInvoiceTaxTypeEnum.NO_TAX;
     }
     /**
-     * Property sales are CGT applicable unless it has "Principle place of residence" exemption type
+     * Get items array as collection
      */
-    getCGTApplicable() {
-        return this.create(this.items.filter((propertySale) => propertySale.isCGTApplicable()));
+    get itemsCollection() {
+        return new SoleInvoiceItemCollection(this.items);
     }
-    getByPropertyShareIds(ids) {
-        return this.filterBy('share.id', ids);
+    /**
+     * Total price of all items
+     */
+    get price() {
+        return this.itemsCollection.sumBy('totalPrice');
     }
-}
-
-class PropertyCollection extends Collection {
     /**
-     * Get new property collection filtered by category id
-     * @param id id of category for filter
+     * Total invoice price without GST
      */
-    getByCategoryId(id) {
-        return new PropertyCollection(this.items.filter((property) => property.category.id === id));
+    get netPrice() {
+        if (this.isTaxInclusive()) {
+            return this.price - this.GSTAmount;
+        }
+        return this.price;
     }
     /**
-     * Get new property collection filtered by active status
+     * Total final price (net + GST)
      */
-    getActiveProperties() {
-        return new PropertyCollection(this.items.filter((property) => property.isActive));
+    get grossPrice() {
+        if (this.isTaxExclusive()) {
+            return this.price + this.GSTAmount;
+        }
+        return this.price;
     }
-    getCreatedProperties() {
-        return new PropertyCollection(this.items.filter((property) => property.isOwn()));
+    /**
+     * Total GST amount
+     */
+    get GSTAmount() {
+        switch (this.taxType) {
+            case SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE:
+                return this.inclusiveGSTAmount;
+            case SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE:
+                return this.exclusiveGSTAmount;
+            case SoleInvoiceTaxTypeEnum.NO_TAX:
+                return 0;
+        }
     }
     /**
-     * Get new property collection filtered by shared
+     * When tax inclusive, GST amount is included to total price
      */
-    getSharedProperties() {
-        return new PropertyCollection(this.items.filter((property) => !property.isOwn()));
+    get inclusiveGSTAmount() {
+        const gstPrice = this.itemsCollection.gstPrice;
+        return +(gstPrice - (gstPrice / (1 + ChartAccounts.GSTRatio))).toFixed(2);
     }
     /**
-     * Properties that are taxed and will be included in reports (Tax summary, My tax report, e.t.c.)
+     * When tax exclusive, GST amount should be added additionally to total price
      */
-    getTaxInclusive() {
-        return this.create(this.items.filter((property) => property.category.isTaxInclusive));
+    get exclusiveGSTAmount() {
+        return +(this.itemsCollection.gstPrice * ChartAccounts.GSTRatio).toFixed(2);
     }
-    getUnsold() {
-        return this.create(this.items.filter((property) => !property.isSold()));
+    isDraft() {
+        return this.status === SoleInvoiceStatusesEnum.DRAFT;
     }
-    /**
-     * Get total purchase price for all properties in the collection
-     */
-    get purchasePrice() {
-        return this.sumBy('purchasePrice');
+    isCancelled() {
+        return this.status === SoleInvoiceStatusesEnum.CANCELED;
     }
-    get growthPercent() {
-        return this.sumBy('growthPercent');
+    isPending() {
+        return this.status === SoleInvoiceStatusesEnum.PENDING;
     }
-    get marketValue() {
-        return this.sumBy('marketValue');
+    isPaid() {
+        return this.status === SoleInvoiceStatusesEnum.PAID;
     }
-    get firstForecastYear() {
-        return this.items.reduce((min, property) => {
-            const current = property.firstForecastYear;
-            return min > current ? current : min;
-        }, new FinancialYear().year);
+    isOverdue() {
+        return this.isPending() && this.dateTo < new Date();
     }
-    get marketValueGrowth() {
-        return (this.marketValue - this.purchasePrice) / this.purchasePrice;
+    isUnpaid() {
+        return this.isPending() && this.dateTo >= new Date();
     }
     /**
-     * list of properties
+     * GST is not available for invoices without taxes
      */
-    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);
+    isNoTax() {
+        return this.taxType === SoleInvoiceTaxTypeEnum.NO_TAX;
     }
     /**
-     * Get list of unique property categories from collection
+     * GST amount is not included in items prices for invoices with tax exclusive,
+     * we should add GST amount additionaly to subtotal price to get total price
      */
-    getCategories() {
-        return uniqBy(this.items.map((property) => property.category), 'id');
+    isTaxExclusive() {
+        return this.taxType === SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE;
     }
     /**
-     * Get property with the highest growth percent
+     * GST amount already included in items prices for invoices with tax inclusive,
+     * we should subtract GST amount from total price to get subtotal price
      */
-    getBestPerformanceGrowthProperty() {
-        return this.items.reduce((max, current) => {
-            return max.growthPercent < current.growthPercent ? current : max;
-        }, this.first);
+    isTaxInclusive() {
+        return this.taxType === SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE;
     }
-    /**
-     * 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);
+    getNumber() {
+        return String(this.number).padStart(SoleInvoice.NUMBER_LENGTH, '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 name() {
+        return `invoice-${this.getNumber()}.pdf`;
+    }
+    getTransactionsIds() {
+        return new Collection(this.items).mapBy('transaction.id');
+        this.items.map((item) => item.transaction.id);
     }
 }
+SoleInvoice.NUMBER_LENGTH = 4;
+__decorate([
+    Type(() => Date)
+], SoleInvoice.prototype, "dateFrom", void 0);
+__decorate([
+    Type(() => Date)
+], SoleInvoice.prototype, "dateTo", void 0);
+__decorate([
+    Type(() => User)
+], SoleInvoice.prototype, "user", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], SoleInvoice.prototype, "business", void 0);
+__decorate([
+    Type(() => SoleInvoiceItem)
+], SoleInvoice.prototype, "items", void 0);
+__decorate([
+    Type(() => SoleContact)
+], SoleInvoice.prototype, "payer", void 0);
+__decorate([
+    Type(() => SoleInvoiceTemplate)
+], SoleInvoice.prototype, "template", void 0);
+__decorate([
+    Type(() => BankAccount)
+], SoleInvoice.prototype, "bankAccount", void 0);
 
-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;
-        });
+/**
+ * Class contains traveled kilometers and work usage percent in 12 weeks date range
+ * @TODO Vik: Best period: move this and related logic to backend
+ * @TODO Alex: check if we need this class when calculation refactored with backend
+ */
+class LogbookPeriod {
+    isEndOfYear() {
+        return this.to === new FinancialYear().endDate;
     }
-    hasCategory(categoryId) {
-        return !!this.findBy('propertyCategory.id', categoryId);
+    getWorkUsageByClaim(claim) {
+        const claimKilometers = this.logbooks.getByVehicleClaim(claim).getClaimableLogbooks().kilometers;
+        return Math.round(this.workUsage * (claimKilometers / this.kilometers));
     }
 }
+__decorate([
+    Type(() => Date)
+], LogbookPeriod.prototype, "from", void 0);
+__decorate([
+    Type(() => Date)
+], LogbookPeriod.prototype, "to", void 0);
 
-class VehicleClaimCollection extends Collection {
-    /**
-     * Get remaining kilometers limit. Total limit ({@link VehicleClaim.totalKmsLimit}) - claimed kilometers from other vehicle claims
-     */
-    getKmsLimitForClaim(claim) {
-        let collection = this;
-        if (claim) {
-            collection = collection.removeBy('id', claim.id);
-        }
-        return VehicleClaim.totalKmsLimit - collection.sumBy('kilometers');
-    }
-    /**
-     * Get remaining work usage limit. Total limit ({@link VehicleClaim.totalWorkUsagePercent}) - claimed percent from other vehicle claims
-     */
-    getWorkUsageLimitForClaim(claim) {
-        let collection = this;
-        if (claim) {
-            collection = collection.removeBy('id', claim.id);
-        }
-        return VehicleClaim.totalWorkUsagePercent - collection.sumBy('workUsage');
-    }
+class Vehicle$1 extends AbstractModel {
 }
 
-class VehicleLogbookCollection extends Collection {
-    /**
-     * Best period may be calculated only when user has logbooks minimum for VehicleLogbook.bestPeriodWeeks
-     * @TODO Vik: Best period: move this and related logic to backend
-     */
-    isBestPeriodExist() {
-        if (this.items.length < 2) {
-            return false;
-        }
-        return VehicleLogbook.bestPeriodDuration < (this.last.date.getTime() - this.first.date.getTime());
-    }
-    /**
-     * Get collection of non-personal logbooks (work-related, sole-related).
-     * @TODO Vik: Best period: move this and related logic to backend
-     */
-    getClaimableLogbooks() {
-        return this.filterBy('isPersonal', false);
+class VehicleLogbook$1 extends AbstractModel {
+}
+
+// problem with DateRange and typescript. See more https://github.com/rotaready/moment-range/issues/263
+const moment = extendMoment(moment$1);
+class VehicleLogbook extends VehicleLogbook$1 {
+    get kilometers() {
+        return this.odometerEnd - this.odometerStart;
     }
-    /**
-     * Get Logbook Period with the biggest work usage percent
-     * Best period duration is defined as VehicleLogbook.bestPeriodWeeks by the ATO
-     * @TODO Vik: Best period: move this and related logic to backend
-     */
-    getBestPeriod() {
-        if (!this.isBestPeriodExist()) {
-            return null;
-        }
-        let bestPeriod;
-        // get list of all logbooks available for best period calculation
-        const claimableLogbooks = this.getClaimableLogbooks().toArray();
-        for (let i = 0; i < claimableLogbooks.length; i++) {
-            // no sense to check next logbooks because we already get the end of the year
-            if (bestPeriod && bestPeriod.isEndOfYear()) {
-                break;
-            }
-            // get date range started from current handling logbook date
-            const dateRange = claimableLogbooks[i].getPeriod();
-            // get all logbooks included in current logbook period
-            const logbooksInRange = this.filterByRange('date', dateRange.start, dateRange.end);
-            const currentPeriod = plainToClass(LogbookPeriod, {
-                from: dateRange.start,
-                to: dateRange.end,
-                kilometers: logbooksInRange.getClaimableLogbooks().kilometers,
-                workUsage: logbooksInRange.getWorkUsage(),
-                logbooks: logbooksInRange
-            });
-            // compare with previous best period and overwrite if needs
-            if (!bestPeriod || currentPeriod.workUsage > bestPeriod.workUsage) {
-                bestPeriod = currentPeriod;
-            }
-            else if (currentPeriod.workUsage === bestPeriod.workUsage) {
-                // if work usage is the same then get period with the biggest work usage for work tank
-                const oldWorkUsage = bestPeriod.logbooks.filterBy('tankType', TankTypeEnum.WORK).getWorkUsage();
-                const currentWorkUsage = currentPeriod.logbooks.filterBy('tankType', TankTypeEnum.WORK).getWorkUsage();
-                if (oldWorkUsage < currentWorkUsage) {
-                    bestPeriod = currentPeriod;
-                }
-            }
-        }
-        return bestPeriod;
+    get tankType() {
+        return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
     }
-    /**
-     * Calculate total kilometers traveled
-     */
-    get kilometers() {
-        return this.sumBy('kilometers');
+    isWorkTank() {
+        return !this.business;
     }
-    /**
-     * Calculate work usage (percent of business-related kilometers from total kilometers)
-     * @TODO Alex: TT-2089 replace with getter
-     */
-    getWorkUsage() {
-        const workKilometers = this.getClaimableLogbooks().kilometers;
-        return Math.round(workKilometers / this.kilometers * 100);
+    isSoleTank() {
+        return !!this.business;
     }
     /**
-     * Get list of logbooks related to passed vehicle claim
+     * Get logbook period date range from logbook date and weeksInPeriod duration
      */
-    getByVehicleClaim(vehicleClaim) {
-        return vehicleClaim.isSoleTank()
-            // sole tank may have multiple vehicle claims, so we need to filter by business.id
-            ? this.filterBy('business.id', vehicleClaim.business.id)
-            // work tank may have only one vehicle claim, so we need to filter by tank type
-            : this.filterBy('tankType', TankTypeEnum.WORK);
+    getPeriod() {
+        return moment.rangeFromInterval('milliseconds', VehicleLogbook.bestPeriodDuration, this.date);
     }
 }
-
 /**
- * List of objects grouped by passed property
+ * Logbook period duration in milliseconds.
+ * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/211517441/Logbook+Vehicle
  */
-class Dictionary {
-    constructor(items, path = 'id') {
-        this.items = {};
-        if (!items.length) {
-            return;
-        }
-        // Do nothing if provided path was not found in the 1st item
-        if (!hasIn(items[0], path.split('.')[0])) {
-            return;
-        }
-        this.groupItems(items, path);
-    }
-    add(key, value) {
-        this.items[key] = value;
+VehicleLogbook.bestPeriodDuration = 12 * 7 * 24 * 3600 * 1000;
+__decorate([
+    Type(() => Date)
+], VehicleLogbook.prototype, "date", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], VehicleLogbook.prototype, "business", void 0);
+
+class Vehicle extends Vehicle$1 {
+}
+__decorate([
+    Type(() => VehicleLogbook)
+], Vehicle.prototype, "logbook", void 0);
+
+class VehicleClaim$1 extends AbstractModel {
+}
+
+class VehicleClaimDetails$1 extends AbstractModel {
+}
+
+var VehicleClaimDetailsMethodEnum;
+(function (VehicleClaimDetailsMethodEnum) {
+    VehicleClaimDetailsMethodEnum[VehicleClaimDetailsMethodEnum["KMS"] = 1] = "KMS";
+    VehicleClaimDetailsMethodEnum[VehicleClaimDetailsMethodEnum["LOGBOOK"] = 2] = "LOGBOOK";
+})(VehicleClaimDetailsMethodEnum || (VehicleClaimDetailsMethodEnum = {}));
+
+class VehicleClaimDetails extends VehicleClaimDetails$1 {
+    constructor() {
+        super(...arguments);
+        /**
+         * Init default values for the new instances
+         */
+        this.isManual = true;
+        this.method = VehicleClaimDetailsMethodEnum.KMS;
+        this.financialYear = new FinancialYear().year;
     }
-    get(key) {
-        return this.items[key] !== undefined ? this.items[key] : null;
+    isLogbookMethod() {
+        return this.method === VehicleClaimDetailsMethodEnum.LOGBOOK;
     }
-    groupItems(items, path) {
-        items.forEach((item) => {
-            let key = get(item, path);
-            // if object does not have property for grouping it will be grouped as 'other'
-            if (key === undefined) {
-                key = 'other';
-            }
-            this.items[key] = item;
-        });
+    isKmsMethod() {
+        return this.method === VehicleClaimDetailsMethodEnum.KMS;
     }
 }
+__decorate([
+    Type(() => User)
+], VehicleClaimDetails.prototype, "user", void 0);
 
-class SoleBusinessLossesCollection extends Collection {
+class VehicleClaim extends VehicleClaim$1 {
+    constructor() {
+        super(...arguments);
+        this.kilometers = 0;
+        this.workUsage = 0;
+    }
+    isWorkTank() {
+        return !this.business;
+    }
+    isSoleTank() {
+        return !!this.business;
+    }
+    get tankType() {
+        return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
+    }
     /**
-     * Business loss applied in current year, includes previous year losses and current year losses for businesses matching offset rule
+     * Claim amount for KMs method. Exists only for KMs method.
      */
-    calculateBusinessLossApplied(transactions) {
-        // claim amounts for businesses that can be applied to be reduced by prior year business losses
-        const claimAmountsByBusinessId = this.getClaimAmountsByBusinessId(transactions);
-        return Object.keys(claimAmountsByBusinessId.items).reduce((sum, businessId) => {
-            const loss = this.findBy('business.id', +businessId);
-            const lossOpenBalance = (loss === null || loss === void 0 ? void 0 : loss.openBalance) || 0;
-            // business loss can be applied to business profit or other income types profit in case in offset rule met
-            return sum + ((loss === null || loss === void 0 ? void 0 : loss.offsetRule) ? lossOpenBalance : Math.min(lossOpenBalance, claimAmountsByBusinessId.get(businessId)));
-        }, 0);
+    getKMSClaimAmount(vehicleClaimRate) {
+        return +(this.kilometers * vehicleClaimRate).toFixed(2);
     }
     /**
-     * Get business claim amounts that can be applied to be reduced by prior year business losses:
-     * businesses with income or businesses with a loss, but which met the non-commercial loss rules
-     * https://www.ato.gov.au/Business/Non-commercial-losses/
+     * Get logbook claim amount. Exists only for logbook method.
+     * ClaimAmount = WorkUsage * transaction/depreciation amount
      */
-    getClaimAmountsByBusinessId(transactions) {
-        const claimAmountsByBusinessId = new Dictionary([]);
-        const transactionsByBusinessId = new CollectionDictionary(transactions, 'business.id');
-        transactionsByBusinessId.keys.forEach((businessId) => {
-            var _a;
-            // business loss may not exist if, when creating a business, user didn't add losses for previous years
-            const lossOffsetRule = (_a = this.findBy('business.id', +businessId)) === null || _a === void 0 ? void 0 : _a.offsetRule;
-            const businessClaimAmount = transactionsByBusinessId
-                .get(businessId)
-                .getClaimAmountByBusinessId(+businessId);
-            // no way to apply loss for business without profit if offset rules not met
-            if (businessClaimAmount < 0 && !lossOffsetRule) {
-                return;
-            }
-            claimAmountsByBusinessId.add(businessId, businessClaimAmount);
-        });
-        return claimAmountsByBusinessId;
-    }
-}
-
-class SoleInvoiceCollection extends Collection {
-    getOverdue() {
-        return this.filter((invoice) => invoice.isOverdue());
-    }
-    getUnpaid() {
-        return this.filter((invoice) => invoice.isUnpaid());
-    }
-    getPaid() {
-        return this.filter((invoice) => invoice.isPaid());
+    getLogbookClaimAmount(transactions) {
+        const transactionsAmount = transactions
+            .getByVehicleClaim(this)
+            .getLogbookTransactions()
+            .sumBy('amount');
+        // Math.abs because amount will be negative (because we sum expenses), but we don't want negative percent value
+        return Math.abs(transactionsAmount) * this.workUsage / 100;
     }
-    getPending() {
-        return this.filter((invoice) => invoice.isPending());
+    getAverageWeeklyKMS() {
+        return this.kilometers / FinancialYear.weeksInYear;
     }
-    getTransactionsIds() {
-        return flatten(this.items.map((invoice) => invoice.getTransactionsIds()));
+    static getKMSChartAccountsIdByTankType(tankType) {
+        return tankType === TankTypeEnum.WORK
+            ? ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK
+            : ChartAccountsListEnum.KLMS_TRAVELLED;
     }
 }
-
 /**
- * Chart serie class: chart data item
- * @TODO consider rename to ChartSerieData
+ * limit for kms claim method
  */
-class ChartSerie {
+VehicleClaim.totalKmsLimit = 5000;
+/**
+ * limit for work usage claim method
+  */
+VehicleClaim.totalWorkUsagePercent = 100;
+__decorate([
+    Type(() => VehicleClaimDetails)
+], VehicleClaim.prototype, "details", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], VehicleClaim.prototype, "business", void 0);
+
+class SoleBusinessActivity$1 extends AbstractModel {
 }
 
+class SoleBusiness extends SoleBusiness$1 {
+    getPhotoPlaceholder() {
+        return `${this.name[0]}${this.name[1]}`;
+    }
+    getPhoto() {
+        return this.logo;
+    }
+}
 /**
- * Chart data class
- * @TODO consider rename to ChartSerie
+ * Maximum number of businesses that a person can have, according to the ATO
  */
-class ChartData {
+SoleBusiness.businessesLimit = 6;
+__decorate([
+    Type(() => User)
+], SoleBusiness.prototype, "user", void 0);
+__decorate([
+    Type(() => SoleBusinessAllocation)
+], SoleBusiness.prototype, "allocations", void 0);
+__decorate([
+    Type(() => SoleBusinessLoss)
+], SoleBusiness.prototype, "losses", void 0);
+__decorate([
+    Type(() => SoleInvoice)
+], SoleBusiness.prototype, "invoices", void 0);
+__decorate([
+    Type(() => SoleInvoiceTemplate)
+], SoleBusiness.prototype, "invoiceTemplates", void 0);
+__decorate([
+    Type(() => VehicleClaim)
+], SoleBusiness.prototype, "vehicleClaims", void 0);
+__decorate([
+    Type(() => Transaction)
+], SoleBusiness.prototype, "transactions", void 0);
+__decorate([
+    Type(() => Depreciation)
+], SoleBusiness.prototype, "depreciations", void 0);
+__decorate([
+    Type(() => SoleBusinessActivity$1)
+], SoleBusiness.prototype, "activity", void 0);
+__decorate([
+    Type(() => IncomeSource)
+], SoleBusiness.prototype, "incomeSource", void 0);
+
+class SoleBusinessActivity extends SoleBusinessActivity$1 {
+}
+
+class SoleDepreciationMethod$1 extends AbstractModel {
+}
+
+var SoleDepreciationMethodEnum;
+(function (SoleDepreciationMethodEnum) {
+    SoleDepreciationMethodEnum[SoleDepreciationMethodEnum["SBP"] = 1] = "SBP";
+    SoleDepreciationMethodEnum[SoleDepreciationMethodEnum["DEPRECIATION"] = 2] = "DEPRECIATION";
+})(SoleDepreciationMethodEnum || (SoleDepreciationMethodEnum = {}));
+
+class SoleDepreciationMethod extends SoleDepreciationMethod$1 {
+    isSBP() {
+        return this.method === SoleDepreciationMethodEnum.SBP;
+    }
+}
+
+class SoleDetails$1 extends AbstractModel {
+}
+
+class SoleDetails extends SoleDetails$1 {
 }
 __decorate([
-    Type(() => ChartSerie)
-], ChartData.prototype, "data", void 0);
+    Type(() => User)
+], SoleDetails.prototype, "user", void 0);
 
-const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan'];
+class BasReport$1 extends AbstractModel {
+}
 
-/**
- * @TODO extend from TransactionBaseCollection
- * Collection of transactions
- */
-class TransactionCollection extends ExportableCollection {
-    /**
-     * @TODO use TransactionBaseCollection instead
-     * we use depreciations as expense transactions a lot
-     */
-    constructor(transactions = [], depreciations = []) {
-        super([...transactions, ...depreciations.map((depreciation) => depreciation.toTransaction())]);
+class BasReport extends BasReport$1 {
+    get taxWithheldTotal() {
+        return this.taxWithheldSalary + this.taxWithheldNoABN;
     }
-    getSoleTransactions() {
-        return this.filter((transaction) => transaction.isSoleTank());
+    get paygTaxInstalmentOwedToATO() {
+        return this.paygTaxInstalment > 0 ? this.paygTaxInstalment : 0;
     }
-    get amount() {
-        return this.sumBy('amount');
+    get paygTaxInstalmentOwedByATO() {
+        return this.paygTaxInstalment < 0 ? Math.abs(this.paygTaxInstalment) : 0;
     }
-    /**
-     * Difference between allocated amount and total amount
-     */
-    getUnallocatedAmount(allocations) {
-        return this.items.reduce((sum, transaction) => {
-            return sum + transaction.getUnallocatedAmount(allocations.filterBy('transaction.id', transaction.id));
-        }, 0);
+    get fuelTaxCreditOwedToATO() {
+        return this.fuelTaxCredit < 0 ? this.fuelTaxCredit : 0;
+    }
+    get fuelTaxCreditOwedByATO() {
+        return this.fuelTaxCredit > 0 ? Math.abs(this.fuelTaxCredit) : 0;
+    }
+    get owesToATO() {
+        return this.incomeGST + this.taxWithheldTotal + this.paygTaxInstalmentOwedToATO + this.fuelTaxCreditOwedToATO;
+    }
+    get owedByATO() {
+        return this.expenseGST + this.paygTaxInstalmentOwedByATO + this.fuelTaxCreditOwedByATO;
     }
     /**
-     * get date of the last transaction
+     * GST payable to the ATO, or refundable from the ATO in case it's negative
      */
-    getLastTransactionDate() {
-        return new Date(Math.max.apply(Math, this.items.map((transaction) => transaction.date)));
-    }
-    get claimAmount() {
-        return this.items.reduce((sum, transaction) => sum + transaction.claimAmount, 0);
+    get gst() {
+        return this.incomeGST + this.expenseGST + this.taxWithheldTotal + this.paygTaxInstalment - this.fuelTaxCredit;
     }
-    get grossClaimAmount() {
-        return this.items.reduce((sum, transaction) => sum + transaction.grossClaimAmount, 0);
+}
+__decorate([
+    Type(() => Date)
+], BasReport.prototype, "dateFrom", void 0);
+__decorate([
+    Type(() => Date)
+], BasReport.prototype, "dateTo", void 0);
+
+/**
+ * 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 User extends User$1 {
+    get fullName() {
+        return `${this.firstName} ${this.lastName}`;
     }
-    get grossAmount() {
-        return this.items.reduce((sum, transaction) => sum + transaction.grossAmount, 0);
+    get activeSubscription() {
+        return this.subscriptions.find((ss) => ss.isActive);
     }
-    getByChartAccountsCategories(categories) {
-        return new TransactionCollection(this.items.filter((transaction) => categories.includes(transaction.chartAccounts.category)));
+    get lastSubscription() {
+        return this.subscriptions[this.subscriptions.length - 1];
     }
     /**
-     * Get transactions by month
-     * @param monthIndex by which desired month should be taken
+     * @TODO refactor
+     *
      */
-    getByMonth(monthIndex) {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.date.getMonth() === monthIndex));
+    get position() {
+        switch (true) {
+            case this.isFirmOwner():
+                return USER_WORK_POSITION[UserRolesEnum.FIRM_OWNER];
+            case this.isManager():
+                return USER_WORK_POSITION[UserRolesEnum.FIRM_MANAGER];
+            case this.isEmployee():
+                return USER_WORK_POSITION[UserRolesEnum.EMPLOYEE];
+            default:
+                return '';
+        }
     }
     /**
-     * Get collection of transactions metadata
+     * search roles including hierarchy
      */
-    getTransactionsMetadata() {
-        const metadataArray = [];
-        this.items.forEach((transaction) => {
-            metadataArray.push(...transaction.metadata);
-        });
-        return new Collection(metadataArray);
-    }
-    getIncomeTransactions() {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.isIncome()));
+    hasRoles(roles) {
+        roles = roles instanceof Array ? roles : [roles];
+        if (!roles.length) {
+            return true;
+        }
+        roles = flatten(roles.map((role) => USER_ROLES[role]));
+        return !!intersection(this.roles, roles).length;
     }
-    getExpenseTransactions() {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.isExpense() && !transaction.isInterest()));
+    isOnboarding() {
+        return this.status === UserStatusEnum.ON_BOARDING;
     }
-    get claimIncome() {
-        return this.getIncomeTransactions().claimAmount;
+    hasSubscription() {
+        return this.roles.includes(UserRolesEnum.SUBSCRIPTION);
     }
-    get claimExpense() {
-        return this.getExpenseTransactions().claimAmount;
+    isLoggedIn() {
+        return this.id === +localStorage.getItem('userId');
     }
-    getInterestTransactions() {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.isInterest()));
+    isClient() {
+        return this.roles.includes(UserRolesEnum.CLIENT);
     }
-    get claimInterest() {
-        return this.getInterestTransactions().claimAmount;
+    isEmployee() {
+        return this.isAccountant() || this.isAdvisor();
     }
-    /**
-     * Get collection of transactions and properties filtered by properties ids
-     * @param ids Ids of properties for filter
-     */
-    getByPropertiesIds(ids) {
-        return new TransactionCollection(this.items.filter((transaction) => {
-            var _a;
-            return ids.includes((_a = transaction.property) === null || _a === void 0 ? void 0 : _a.id);
-        }));
+    isAccountant() {
+        return this.roles.includes(UserRolesEnum.ACCOUNTANT);
     }
-    /**
-     * Get new collection filtered by income source id
-     * @param id id of income source for filter
-     */
-    getByIncomeSourceId(id) {
-        return new TransactionCollection(this.items.filter((transaction) => { var _a; return ((_a = transaction.incomeSource) === null || _a === void 0 ? void 0 : _a.id) === id; }));
+    isAdvisor() {
+        return this.roles.includes(UserRolesEnum.ADVISOR);
     }
-    /**
-     * Get new collection filtered by chart accounts category
-     * @param category Chart accounts category value
-     */
-    getByChartAccountsCategory(category) {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.chartAccounts.category === category));
+    isImpersonator() {
+        return this.roles.includes(UserRolesEnum.SWITCH_USER);
     }
     /**
-     * Get new collection of property transactions
+     * Check if current user is firm owner
      */
-    getPropertyTransactions() {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.isPropertyTank()));
-    }
-    getDebitTransactions() {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.isDebit()));
-    }
-    getCreditTransactions() {
-        return new TransactionCollection(this.items.filter((transaction) => transaction.isCredit()));
-    }
-    getByAllocations(allocations) {
-        return new TransactionCollection(this.items.filter((transaction) => allocations.hasTransaction(transaction)));
+    isFirmOwner() {
+        return this.roles.includes(UserRolesEnum.FIRM_OWNER);
     }
     /**
-     * Get transactions related to Vehicle category
+     * Check if current user is firm manager
      */
-    getVehicleTransactions() {
-        return this.create(this.items.filter((transaction) => {
-            return transaction.isVehicleTransaction();
-        }));
+    isManager() {
+        return this.roles.includes(UserRolesEnum.FIRM_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);
     }
     /**
-     * Get new transaction collection filtered by tank type
+     * check if user has property tank access
      */
-    getByTankType(tankType) {
-        return this.create(this.items.filter((transaction) => {
-            switch (tankType) {
-                case TankTypeEnum.PROPERTY:
-                    return transaction.isPropertyTank();
-                case TankTypeEnum.WORK:
-                    return transaction.isWorkTank();
-                case TankTypeEnum.SOLE:
-                    return transaction.isSoleTank();
-                // Transaction may be not related to any tank type (personal)
-                default:
-                    return false;
-            }
-        }));
-    }
-    getExportHeader() {
-        return ['Date', 'Description', 'Debit', 'Credit'];
-    }
-    getExportFooter() {
-        return [
-            plainToClass(ExportCell, { value: 'Total', type: ExportCellTypeEnum.STRING }),
-            plainToClass(ExportCell, { value: '', type: ExportCellTypeEnum.STRING }),
-            plainToClass(ExportCell, { value: this.sumBy('debit'), type: ExportCellTypeEnum.CURRENCY }),
-            plainToClass(ExportCell, { value: this.sumBy('credit'), type: ExportCellTypeEnum.CURRENCY })
-        ];
-    }
-    getExportBody() {
-        return this.items.map((transaction) => {
-            return [
-                plainToClass(ExportCell, { value: transaction.date, type: ExportCellTypeEnum.DATE }),
-                plainToClass(ExportCell, { value: transaction.description, type: ExportCellTypeEnum.STRING }),
-                plainToClass(ExportCell, { value: transaction.debit, type: ExportCellTypeEnum.CURRENCY }),
-                plainToClass(ExportCell, { value: transaction.credit, type: ExportCellTypeEnum.CURRENCY })
-            ];
-        });
+    hasPropertyTank() {
+        return this.roles ?
+            this.roles.includes(UserRolesEnum.PROPERTY_TANK) :
+            !!this.getSubscriptionRole(UserRolesEnum.PROPERTY_TANK);
     }
     /**
-     * Get list of vehicle transactions filtered by vehicle claim
+     * check if user has property tank access
      */
-    getByVehicleClaim(vehicleClaim) {
-        if (!vehicleClaim) {
-            return this.create([]);
-        }
-        return vehicleClaim.isSoleTank()
-            // sole tank may have multiple vehicle claims, so we need to filter by business.id
-            ? this.getVehicleTransactions().filterBy('business.id', vehicleClaim.business.id)
-            // work tank may have only one vehicle claim, so we need to filter by tank type
-            : this.getVehicleTransactions().filterBy('tankType', TankTypeEnum.WORK);
+    hasWorkTank() {
+        return this.roles ?
+            this.roles.includes(UserRolesEnum.WORK_TANK) :
+            !!this.getSubscriptionRole(UserRolesEnum.WORK_TANK);
     }
     /**
-     * Get list of vehicle transactions except KMS transactions
+     * Get user subscription role by provided role type
+     * @param roleType by which role should be returned
      */
-    getLogbookTransactions() {
-        return this
-            .getVehicleTransactions()
-            .removeBy('chartAccounts.id', [ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK, ChartAccountsListEnum.KLMS_TRAVELLED]);
+    getSubscriptionRole(roleType) {
+        var _a;
+        /**
+         * Add @TODO for Alex to check if we should use getLastSubscription here
+         */
+        return (_a = this.activeSubscription) === null || _a === void 0 ? void 0 : _a.items.find((subscriptionItem) => subscriptionItem.price.product.role.includes(roleType));
     }
     /**
-     * Build chart data with transactions cash position.
-     * Cash position = Income - Expenses (include depreciations)
-     * Chart data for each month from fin year start till current month
+     * Get user's photo link
      */
-    getCashPositionChartData() {
-        const chartData = [
-            plainToClass(ChartData, { name: 'Income', data: [] }),
-            plainToClass(ChartData, { name: 'Expense', data: [] })
-        ];
-        new FinancialYear().getPastMonths().forEach((month) => {
-            chartData[0].data.push({
-                label: MONTHS[month],
-                value: this.getIncomeTransactions().getByMonth(month).claimAmount
-            });
-            chartData[1].data.push({
-                label: MONTHS[month],
-                value: Math.abs(this.getExpenseTransactions().getByMonth(month).claimAmount)
-            });
-        });
-        return chartData;
+    getPhoto() {
+        return this.photo;
     }
     /**
-     * user pays GST only from allocated part (or paid) of income
+     * get user's initials
      */
-    calculateAllocatedClaimAmount(allocations) {
-        let allocatedClaimAmount = 0;
-        this.filterBy('isGST', true).toArray().forEach((transaction) => {
-            allocatedClaimAmount += transaction.getAllocatedClaimAmount(allocations);
-        });
-        return allocatedClaimAmount;
+    getPhotoPlaceholder() {
+        return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
     }
-    calculateAllocatedGST(allocations) {
-        return this.calculateAllocatedClaimAmount(allocations) * ChartAccounts.GSTRatio;
+}
+__decorate([
+    Type(() => ServiceSubscription)
+], User.prototype, "subscriptions", void 0);
+__decorate([
+    Type(() => ClientDetails)
+], User.prototype, "clientDetails", void 0);
+__decorate([
+    Type(() => EmployeeDetails)
+], User.prototype, "employeeDetails", void 0);
+__decorate([
+    Type(() => SoleDetails)
+], User.prototype, "soleDetails", void 0);
+__decorate([
+    Type(() => Address)
+], User.prototype, "address", void 0);
+__decorate([
+    Type(() => Phone)
+], User.prototype, "phone", void 0);
+__decorate([
+    Type(() => Date)
+], User.prototype, "createdAt", void 0);
+__decorate([
+    Type(() => User)
+], User.prototype, "clients", void 0);
+
+class PropertySubscription extends PropertySubscription$1 {
+}
+__decorate([
+    Type(() => Date)
+], PropertySubscription.prototype, "createdAt", void 0);
+__decorate([
+    Type(() => User)
+], PropertySubscription.prototype, "user", void 0);
+
+class PropertyCategory$1 extends AbstractModel {
+}
+
+var PropertyCategoryListEnum;
+(function (PropertyCategoryListEnum) {
+    PropertyCategoryListEnum[PropertyCategoryListEnum["OWNER_OCCUPIED"] = 3] = "OWNER_OCCUPIED";
+    PropertyCategoryListEnum[PropertyCategoryListEnum["SHARED"] = 4] = "SHARED";
+    PropertyCategoryListEnum[PropertyCategoryListEnum["VACANT_LAND"] = 5] = "VACANT_LAND";
+})(PropertyCategoryListEnum || (PropertyCategoryListEnum = {}));
+
+class PropertyCategory extends PropertyCategory$1 {
+    // @Todo check if category is Owner Occupied. If will be needed to check more categories - move the checking to the backend
+    isOwnerOccupied() {
+        return this.id === PropertyCategoryListEnum.OWNER_OCCUPIED;
     }
-    getAllocatedAmount(allocations) {
-        return allocations.getByTransactionsIds(this.getIds()).sumBy('amount');
+    isVacantLand() {
+        return this.id === PropertyCategoryListEnum.VACANT_LAND;
+    }
+    isShared() {
+        return this.id === PropertyCategoryListEnum.SHARED;
     }
 }
 
-class TransactionAllocationCollection extends Collection {
-    get amount() {
-        return this.sumBy('amount');
+class PropertyValuation$1 extends AbstractModel {
+}
+
+class PropertyDocument$1 extends AbstractModel {
+    getApiUrlPrefix() {
+        return '';
     }
-    getByTransactionsIds(ids) {
-        return new TransactionAllocationCollection(this.items.filter((allocation) => ids.includes(allocation.transaction.id)));
+    getEntity() {
+        return undefined;
     }
-    getByBankTransactionsIds(ids) {
-        return new TransactionAllocationCollection(this.items.filter((allocation) => ids.includes(allocation.bankTransaction.id)));
+}
+
+class PropertyDocument extends PropertyDocument$1 {
+    constructor() {
+        super(...arguments);
+        this.type = AssetTypeEnum.DOCUMENT;
+        this.entityType = AssetEntityTypeEnum.PROPERTIES;
+    }
+    getApiUrlPrefix() {
+        return '';
+    }
+    getEntity() {
+        return this.property;
+    }
+}
+
+class PropertyValuation extends PropertyValuation$1 {
+    get financialYear() {
+        return new FinancialYear(this.date).year;
+    }
+    isCurrentYear() {
+        return this.financialYear === new FinancialYear(new Date()).year;
+    }
+}
+__decorate([
+    Type(() => Date)
+], PropertyValuation.prototype, "date", void 0);
+__decorate([
+    Type(() => PropertyDocument)
+], PropertyValuation.prototype, "document", void 0);
+__decorate([
+    Exclude()
+], PropertyValuation.prototype, "documentFile", void 0);
+
+class PropertyForecast$1 extends AbstractModel {
+}
+
+class PropertyForecast extends PropertyForecast$1 {
+    constructor() {
+        super(...arguments);
+        this.financialYear = new FinancialYear(new Date()).year;
     }
     /**
-     * Group allocations by bank account via bank transactions collection
+     * Get cash position
+     * Cash Position = Income - Expense - Interest
      */
-    groupByBankAccount(bankTransactions) {
-        // Group bank transactions by bank account id
-        const bankTransactionsByBankAccount = new CollectionDictionary(bankTransactions, 'bankAccount.id');
-        // Create empty dictionary of transaction allocations
-        const allocationsByBankAccount = new CollectionDictionary(new TransactionAllocationCollection([]));
-        // Fill allocations dictionary with bank transactions dictionary keys and allocations related with each bank transaction collection
-        bankTransactionsByBankAccount.keys.forEach((key) => {
-            allocationsByBankAccount.add(key, this.getByBankTransactionsIds(bankTransactionsByBankAccount.get(key).getIds()));
-        });
-        return allocationsByBankAccount;
+    get cashPosition() {
+        return this.income + this.expense + this.interest;
     }
     /**
-     * check if collection includes allocation of passed transaction
+     * Get tax position
+     * Tax Position = Income - Expense - Interest - Depreciation
      */
-    hasTransaction(transaction) {
-        return !!this.items.find((allocation) => allocation.transaction.id === transaction.id);
+    get taxPosition() {
+        return this.cashPosition + this.depreciation;
     }
     /**
-     * Check if bank transaction is related with current allocations
+     * Get rental return percent
+     * Rental Return = Income / Market Value
      */
-    hasBankTransaction(bankTransaction) {
-        return !!this.items.find((allocation) => allocation.bankTransaction.id === bankTransaction.id);
+    get rentalReturn() {
+        return this.income / this.marketValue;
+    }
+    /**
+     * Check if forecast is for real current fin year (not selected in the sidebar)
+     */
+    isCurrentYear() {
+        return this.financialYear === new FinancialYear(new Date()).year;
     }
 }
+__decorate([
+    Transform(({ value }) => +value)
+], PropertyForecast.prototype, "income", void 0);
+__decorate([
+    Transform(({ value }) => -Math.abs(+value))
+], PropertyForecast.prototype, "expense", void 0);
+__decorate([
+    Transform(({ value }) => -Math.abs(+value))
+], PropertyForecast.prototype, "interest", void 0);
+__decorate([
+    Transform(({ value }) => -Math.abs(+value))
+], PropertyForecast.prototype, "depreciation", void 0);
+__decorate([
+    Transform(({ value }) => +value)
+], PropertyForecast.prototype, "loanBalance", void 0);
+__decorate([
+    Transform(({ value }) => +value)
+], PropertyForecast.prototype, "marketValue", void 0);
 
-/**
- * used to combine transactions/depreciations
- */
-class TransactionBaseCollection extends Collection {
-    getClaimAmountByBusinessId(businessId) {
-        return +this.filterBy('business.id', businessId).items.map((transaction) => transaction instanceof Depreciation ? -transaction.claimAmount : transaction['claimAmount']).reduce((sum, claimAmount) => sum + claimAmount, 0).toFixed(2);
-    }
-    getSoleTransactions() {
-        return this.filter((transaction) => transaction.isSoleTank());
-    }
+class PropertyCategoryMovement$1 extends AbstractModel {
 }
 
-// @TODO Alex move here all collections
+class PropertyCategoryMovement extends PropertyCategoryMovement$1 {
+}
+__decorate([
+    Type(() => PropertyValuation)
+], PropertyCategoryMovement.prototype, "valuation", void 0);
+__decorate([
+    Type(() => PropertyCategory)
+], PropertyCategoryMovement.prototype, "propertyCategory", void 0);
+__decorate([
+    Type(() => Date)
+], PropertyCategoryMovement.prototype, "fromDate", void 0);
+__decorate([
+    Type(() => Date)
+], PropertyCategoryMovement.prototype, "toDate", void 0);
+
+var TaxExemptionEnum;
+(function (TaxExemptionEnum) {
+    TaxExemptionEnum[TaxExemptionEnum["ONE_YEAR_RULE"] = 1] = "ONE_YEAR_RULE";
+    // principle place of residence
+    TaxExemptionEnum[TaxExemptionEnum["PPR"] = 2] = "PPR";
+    TaxExemptionEnum[TaxExemptionEnum["SIX_YEARS_RULE"] = 3] = "SIX_YEARS_RULE";
+    TaxExemptionEnum[TaxExemptionEnum["INVESTMENT_TO_PPR"] = 4] = "INVESTMENT_TO_PPR";
+    TaxExemptionEnum[TaxExemptionEnum["PPR_TO_INVESTMENT"] = 5] = "PPR_TO_INVESTMENT";
+    TaxExemptionEnum[TaxExemptionEnum["TRANSFER"] = 6] = "TRANSFER";
+    TaxExemptionEnum[TaxExemptionEnum["OTHER"] = 7] = "OTHER";
+})(TaxExemptionEnum || (TaxExemptionEnum = {}));
 
 /**
  * propertySale docs - https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4209508353/Property+Sold+button
@@ -17948,13 +17954,15 @@ class WorkIncomeForm extends TransactionForm {
             }, Validators.required),
             incomeSource: new FormControl(transaction.incomeSource, [Validators.required, autocompleteValidator()]),
         });
-        // salary adjustments (like tips)
+        // @TODO we use amount field as netAmount to avoid extra watcher for amount recalculation
         if (transaction.id) {
-            this.get('amount').setValue(this.getAmount(transaction));
+            this.get('amount').setValue(transaction.netAmount);
         }
+        // forbid to edit some fields for allocated transaction
         if (allocations.length) {
             this.get('chartAccounts').disable();
         }
+        // adjustments allowed only for salary
         if (!((_a = transaction.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalary())) {
             this.get('transactions').disable();
         }
@@ -18013,25 +18021,19 @@ class WorkIncomeForm extends TransactionForm {
         });
     }
     /**
-     * @param transaction
-     * @param includeAdjustments reduce result by adjustments included in salary if false or increase amount with included salary adjustments to match received payment if true,
-     * salary/wage comes to bankAccount together with related chartAccounts like tips (kind of salary, but reported in different tax summary section),
+     * salary comes to bankAccount together with related transactions like tips (kind of salary, but reported in different tax summary section),
      * adjustments used to clarify received payment by separating it into multiple transactions,
-     * formAmount always match received payment, it also matches parent transactionAmount when there are no adjustments,
-     * otherwise it includes such adjustments, so we should exclude it from formAmount to create a salary transaction (on submit)
-     * but include in form->amount to match bank transaction (on edit),
-     * ie bankTransaction=1000$, it includes 900$ salary and 100$ tips (should be reported in different tax summary sections),
-     * so we should show 1000$ in formAmount, but create 2 transactions with 900$ and 100$
-     */
-    getAmount(transaction, includeAdjustments = true) {
-        if (!transaction.chartAccounts || !transaction.chartAccounts.isSalary()) {
-            return transaction.amount;
-        }
-        const includedTransactions = new Collection(transaction.transactions).filter((t) => t.chartAccounts.isSalaryIncluded());
-        return transaction.amount + includedTransactions.sumBy('amount') * (includeAdjustments ? 1 : -1);
+     * netAmount always match received payment and includes related adjustments
+     * amount calculated as netAmount - salary included adjustments
+     * ie bankTransaction=1000$ with 900$ salary and 100$ tips will create 2 transactions with 900$ and 100$
+     */
+    getAmount() {
+        return this.get('amount').value - new Collection(this.currentValue.transactions)
+            .filter((t) => { var _a; return (_a = t.chartAccounts) === null || _a === void 0 ? void 0 : _a.isSalaryIncluded(); })
+            .sumBy('amount');
     }
     submit(data = {}) {
-        return super.submit(Object.assign(data, { amount: this.getAmount(this.currentValue, false) }));
+        return super.submit(Object.assign(data, { amount: this.getAmount() }));
     }
 }