taxtank-core 0.28.29 → 0.28.31

package/bundles/taxtank-core.umd.js

@@ -1067,7 +1067,10 @@
         SOLE_BUSINESSES_GET: new Endpoint('GET', '\\/sole-businesses'),
         SOLE_BUSINESSES_POST: new Endpoint('POST', '\\/sole-businesses'),
         SOLE_BUSINESSES_PUT: new Endpoint('PUT', '\\/sole-businesses\\/\\d+'),
-        SOLE_BUSINESSES_LOSSES_GET: new Endpoint('GET', '\\/sole-business-losses'),
+        SOLE_BUSINESS_LOSSES_GET: new Endpoint('GET', '\\/sole-business-losses'),
+        SOLE_BUSINESS_LOSSES_POST: new Endpoint('POST', '\\/sole-business-losses'),
+        SOLE_BUSINESS_LOSSES_PUT: new Endpoint('PUT', '\\/sole-business-losses\\/\\d+'),
+        SOLE_BUSINESS_LOSS_OFFSET_RULES_GET: new Endpoint('GET', '\\/sole-business-loss-offset-rules'),
         SOLE_CONTACTS_POST: new Endpoint('POST', '\\/sole-contacts'),
         SOLE_CONTACTS_PUT: new Endpoint('PUT', '\\/sole-contacts\\/\\d+'),
         BUSINESS_ACTIVITIES_GET: new Endpoint('GET', '\\/sole-business-activities'),
@@ -1815,6 +1818,10 @@
     var Collection = /** @class */ (function () {
         function Collection(items) {
             if (items === void 0) { items = []; }
+            /**
+             * index of current item, used to iterate over the collection
+             */
+            this.index = 0;
             this.items = items;
         }
         /**
@@ -1851,6 +1858,24 @@
             enumerable: false,
             configurable: true
         });
+        Collection.prototype.reset = function () {
+            this.index = 0;
+            return this.items[this.index];
+        };
+        Collection.prototype.next = function () {
+            if (this.index < this.length) {
+                this.index++;
+                return this.items[this.index];
+            }
+            return null;
+        };
+        Collection.prototype.back = function () {
+            if (this.index > 0) {
+                this.index--;
+                return this.items[this.index];
+            }
+            return null;
+        };
         Collection.prototype.getIds = function () {
             return this.items.map(function (item) { return item['id']; });
         };
@@ -2667,6 +2692,19 @@
         ServiceSubscription.prototype.hasItem = function (itemToCheck) {
             return !!this.items.find(function (item) { return item.price.id === itemToCheck.price.id; });
         };
+        /**
+         * Recommended number of properties to buy,
+         * based on the property service product and the number of properties the user has
+         */
+        ServiceSubscription.prototype.getRecommendedPropertiesQty = function (propertyItem, propertiesQty) {
+            var max = propertyItem.price.product.maxQty;
+            var min = propertyItem.price.product.minQty;
+            // if user has property subscription and number of properties doesn't exceed the maximum in the service product - return one more
+            if (this.hasItem(propertyItem)) {
+                propertiesQty = propertiesQty < max ? propertiesQty + 1 : max;
+            }
+            return Math.max(min, propertiesQty);
+        };
         return ServiceSubscription;
     }(ServiceSubscription$1));
     __decorate([
@@ -2717,16 +2755,47 @@
         return SoleBusinessLoss;
     }(AbstractModel));
 
+    var SoleBusinessLossOffsetRule$1 = /** @class */ (function (_super) {
+        __extends(SoleBusinessLossOffsetRule, _super);
+        function SoleBusinessLossOffsetRule() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return SoleBusinessLossOffsetRule;
+    }(AbstractModel));
+
+    var SoleBusinessLossOffsetRule = /** @class */ (function (_super) {
+        __extends(SoleBusinessLossOffsetRule, _super);
+        function SoleBusinessLossOffsetRule() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return SoleBusinessLossOffsetRule;
+    }(SoleBusinessLossOffsetRule$1));
+    __decorate([
+        classTransformer.Type(function () { return SoleBusinessLossOffsetRule; })
+    ], SoleBusinessLossOffsetRule.prototype, "parent", void 0);
+
     var SoleBusinessLoss = /** @class */ (function (_super) {
         __extends(SoleBusinessLoss, _super);
         function SoleBusinessLoss() {
-            return _super !== null && _super.apply(this, arguments) || this;
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.openBalance = 0;
+            return _this;
         }
+        Object.defineProperty(SoleBusinessLoss.prototype, "hasOffset", {
+            get: function () {
+                return !!this.offsetRule;
+            },
+            enumerable: false,
+            configurable: true
+        });
         return SoleBusinessLoss;
     }(SoleBusinessLoss$1));
     __decorate([
         classTransformer.Type(function () { return SoleBusiness; })
     ], SoleBusinessLoss.prototype, "business", void 0);
+    __decorate([
+        classTransformer.Type(function () { return SoleBusinessLossOffsetRule; })
+    ], SoleBusinessLoss.prototype, "offsetRule", void 0);
 
     var SoleInvoice$1 = /** @class */ (function (_super) {
         __extends(SoleInvoice, _super);
@@ -7132,155 +7201,482 @@
         return PropertyCategoryMovementCollection;
     }(Collection));
 
-    // @TODO Alex move here all collections
-
-    var AccountSetupItemCollection = /** @class */ (function (_super) {
-        __extends(AccountSetupItemCollection, _super);
-        function AccountSetupItemCollection(items) {
-            var _this = _super.call(this, compact__default["default"](items)) || this;
-            _this.sortBy('isCompleted', false);
-            return _this;
+    /**
+     * Chart serie class: chart data item
+     * @TODO consider rename to ChartSerieData
+     */
+    var ChartSerie = /** @class */ (function () {
+        function ChartSerie() {
         }
-        AccountSetupItemCollection.prototype.isCompleted = function () {
-            return this.filterBy('isCompleted', true).length === this.length;
-        };
-        return AccountSetupItemCollection;
-    }(Collection));
+        return ChartSerie;
+    }());
 
     /**
-     * Maximal delay between transfer transactions
+     * Chart data class
+     * @TODO consider rename to ChartSerie
      */
-    var TRANSACTION_TRANSFER_DELAY = 96 * 3600 * 1000;
+    var ChartData = /** @class */ (function () {
+        function ChartData() {
+        }
+        return ChartData;
+    }());
+    __decorate([
+        classTransformer.Type(function () { return ChartSerie; })
+    ], ChartData.prototype, "data", void 0);
+
+    var MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan'];
+
     /**
-     * Collection of bank transactions.
-     * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService
-     * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage
-     * because all amounts calculates with allocated amounts but not from bank transactions amounts.
+     * Collection of transactions
      */
-    var BankTransactionCollection = /** @class */ (function (_super) {
-        __extends(BankTransactionCollection, _super);
-        function BankTransactionCollection() {
+    var TransactionCollection = /** @class */ (function (_super) {
+        __extends(TransactionCollection, _super);
+        function TransactionCollection() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        BankTransactionCollection.prototype.getAmount = function () {
-            return this.sumBy('amount');
-        };
-        /**
-         * Difference between total bank transactions amount and sum of allocations for passed bank transactions
-         */
-        BankTransactionCollection.prototype.getUnallocatedAmount = function (allocations) {
-            return +(this.getAmount() - allocations.getByBankTransactionsIds(this.getIds()).amount).toFixed(2);
-        };
+        Object.defineProperty(TransactionCollection.prototype, "amount", {
+            /**
+             * Get total amount of all transactions in the collection
+             */
+            get: function () {
+                return +this.items.reduce(function (sum, transaction) { return sum + transaction.getNetAmount(); }, 0).toFixed(2);
+            },
+            enumerable: false,
+            configurable: true
+        });
         /**
-         * get date of the last transaction
+         * Difference between allocated amount and total amount
          */
-        BankTransactionCollection.prototype.getLastTransactionDate = function () {
-            return new Date(Math.max.apply(Math, this.items.map(function (bankTransaction) { return bankTransaction.date; })));
+        TransactionCollection.prototype.getUnallocatedAmount = function (allocations) {
+            return +(this.amount - allocations.getByTransactionsIds(this.getIds()).amount).toFixed(2);
         };
-        Object.defineProperty(BankTransactionCollection.prototype, "creditTransactions", {
+        Object.defineProperty(TransactionCollection.prototype, "cashPosition", {
             /**
-             * get list of credit transactions
+             * Get cash position
+             * Cash Position = Income - Expenses
+             * Cash position is equal to Total Amount because income is positive and expense is negative,
              */
             get: function () {
-                return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return bankTransaction.isCredit(); }));
+                return this.claimAmount;
             },
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(BankTransactionCollection.prototype, "debitTransactions", {
+        /**
+         * get date of the last transaction
+         */
+        TransactionCollection.prototype.getLastTransactionDate = function () {
+            return new Date(Math.max.apply(Math, this.items.map(function (transaction) { return transaction.date; })));
+        };
+        Object.defineProperty(TransactionCollection.prototype, "claimAmount", {
             /**
-             * get list of debit transactions
+             * Get summary of claim amounts
              */
             get: function () {
-                return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return bankTransaction.isDebit(); }));
+                return this.items.reduce(function (sum, transaction) { return sum + transaction.claimAmount; }, 0);
             },
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(BankTransactionCollection.prototype, "balanceAmount", {
-            /**
-             * get difference between debit and credit transactions amounts
-             */
+        Object.defineProperty(TransactionCollection.prototype, "grossAmount", {
             get: function () {
-                return this.items.reduce(function (sum, bankTransaction) { return sum + bankTransaction.balanceAmount; }, 0);
+                return +this.items.reduce(function (sum, transaction) { return sum + transaction.amount; }, 0).toFixed(2);
             },
             enumerable: false,
             configurable: true
         });
+        TransactionCollection.prototype.getByChartAccountsCategories = function (categories) {
+            return new TransactionCollection(this.items.filter(function (transaction) { return categories.includes(transaction.chartAccounts.category); }));
+        };
         /**
-         * get list of transactions for passed month
-         * @param monthIndex Month number from 0 to 11
+         * Get transactions by month
+         * @param monthIndex by which desired month should be taken
          */
-        BankTransactionCollection.prototype.getTransactionsByMonth = function (monthIndex) {
-            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return bankTransaction.date.getMonth() === monthIndex; }));
+        TransactionCollection.prototype.getByMonth = function (monthIndex) {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.date.getMonth() === monthIndex; }));
         };
         /**
-         * get list of transactions by provided bank accounts
-         * @param bankAccounts by which transactions should be returned
+         * Get collection of transactions metadata
          */
-        BankTransactionCollection.prototype.getByBankAccounts = function (bankAccounts) {
-            var bankAccountIds = bankAccounts.map(function (bankAccount) { return bankAccount.id; });
-            return this.items.filter(function (bankTransaction) { return bankAccountIds.includes(bankTransaction.bankAccount.id); });
+        TransactionCollection.prototype.getTransactionsMetadata = function () {
+            var metadataArray = [];
+            this.items.forEach(function (transaction) {
+                metadataArray.push.apply(metadataArray, __spreadArray([], __read(transaction.metadata)));
+            });
+            return new Collection(metadataArray);
+        };
+        TransactionCollection.prototype.getIncomeTransactions = function () {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isIncome(); }));
+        };
+        Object.defineProperty(TransactionCollection.prototype, "claimIncome", {
+            get: function () {
+                return this.getIncomeTransactions().claimAmount;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        TransactionCollection.prototype.getExpenseTransactions = function () {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isExpense() && !transaction.isInterest(); }));
+        };
+        Object.defineProperty(TransactionCollection.prototype, "claimExpense", {
+            get: function () {
+                return this.getExpenseTransactions().claimAmount;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        TransactionCollection.prototype.getInterestTransactions = function () {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isInterest(); }));
         };
+        Object.defineProperty(TransactionCollection.prototype, "claimInterest", {
+            get: function () {
+                return this.getInterestTransactions().claimAmount;
+            },
+            enumerable: false,
+            configurable: true
+        });
         /**
-         * get list of transactions by provided ids of bank accounts
-         * @param ids of bank accounts
+         * Get collection of transactions and properties filtered by properties ids
+         * @param ids Ids of properties for filter
          */
-        BankTransactionCollection.prototype.getByBankAccountsIds = function (ids) {
-            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return ids.includes(bankTransaction.bankAccount.id); }));
+        TransactionCollection.prototype.getByPropertiesIds = function (ids) {
+            return new TransactionCollection(this.items.filter(function (transaction) {
+                var _a;
+                return ids.includes((_a = transaction.property) === null || _a === void 0 ? void 0 : _a.id);
+            }));
         };
         /**
-         * Find Bank Transaction available for transfer
+         * Get new collection filtered by income source id
+         * @param id id of income source for filter
          */
-        BankTransactionCollection.prototype.findTransfer = function (bankTransaction) {
-            return this.items.find(function (item) {
-                return item.amount + bankTransaction.amount === 0 &&
-                    Math.abs(bankTransaction.date.getTime() - item.date.getTime()) < TRANSACTION_TRANSFER_DELAY;
-            });
+        TransactionCollection.prototype.getByIncomeSourceId = function (id) {
+            return new TransactionCollection(this.items.filter(function (transaction) { var _a; return ((_a = transaction.incomeSource) === null || _a === void 0 ? void 0 : _a.id) === id; }));
         };
         /**
-         * Group bank transactions by transaction id.
-         * Each group is bank transaction collection and contains bank transactions related to transactions via allocations
+         * Get new collection filtered by chart accounts category
+         * @param category Chart accounts category value
          */
-        BankTransactionCollection.prototype.groupByTransaction = function (allocations) {
-            var _this = this;
-            // Group allocations by transaction id
-            var allocationsByTransactions = new CollectionDictionary(allocations, 'transaction.id');
-            // Init an empty dictionary we will fill below
-            var bankTransactionsByTransactions = new CollectionDictionary(new BankTransactionCollection([]));
-            // Fill dictionary with the same keys as at allocationsByTransactions
-            allocationsByTransactions.keys.forEach(function (key) {
-                bankTransactionsByTransactions.add(key, _this.getByAllocations(allocationsByTransactions.get(key)));
-            });
-            return bankTransactionsByTransactions;
+        TransactionCollection.prototype.getByChartAccountsCategory = function (category) {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.chartAccounts.category === category; }));
         };
         /**
-         * Get collection of bank transactions related with passed allocations
+         * Get new collection of property transactions
          */
-        BankTransactionCollection.prototype.getByAllocations = function (allocations) {
-            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return allocations.hasBankTransaction(bankTransaction); }));
+        TransactionCollection.prototype.getPropertyTransactions = function () {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isPropertyTank(); }));
+        };
+        TransactionCollection.prototype.getDebitTransactions = function () {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isDebit(); }));
+        };
+        TransactionCollection.prototype.getCreditTransactions = function () {
+            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isCredit(); }));
+        };
+        TransactionCollection.prototype.getByAllocations = function (allocations) {
+            return new TransactionCollection(this.items.filter(function (transaction) { return allocations.hasTransaction(transaction); }));
         };
         /**
-         * Set allocate operation for bank transactions with amounts equal to salary
+         * Get transactions related to Vehicle category
          */
-        BankTransactionCollection.prototype.preselectAllocateOperationForSalary = function (salaryIncomeSources) {
-            // incomeSource.salaryForecasts[0] because each income source has only one forecast for current fin year
-            var salaryAmounts = salaryIncomeSources.map(function (incomeSource) { var _a; return ((_a = incomeSource.salaryForecasts[0]) === null || _a === void 0 ? void 0 : _a.netPay) || 0; });
-            this.items.forEach(function (bankTransaction) {
-                if (salaryAmounts.includes(bankTransaction.amount)) {
-                    bankTransaction.operation = exports.TransactionOperationEnum.ALLOCATE;
-                }
-            });
+        TransactionCollection.prototype.getVehicleTransactions = function () {
+            return this.create(this.items.filter(function (transaction) {
+                return transaction.isVehicleTransaction();
+            }));
         };
         /**
-         * Get collection of unallocated bankTransactions
+         * Get new transaction collection filtered by tank type
          */
-        BankTransactionCollection.prototype.getUnallocated = function (allocations) {
-            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return !bankTransaction.isAllocated(allocations); }));
-        };
-        return BankTransactionCollection;
-    }(Collection));
-
+        TransactionCollection.prototype.getByTankType = function (tankType) {
+            return this.create(this.items.filter(function (transaction) {
+                switch (tankType) {
+                    case exports.TankTypeEnum.PROPERTY:
+                        return transaction.isPropertyTank();
+                    case exports.TankTypeEnum.WORK:
+                        return transaction.isWorkTank();
+                    case exports.TankTypeEnum.SOLE:
+                        return transaction.isSoleTank();
+                    // Transaction may be not related to any tank type (personal)
+                    default:
+                        return false;
+                }
+            }));
+        };
+        TransactionCollection.prototype.getExportHeader = function () {
+            return ['Date', 'Description', 'Debit', 'Credit'];
+        };
+        TransactionCollection.prototype.getExportFooter = function () {
+            return [
+                classTransformer.plainToClass(ExportCell, { value: 'Total', type: ExportCellTypeEnum.STRING }),
+                classTransformer.plainToClass(ExportCell, { value: '', type: ExportCellTypeEnum.STRING }),
+                classTransformer.plainToClass(ExportCell, { value: this.sumBy('debit'), type: ExportCellTypeEnum.CURRENCY }),
+                classTransformer.plainToClass(ExportCell, { value: this.sumBy('credit'), type: ExportCellTypeEnum.CURRENCY })
+            ];
+        };
+        TransactionCollection.prototype.getExportBody = function () {
+            return this.items.map(function (transaction) {
+                return [
+                    classTransformer.plainToClass(ExportCell, { value: transaction.date, type: ExportCellTypeEnum.DATE }),
+                    classTransformer.plainToClass(ExportCell, { value: transaction.description, type: ExportCellTypeEnum.STRING }),
+                    classTransformer.plainToClass(ExportCell, { value: transaction.debit, type: ExportCellTypeEnum.CURRENCY }),
+                    classTransformer.plainToClass(ExportCell, { value: transaction.credit, type: ExportCellTypeEnum.CURRENCY })
+                ];
+            });
+        };
+        /**
+         * Get list of vehicle transactions filtered by vehicle claim
+         */
+        TransactionCollection.prototype.getByVehicleClaim = function (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', exports.TankTypeEnum.WORK);
+        };
+        /**
+         * Get list of vehicle transactions except KMS transactions
+         */
+        TransactionCollection.prototype.getLogbookTransactions = function () {
+            return this
+                .getVehicleTransactions()
+                .removeBy('chartAccounts.id', [exports.ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK, exports.ChartAccountsListEnum.KLMS_TRAVELLED]);
+        };
+        /**
+         * 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
+         */
+        TransactionCollection.prototype.getCashPositionChartData = function () {
+            var _this = this;
+            var chartData = [
+                classTransformer.plainToClass(ChartData, { name: 'Income', data: [] }),
+                classTransformer.plainToClass(ChartData, { name: 'Expense', data: [] })
+            ];
+            new FinancialYear().getPastMonths().forEach(function (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;
+        };
+        return TransactionCollection;
+    }(ExportableCollection));
+
+    var TransactionAllocationCollection = /** @class */ (function (_super) {
+        __extends(TransactionAllocationCollection, _super);
+        function TransactionAllocationCollection() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(TransactionAllocationCollection.prototype, "amount", {
+            get: function () {
+                return this.sumBy('amount');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        TransactionAllocationCollection.prototype.getByTransactionsIds = function (ids) {
+            return new TransactionAllocationCollection(this.items.filter(function (allocation) { return ids.includes(allocation.transaction.id); }));
+        };
+        TransactionAllocationCollection.prototype.getByBankTransactionsIds = function (ids) {
+            return new TransactionAllocationCollection(this.items.filter(function (allocation) { return ids.includes(allocation.bankTransaction.id); }));
+        };
+        /**
+         * Group allocations by bank account via bank transactions collection
+         */
+        TransactionAllocationCollection.prototype.groupByBankAccount = function (bankTransactions) {
+            var _this = this;
+            // Group bank transactions by bank account id
+            var bankTransactionsByBankAccount = new CollectionDictionary(bankTransactions, 'bankAccount.id');
+            // Create empty dictionary of transaction allocations
+            var allocationsByBankAccount = new CollectionDictionary(new TransactionAllocationCollection([]));
+            // Fill allocations dictionary with bank transactions dictionary keys and allocations related with each bank transaction collection
+            bankTransactionsByBankAccount.keys.forEach(function (key) {
+                allocationsByBankAccount.add(key, _this.getByBankTransactionsIds(bankTransactionsByBankAccount.get(key).getIds()));
+            });
+            return allocationsByBankAccount;
+        };
+        /**
+         * check if collection includes allocation of passed transaction
+         */
+        TransactionAllocationCollection.prototype.hasTransaction = function (transaction) {
+            return !!this.items.find(function (allocation) { return allocation.transaction.id === transaction.id; });
+        };
+        /**
+         * Check if bank transaction is related with current allocations
+         */
+        TransactionAllocationCollection.prototype.hasBankTransaction = function (bankTransaction) {
+            return !!this.items.find(function (allocation) { return allocation.bankTransaction.id === bankTransaction.id; });
+        };
+        return TransactionAllocationCollection;
+    }(Collection));
+
+    var TransactionBaseCollection = /** @class */ (function (_super) {
+        __extends(TransactionBaseCollection, _super);
+        function TransactionBaseCollection() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TransactionBaseCollection.prototype.getClaimAmountByBusiness = function (business) {
+            return this.filterBy('business.id', business.id)
+                .sumBy('claimAmount');
+        };
+        return TransactionBaseCollection;
+    }(Collection));
+
+    // @TODO Alex move here all collections
+
+    var AccountSetupItemCollection = /** @class */ (function (_super) {
+        __extends(AccountSetupItemCollection, _super);
+        function AccountSetupItemCollection(items) {
+            var _this = _super.call(this, compact__default["default"](items)) || this;
+            _this.sortBy('isCompleted', false);
+            return _this;
+        }
+        AccountSetupItemCollection.prototype.isCompleted = function () {
+            return this.filterBy('isCompleted', true).length === this.length;
+        };
+        return AccountSetupItemCollection;
+    }(Collection));
+
+    /**
+     * Maximal delay between transfer transactions
+     */
+    var TRANSACTION_TRANSFER_DELAY = 96 * 3600 * 1000;
+    /**
+     * Collection of bank transactions.
+     * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService
+     * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage
+     * because all amounts calculates with allocated amounts but not from bank transactions amounts.
+     */
+    var BankTransactionCollection = /** @class */ (function (_super) {
+        __extends(BankTransactionCollection, _super);
+        function BankTransactionCollection() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BankTransactionCollection.prototype.getAmount = function () {
+            return this.sumBy('amount');
+        };
+        /**
+         * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+         */
+        BankTransactionCollection.prototype.getUnallocatedAmount = function (allocations) {
+            return +(this.getAmount() - allocations.getByBankTransactionsIds(this.getIds()).amount).toFixed(2);
+        };
+        /**
+         * get date of the last transaction
+         */
+        BankTransactionCollection.prototype.getLastTransactionDate = function () {
+            return new Date(Math.max.apply(Math, this.items.map(function (bankTransaction) { return bankTransaction.date; })));
+        };
+        Object.defineProperty(BankTransactionCollection.prototype, "creditTransactions", {
+            /**
+             * get list of credit transactions
+             */
+            get: function () {
+                return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return bankTransaction.isCredit(); }));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BankTransactionCollection.prototype, "debitTransactions", {
+            /**
+             * get list of debit transactions
+             */
+            get: function () {
+                return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return bankTransaction.isDebit(); }));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BankTransactionCollection.prototype, "balanceAmount", {
+            /**
+             * get difference between debit and credit transactions amounts
+             */
+            get: function () {
+                return this.items.reduce(function (sum, bankTransaction) { return sum + bankTransaction.balanceAmount; }, 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * get list of transactions for passed month
+         * @param monthIndex Month number from 0 to 11
+         */
+        BankTransactionCollection.prototype.getTransactionsByMonth = function (monthIndex) {
+            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return bankTransaction.date.getMonth() === monthIndex; }));
+        };
+        /**
+         * get list of transactions by provided bank accounts
+         * @param bankAccounts by which transactions should be returned
+         */
+        BankTransactionCollection.prototype.getByBankAccounts = function (bankAccounts) {
+            var bankAccountIds = bankAccounts.map(function (bankAccount) { return bankAccount.id; });
+            return this.items.filter(function (bankTransaction) { return bankAccountIds.includes(bankTransaction.bankAccount.id); });
+        };
+        /**
+         * get list of transactions by provided ids of bank accounts
+         * @param ids of bank accounts
+         */
+        BankTransactionCollection.prototype.getByBankAccountsIds = function (ids) {
+            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return ids.includes(bankTransaction.bankAccount.id); }));
+        };
+        /**
+         * Find Bank Transaction available for transfer
+         */
+        BankTransactionCollection.prototype.findTransfer = function (bankTransaction) {
+            return this.items.find(function (item) {
+                return item.amount + bankTransaction.amount === 0 &&
+                    Math.abs(bankTransaction.date.getTime() - item.date.getTime()) < TRANSACTION_TRANSFER_DELAY;
+            });
+        };
+        /**
+         * Group bank transactions by transaction id.
+         * Each group is bank transaction collection and contains bank transactions related to transactions via allocations
+         */
+        BankTransactionCollection.prototype.groupByTransaction = function (allocations) {
+            var _this = this;
+            // Group allocations by transaction id
+            var allocationsByTransactions = new CollectionDictionary(allocations, 'transaction.id');
+            // Init an empty dictionary we will fill below
+            var bankTransactionsByTransactions = new CollectionDictionary(new BankTransactionCollection([]));
+            // Fill dictionary with the same keys as at allocationsByTransactions
+            allocationsByTransactions.keys.forEach(function (key) {
+                bankTransactionsByTransactions.add(key, _this.getByAllocations(allocationsByTransactions.get(key)));
+            });
+            return bankTransactionsByTransactions;
+        };
+        /**
+         * Get collection of bank transactions related with passed allocations
+         */
+        BankTransactionCollection.prototype.getByAllocations = function (allocations) {
+            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return allocations.hasBankTransaction(bankTransaction); }));
+        };
+        /**
+         * Set allocate operation for bank transactions with amounts equal to salary
+         */
+        BankTransactionCollection.prototype.preselectAllocateOperationForSalary = function (salaryIncomeSources) {
+            // incomeSource.salaryForecasts[0] because each income source has only one forecast for current fin year
+            var salaryAmounts = salaryIncomeSources.map(function (incomeSource) { var _a; return ((_a = incomeSource.salaryForecasts[0]) === null || _a === void 0 ? void 0 : _a.netPay) || 0; });
+            this.items.forEach(function (bankTransaction) {
+                if (salaryAmounts.includes(bankTransaction.amount)) {
+                    bankTransaction.operation = exports.TransactionOperationEnum.ALLOCATE;
+                }
+            });
+        };
+        /**
+         * Get collection of unallocated bankTransactions
+         */
+        BankTransactionCollection.prototype.getUnallocated = function (allocations) {
+            return new BankTransactionCollection(this.items.filter(function (bankTransaction) { return !bankTransaction.isAllocated(allocations); }));
+        };
+        return BankTransactionCollection;
+    }(Collection));
+
     var ChartAccountsCollection = /** @class */ (function (_super) {
         __extends(ChartAccountsCollection, _super);
         function ChartAccountsCollection() {
@@ -7497,330 +7893,63 @@
         }
         Object.defineProperty(ClientPortfolioReportCollection.prototype, "marketValue", {
             get: function () {
-                return this.sumBy('marketValue');
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ClientPortfolioReportCollection.prototype, "loanBalance", {
-            get: function () {
-                return this.sumBy('loanBalance');
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ClientPortfolioReportCollection.prototype, "equityPosition", {
-            get: function () {
-                return this.sumBy('equityPosition');
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ClientPortfolioReportCollection.prototype, "averageMarketValue", {
-            /**
-             * Get average market value if there are more than 1 item in the collection
-             */
-            get: function () {
-                return this.items.length > 1 ? this.marketValue / this.items.length : null;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ClientPortfolioReportCollection.prototype, "averageLoanBalance", {
-            /**
-             * Get average loan balance if there are more than 1 item in the collection
-             */
-            get: function () {
-                return this.items.length > 1 ? this.loanBalance / this.items.length : null;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ClientPortfolioReportCollection.prototype, "averageEquityPosition", {
-            /**
-             * Get average equity position if there are more than 1 item in the collection
-             */
-            get: function () {
-                return this.items.length > 1 ? this.equityPosition / this.items.length : null;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        /**
-         * Return report by provided category name
-         */
-        ClientPortfolioReportCollection.prototype.getByCategoryName = function (name) {
-            return this.items.find(function (item) { return item.category === name; });
-        };
-        return ClientPortfolioReportCollection;
-    }(Collection));
-
-    /**
-     * Chart serie class: chart data item
-     * @TODO consider rename to ChartSerieData
-     */
-    var ChartSerie = /** @class */ (function () {
-        function ChartSerie() {
-        }
-        return ChartSerie;
-    }());
-
-    /**
-     * Chart data class
-     * @TODO consider rename to ChartSerie
-     */
-    var ChartData = /** @class */ (function () {
-        function ChartData() {
-        }
-        return ChartData;
-    }());
-    __decorate([
-        classTransformer.Type(function () { return ChartSerie; })
-    ], ChartData.prototype, "data", void 0);
-
-    var MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan'];
-
-    /**
-     * Collection of transactions
-     */
-    var TransactionCollection = /** @class */ (function (_super) {
-        __extends(TransactionCollection, _super);
-        function TransactionCollection() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        Object.defineProperty(TransactionCollection.prototype, "amount", {
-            /**
-             * Get total amount of all transactions in the collection
-             */
-            get: function () {
-                return +this.items.reduce(function (sum, transaction) { return sum + transaction.getNetAmount(); }, 0).toFixed(2);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        /**
-         * Difference between allocated amount and total amount
-         */
-        TransactionCollection.prototype.getUnallocatedAmount = function (allocations) {
-            return +(this.amount - allocations.getByTransactionsIds(this.getIds()).amount).toFixed(2);
-        };
-        Object.defineProperty(TransactionCollection.prototype, "cashPosition", {
-            /**
-             * Get cash position
-             * Cash Position = Income - Expenses
-             * Cash position is equal to Total Amount because income is positive and expense is negative,
-             */
-            get: function () {
-                return this.claimAmount;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        /**
-         * get date of the last transaction
-         */
-        TransactionCollection.prototype.getLastTransactionDate = function () {
-            return new Date(Math.max.apply(Math, this.items.map(function (transaction) { return transaction.date; })));
-        };
-        Object.defineProperty(TransactionCollection.prototype, "claimAmount", {
-            /**
-             * Get summary of claim amounts
-             */
-            get: function () {
-                return this.items.reduce(function (sum, transaction) { return sum + transaction.claimAmount; }, 0);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(TransactionCollection.prototype, "grossAmount", {
-            get: function () {
-                return +this.items.reduce(function (sum, transaction) { return sum + transaction.amount; }, 0).toFixed(2);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        TransactionCollection.prototype.getByChartAccountsCategories = function (categories) {
-            return new TransactionCollection(this.items.filter(function (transaction) { return categories.includes(transaction.chartAccounts.category); }));
-        };
-        /**
-         * Get transactions by month
-         * @param monthIndex by which desired month should be taken
-         */
-        TransactionCollection.prototype.getByMonth = function (monthIndex) {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.date.getMonth() === monthIndex; }));
-        };
-        /**
-         * Get collection of transactions metadata
-         */
-        TransactionCollection.prototype.getTransactionsMetadata = function () {
-            var metadataArray = [];
-            this.items.forEach(function (transaction) {
-                metadataArray.push.apply(metadataArray, __spreadArray([], __read(transaction.metadata)));
-            });
-            return new Collection(metadataArray);
-        };
-        TransactionCollection.prototype.getIncomeTransactions = function () {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isIncome(); }));
-        };
-        Object.defineProperty(TransactionCollection.prototype, "claimIncome", {
+                return this.sumBy('marketValue');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ClientPortfolioReportCollection.prototype, "loanBalance", {
             get: function () {
-                return this.getIncomeTransactions().claimAmount;
+                return this.sumBy('loanBalance');
             },
             enumerable: false,
             configurable: true
         });
-        TransactionCollection.prototype.getExpenseTransactions = function () {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isExpense() && !transaction.isInterest(); }));
-        };
-        Object.defineProperty(TransactionCollection.prototype, "claimExpense", {
+        Object.defineProperty(ClientPortfolioReportCollection.prototype, "equityPosition", {
             get: function () {
-                return this.getExpenseTransactions().claimAmount;
+                return this.sumBy('equityPosition');
             },
             enumerable: false,
             configurable: true
         });
-        TransactionCollection.prototype.getInterestTransactions = function () {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isInterest(); }));
-        };
-        Object.defineProperty(TransactionCollection.prototype, "claimInterest", {
+        Object.defineProperty(ClientPortfolioReportCollection.prototype, "averageMarketValue", {
+            /**
+             * Get average market value if there are more than 1 item in the collection
+             */
             get: function () {
-                return this.getInterestTransactions().claimAmount;
+                return this.items.length > 1 ? this.marketValue / this.items.length : null;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ClientPortfolioReportCollection.prototype, "averageLoanBalance", {
+            /**
+             * Get average loan balance if there are more than 1 item in the collection
+             */
+            get: function () {
+                return this.items.length > 1 ? this.loanBalance / this.items.length : null;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ClientPortfolioReportCollection.prototype, "averageEquityPosition", {
+            /**
+             * Get average equity position if there are more than 1 item in the collection
+             */
+            get: function () {
+                return this.items.length > 1 ? this.equityPosition / this.items.length : null;
             },
             enumerable: false,
             configurable: true
         });
         /**
-         * Get collection of transactions and properties filtered by properties ids
-         * @param ids Ids of properties for filter
-         */
-        TransactionCollection.prototype.getByPropertiesIds = function (ids) {
-            return new TransactionCollection(this.items.filter(function (transaction) {
-                var _a;
-                return ids.includes((_a = transaction.property) === null || _a === void 0 ? void 0 : _a.id);
-            }));
-        };
-        /**
-         * Get new collection filtered by income source id
-         * @param id id of income source for filter
-         */
-        TransactionCollection.prototype.getByIncomeSourceId = function (id) {
-            return new TransactionCollection(this.items.filter(function (transaction) { var _a; return ((_a = transaction.incomeSource) === null || _a === void 0 ? void 0 : _a.id) === id; }));
-        };
-        /**
-         * Get new collection filtered by chart accounts category
-         * @param category Chart accounts category value
-         */
-        TransactionCollection.prototype.getByChartAccountsCategory = function (category) {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.chartAccounts.category === category; }));
-        };
-        /**
-         * Get new collection of property transactions
-         */
-        TransactionCollection.prototype.getPropertyTransactions = function () {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isPropertyTank(); }));
-        };
-        TransactionCollection.prototype.getDebitTransactions = function () {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isDebit(); }));
-        };
-        TransactionCollection.prototype.getCreditTransactions = function () {
-            return new TransactionCollection(this.items.filter(function (transaction) { return transaction.isCredit(); }));
-        };
-        TransactionCollection.prototype.getByAllocations = function (allocations) {
-            return new TransactionCollection(this.items.filter(function (transaction) { return allocations.hasTransaction(transaction); }));
-        };
-        /**
-         * Get transactions related to Vehicle category
-         */
-        TransactionCollection.prototype.getVehicleTransactions = function () {
-            return this.create(this.items.filter(function (transaction) {
-                return transaction.isVehicleTransaction();
-            }));
-        };
-        /**
-         * Get new transaction collection filtered by tank type
-         */
-        TransactionCollection.prototype.getByTankType = function (tankType) {
-            return this.create(this.items.filter(function (transaction) {
-                switch (tankType) {
-                    case exports.TankTypeEnum.PROPERTY:
-                        return transaction.isPropertyTank();
-                    case exports.TankTypeEnum.WORK:
-                        return transaction.isWorkTank();
-                    case exports.TankTypeEnum.SOLE:
-                        return transaction.isSoleTank();
-                    // Transaction may be not related to any tank type (personal)
-                    default:
-                        return false;
-                }
-            }));
-        };
-        TransactionCollection.prototype.getExportHeader = function () {
-            return ['Date', 'Description', 'Debit', 'Credit'];
-        };
-        TransactionCollection.prototype.getExportFooter = function () {
-            return [
-                classTransformer.plainToClass(ExportCell, { value: 'Total', type: ExportCellTypeEnum.STRING }),
-                classTransformer.plainToClass(ExportCell, { value: '', type: ExportCellTypeEnum.STRING }),
-                classTransformer.plainToClass(ExportCell, { value: this.sumBy('debit'), type: ExportCellTypeEnum.CURRENCY }),
-                classTransformer.plainToClass(ExportCell, { value: this.sumBy('credit'), type: ExportCellTypeEnum.CURRENCY })
-            ];
-        };
-        TransactionCollection.prototype.getExportBody = function () {
-            return this.items.map(function (transaction) {
-                return [
-                    classTransformer.plainToClass(ExportCell, { value: transaction.date, type: ExportCellTypeEnum.DATE }),
-                    classTransformer.plainToClass(ExportCell, { value: transaction.description, type: ExportCellTypeEnum.STRING }),
-                    classTransformer.plainToClass(ExportCell, { value: transaction.debit, type: ExportCellTypeEnum.CURRENCY }),
-                    classTransformer.plainToClass(ExportCell, { value: transaction.credit, type: ExportCellTypeEnum.CURRENCY })
-                ];
-            });
-        };
-        /**
-         * Get list of vehicle transactions filtered by vehicle claim
-         */
-        TransactionCollection.prototype.getByVehicleClaim = function (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', exports.TankTypeEnum.WORK);
-        };
-        /**
-         * Get list of vehicle transactions except KMS transactions
-         */
-        TransactionCollection.prototype.getLogbookTransactions = function () {
-            return this
-                .getVehicleTransactions()
-                .removeBy('chartAccounts.id', [exports.ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK, exports.ChartAccountsListEnum.KLMS_TRAVELLED]);
-        };
-        /**
-         * 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
+         * Return report by provided category name
          */
-        TransactionCollection.prototype.getCashPositionChartData = function () {
-            var _this = this;
-            var chartData = [
-                classTransformer.plainToClass(ChartData, { name: 'Income', data: [] }),
-                classTransformer.plainToClass(ChartData, { name: 'Expense', data: [] })
-            ];
-            new FinancialYear().getPastMonths().forEach(function (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;
+        ClientPortfolioReportCollection.prototype.getByCategoryName = function (name) {
+            return this.items.find(function (item) { return item.category === name; });
         };
-        return TransactionCollection;
-    }(ExportableCollection));
+        return ClientPortfolioReportCollection;
+    }(Collection));
 
     var DepreciationCollection = /** @class */ (function (_super) {
         __extends(DepreciationCollection, _super);
@@ -8639,7 +8768,11 @@
                 exports.TaxReturnCategoryListEnum.DEPRECIATION_EXPENSES,
                 exports.TaxReturnCategoryListEnum.MOTOR_VEHICLE_EXPENSES,
                 exports.TaxReturnCategoryListEnum.ALL_OTHER_EXPENSES
-            ]
+            ],
+            // @TODO TT-2386 Nikita to move sole tax offsets in separated category
+            taxOffsets: [
+                exports.TaxReturnCategoryListEnum.TAX_OFFSETS
+            ],
         },
     };
 
@@ -8701,54 +8834,6 @@
         return TaxReviewCollection;
     }(Collection));
 
-    var TransactionAllocationCollection = /** @class */ (function (_super) {
-        __extends(TransactionAllocationCollection, _super);
-        function TransactionAllocationCollection() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        Object.defineProperty(TransactionAllocationCollection.prototype, "amount", {
-            get: function () {
-                return this.sumBy('amount');
-            },
-            enumerable: false,
-            configurable: true
-        });
-        TransactionAllocationCollection.prototype.getByTransactionsIds = function (ids) {
-            return new TransactionAllocationCollection(this.items.filter(function (allocation) { return ids.includes(allocation.transaction.id); }));
-        };
-        TransactionAllocationCollection.prototype.getByBankTransactionsIds = function (ids) {
-            return new TransactionAllocationCollection(this.items.filter(function (allocation) { return ids.includes(allocation.bankTransaction.id); }));
-        };
-        /**
-         * Group allocations by bank account via bank transactions collection
-         */
-        TransactionAllocationCollection.prototype.groupByBankAccount = function (bankTransactions) {
-            var _this = this;
-            // Group bank transactions by bank account id
-            var bankTransactionsByBankAccount = new CollectionDictionary(bankTransactions, 'bankAccount.id');
-            // Create empty dictionary of transaction allocations
-            var allocationsByBankAccount = new CollectionDictionary(new TransactionAllocationCollection([]));
-            // Fill allocations dictionary with bank transactions dictionary keys and allocations related with each bank transaction collection
-            bankTransactionsByBankAccount.keys.forEach(function (key) {
-                allocationsByBankAccount.add(key, _this.getByBankTransactionsIds(bankTransactionsByBankAccount.get(key).getIds()));
-            });
-            return allocationsByBankAccount;
-        };
-        /**
-         * check if collection includes allocation of passed transaction
-         */
-        TransactionAllocationCollection.prototype.hasTransaction = function (transaction) {
-            return !!this.items.find(function (allocation) { return allocation.transaction.id === transaction.id; });
-        };
-        /**
-         * Check if bank transaction is related with current allocations
-         */
-        TransactionAllocationCollection.prototype.hasBankTransaction = function (bankTransaction) {
-            return !!this.items.find(function (allocation) { return allocation.bankTransaction.id === bankTransaction.id; });
-        };
-        return TransactionAllocationCollection;
-    }(Collection));
-
     /**
      * Collection of user event settings
      */
@@ -11652,7 +11737,6 @@
         });
         Object.defineProperty(TaxSummary.prototype, "soleNetCash", {
             /**
-             * @TODO Nicole update documentation + check calculations
              * Sole Net Cash = gross income – expenses
              * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
              */
@@ -11666,7 +11750,6 @@
         });
         Object.defineProperty(TaxSummary.prototype, "soleNetTotal", {
             /**
-             * @TODO Nicole update documentation + check calculations
              * Sole Net Total = Gross income - expenses
              * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
              */
@@ -11921,6 +12004,29 @@
                     }]
             }] });
 
+    /**
+     * @TODO vik replace with json when the final list is confirmed
+     */
+    var SoleBusinessLossOffsetRuleService = /** @class */ (function (_super) {
+        __extends(SoleBusinessLossOffsetRuleService, _super);
+        function SoleBusinessLossOffsetRuleService() {
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.modelClass = SoleBusinessLossOffsetRule;
+            _this.url = 'sole-business-loss-offset-rules';
+            _this.isHydra = true;
+            return _this;
+        }
+        return SoleBusinessLossOffsetRuleService;
+    }(RestService));
+    SoleBusinessLossOffsetRuleService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SoleBusinessLossOffsetRuleService, deps: null, target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    SoleBusinessLossOffsetRuleService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SoleBusinessLossOffsetRuleService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SoleBusinessLossOffsetRuleService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }] });
+
     var SoleContactService = /** @class */ (function (_super) {
         __extends(SoleContactService, _super);
         function SoleContactService() {
@@ -17759,6 +17865,33 @@
         return SoleBusinessAllocationsForm;
     }(forms.FormArray));
 
+    var SoleBusinessLossForm = /** @class */ (function (_super) {
+        __extends(SoleBusinessLossForm, _super);
+        function SoleBusinessLossForm(loss, balance) {
+            var _this = this;
+            var _a;
+            _this = _super.call(this, {
+                openBalance: new forms.FormControl(loss.openBalance, forms.Validators.required),
+                offsetRule: new forms.FormControl((_a = loss.offsetRule) === null || _a === void 0 ? void 0 : _a.id),
+                // sum of depreciations/transactions claim amount - openBalance
+                balance: new forms.FormControl({ value: balance, disabled: true }),
+            }, loss) || this;
+            _this.loss = loss;
+            _this.get('openBalance').valueChanges.subscribe(function (openBalance) {
+                _this.get('balance').setValue(balance - openBalance);
+            });
+            return _this;
+        }
+        /**
+         * radio buttons can't work with object
+         * https://github.com/angular/components/issues/10495
+         */
+        SoleBusinessLossForm.prototype.submit = function () {
+            return _super.prototype.submit.call(this, { offsetRule: this.get('offsetRule').value ? { id: this.get('offsetRule').value } : null });
+        };
+        return SoleBusinessLossForm;
+    }(AbstractForm));
+
     var SoleContactForm = /** @class */ (function (_super) {
         __extends(SoleContactForm, _super);
         function SoleContactForm(contact) {
@@ -19281,6 +19414,9 @@
     exports.SoleBusinessAllocationsForm = SoleBusinessAllocationsForm;
     exports.SoleBusinessForm = SoleBusinessForm;
     exports.SoleBusinessLoss = SoleBusinessLoss;
+    exports.SoleBusinessLossForm = SoleBusinessLossForm;
+    exports.SoleBusinessLossOffsetRule = SoleBusinessLossOffsetRule;
+    exports.SoleBusinessLossOffsetRuleService = SoleBusinessLossOffsetRuleService;
     exports.SoleBusinessLossReport = SoleBusinessLossReport;
     exports.SoleBusinessLossService = SoleBusinessLossService;
     exports.SoleBusinessService = SoleBusinessService;
@@ -19325,6 +19461,7 @@
     exports.TransactionAllocationCollection = TransactionAllocationCollection;
     exports.TransactionAllocationService = TransactionAllocationService;
     exports.TransactionBase = TransactionBase;
+    exports.TransactionBaseCollection = TransactionBaseCollection;
     exports.TransactionCalculationService = TransactionCalculationService;
     exports.TransactionCollection = TransactionCollection;
     exports.TransactionMetadata = TransactionMetadata;