taxtank-core 0.0.2 → 0.0.3

package/lib/services/bank/bank-transaction-calculation.service.d.ts

@@ -0,0 +1,41 @@
+import { BankTransactionCollection } from '../../collections/bank-transaction.collection';
+import { BankTransaction } from '../../models/bank/bank-transaction';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+import * as i0 from "@angular/core";
+/**
+ * @TODO move to collection
+ */
+export declare class BankTransactionCalculationService {
+    /**
+     * Sum of allocations for passed bank transactions
+     */
+    getAllocatedAmount(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number;
+    /**
+     * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+     */
+    getUnallocatedAmount(bankTransactionCollection: BankTransactionCollection, allocations: TransactionAllocationCollection): number;
+    /**
+     * Check if bank transaction is allocated
+     */
+    isAllocated(bankTransaction: BankTransaction, allocations: TransactionAllocationCollection): boolean;
+    /**
+     * Get collection of allocated bank transactions
+     * @TODO Alex: consider to move to collection
+     */
+    getAllocatedBankTransactions(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): BankTransactionCollection;
+    /**
+     * Get collection of unallocated bank transactions
+     * @TODO Alex: consider to move to collection
+     */
+    getUnallocatedBankTransactions(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): BankTransactionCollection;
+    /**
+     * Allocated sum of credit transactions
+     */
+    getCreditAmount(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number;
+    /**
+     * Allocated sum of debit transactions
+     */
+    getDebitAmount(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BankTransactionCalculationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BankTransactionCalculationService>;
+}

package/lib/services/bank/bank-transaction.service.d.ts

@@ -0,0 +1,38 @@
+import { BankTransaction as BankTransactionBase } from '../../db/Models/bank-transaction';
+import { Observable } from 'rxjs';
+import { BaseRestService } from '../base-rest.service';
+import { HttpClient } from '@angular/common/http';
+import { BankTransaction } from '../../models/bank/bank-transaction';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for bank transactions business logic
+ */
+export declare class BankTransactionService extends BaseRestService<BankTransactionBase, BankTransaction> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof BankTransaction;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    private listenEvents;
+    /**
+     * get list of bank transactions for passed bank account id
+     * @param bankAccountId Id of bank account we search bank transactions for
+     */
+    getByBankAccountId(bankAccountId: number): Observable<BankTransaction[]>;
+    /**
+     * Get list of bank transactions for provided financial year
+     * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years
+     */
+    getTransactionsByYear(finYear: number): Observable<BankTransaction[]>;
+    /**
+     * import bank transactions from csv file
+     * @param bankAccountId Bank account id we import bank transactions for
+     * @param file File with bank transactions for import
+     */
+    import(bankAccountId: number, file: File): Observable<BankTransaction[]>;
+    private listenBankTransactionsImport;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BankTransactionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BankTransactionService>;
+}

package/lib/services/bank/bank.service.d.ts

@@ -0,0 +1,14 @@
+import { Bank as BankBase } from '../../db/Models/bank';
+import { Bank } from '../../models/bank/bank';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling banks logic
+ */
+export declare class BankService extends BaseRestService<BankBase, Bank> {
+    modelClass: typeof Bank;
+    url: string;
+    isHydra: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BankService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BankService>;
+}

package/lib/services/bank/basiq.service.d.ts

@@ -0,0 +1,42 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { BankAccount as BankAccountBase } from '../../db/Models/bank-account';
+import { BaseRestService } from '../base-rest.service';
+import { BankAccount } from '../../models/bank/bank-account';
+import { BasiqToken } from '../../models/bank/basiq-token';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { BankConnection } from '../../models/bank/bank-connection';
+import * as i0 from "@angular/core";
+/**
+ * basiq is a middleman between bank and user
+ * service is responsible for fetching bank related information
+ */
+export declare class BasiqService extends BaseRestService<BankAccountBase, BankAccount> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    token: BasiqToken;
+    tokenSubject: ReplaySubject<BasiqToken>;
+    url: string;
+    modelClass: typeof BankAccount;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Listen events from Event Dispatcher service
+     */
+    listenEvents(): void;
+    /**
+     * access token to use basiq connect ui iframe
+     */
+    getToken(): Observable<BasiqToken>;
+    getConnections(): Observable<BankConnection[]>;
+    /**
+     * Listen to EventDispatcherService event related to added Bank connection
+     */
+    private listenToBankConnectionAdded;
+    /**
+     * listen to notifications to update basiq accounts list
+     */
+    private listenNotifications;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasiqService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BasiqService>;
+}

package/lib/services/base-rest.service.d.ts

@@ -0,0 +1,91 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from './event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base service that implements common services functionality
+ * and describe abstract methods/properties that have to be implemented in child services
+ * Model - entity service is working with
+ * BaseModel - base entity model that extends by Model
+ */
+export declare abstract class BaseRestService<BaseModel, Model extends BaseModel> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    abstract url: string;
+    abstract modelClass: any;
+    protected cache: Model[];
+    protected cacheSubject: ReplaySubject<Model[]>;
+    protected isHydra: boolean;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * get cached list of all instances
+     */
+    get(): Observable<Model[]>;
+    /**
+     * get instance by id from cache
+     * @param id ID of required item
+     */
+    getById(id: number): Observable<Model>;
+    /**
+     * get list of items filtered by id.
+     * @param models Array of objects contains required items ids
+     */
+    getByIds(models: Model[]): Observable<Model[]>;
+    /**
+     * add new instance and update cache
+     * @TODO rename to post
+     */
+    add(model: Model, shouldUpdateCache?: boolean): Observable<Model>;
+    /**
+     * Add several new items
+     * @param models Array of new items for saving
+     * @param queryParams query parameters for request
+     * @TODO rename to postBatch
+     */
+    addBatch(models: Model[], queryParams?: object): Observable<Model[]>;
+    /**
+     * Update item
+     * @param model Existing instance for updating
+     * @param queryParams query parameters for request
+     * @TODO rename to put
+     */
+    update(model: Model, queryParams?: object): Observable<Model>;
+    /**
+     * Update several items
+     * @param models Array of items for updating
+     * @param queryParams query parameters for request
+     * TODO rename to putBatch
+     */
+    updateBatch(models: Model[], queryParams?: object): Observable<Model[]>;
+    /**
+     * delete instance of class
+     * @param model Class instance for deleting
+     */
+    delete(model: Model): Observable<void>;
+    /**
+     * delete multiple instances of class
+     * @param models Class instances array for deleting
+     */
+    deleteBatch(models: Model[]): Observable<void>;
+    /**
+     * clear service cache
+     */
+    resetCache(): void;
+    /**
+     * get list of base class instances directly from backend
+     */
+    protected fetch(): Observable<Model[]>;
+    /**
+     * Update cache subject with current cache array value
+     */
+    protected updateCache(): void;
+    /**
+     * Create new instance of class
+     * @param model The class for which you want to create an instance
+     * @param baseModel base model instance that we will use as constructor options
+     */
+    protected createModelInstance(model: new (bm: BaseModel) => Model, baseModel: BaseModel): Model;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseRestService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseRestService<any, any>>;
+}

package/lib/services/borrowing-expense/borrowing-expense.service.d.ts

@@ -0,0 +1,19 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { BorrowingExpense } from '../../models/borrowing-expense/borrowing-expense';
+import { Loan } from '../../models/loan/loan';
+import * as i0 from "@angular/core";
+export declare class BorrowingExpenseService {
+    private http;
+    protected environment: any;
+    _borrowingExpenses: BorrowingExpense[];
+    borrowingExpensesSubject: ReplaySubject<BorrowingExpense[]>;
+    constructor(http: HttpClient, environment: any);
+    /**
+     * Get borrowing expenses
+     */
+    get(): Observable<BorrowingExpense[]>;
+    getLoanBorrowingExpenses(loan?: Loan): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BorrowingExpenseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BorrowingExpenseService>;
+}

package/lib/services/chart-accounts/chart-accounts-depreciations.service.d.ts

@@ -0,0 +1,19 @@
+import { BaseRestService } from '../base-rest.service';
+import { ChartAccountsDepreciation as ChartAccountsDepreciationBase } from '../../db/Models/chart-accounts-depreciation';
+import { Observable } from 'rxjs';
+import { ChartAccountsDepreciation } from '../../models/chart-accounts/chart-accounts-depreciation';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with depreciation chart accounts
+ */
+export declare class ChartAccountsDepreciationService extends BaseRestService<ChartAccountsDepreciationBase, ChartAccountsDepreciation> {
+    url: string;
+    modelClass: typeof ChartAccountsDepreciation;
+    isHydra: boolean;
+    /**
+     * Get depreciation chart accounts for current financial year
+     */
+    getCurrent(): Observable<ChartAccountsDepreciation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartAccountsDepreciationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartAccountsDepreciationService>;
+}

package/lib/services/chart-accounts/chart-accounts.service.d.ts

@@ -0,0 +1,37 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { ChartAccountsCategoryEnum } from '../../db/Enums/chart-accounts-category.enum';
+import { ChartAccounts } from '../../models/chart-accounts/chart-accounts';
+import { ChartAccountsHeading } from '../../models/chart-accounts/chart-accounts-heading';
+import * as i0 from "@angular/core";
+/**
+ * Chart accounts service
+ */
+export declare class ChartAccountsService {
+    private http;
+    private environment;
+    _chartAccounts: ChartAccounts[];
+    chartAccountsSubject: ReplaySubject<ChartAccounts[]>;
+    constructor(http: HttpClient, environment: any);
+    /**
+     * get all parent and child chart accounts and group it
+     */
+    getChartAccounts(): Observable<ChartAccounts[]>;
+    /**
+     * Get list of chart accounts heading
+     * @param categories
+     */
+    getChartAccountsHeadings(categories?: ChartAccountsCategoryEnum[]): Observable<ChartAccountsHeading[]>;
+    /**
+     * Get heading of chart accounts by it Id
+     * @param id
+     */
+    getHeadingByChartAccountsId(id: number): Observable<ChartAccountsHeading>;
+    /**
+     * Get chart accounts by Id
+     * @param id
+     */
+    getChartAccountsById(id: number): Observable<ChartAccounts>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartAccountsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartAccountsService>;
+}

package/lib/services/chat/chat.service.d.ts

@@ -0,0 +1,31 @@
+import { Chat as ChatBase } from '../../db/Models/chat';
+import { HttpClient } from '@angular/common/http';
+import { SseService } from '../event/sse.service';
+import { BaseRestService } from '../base-rest.service';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { Chat } from '../../models/chat/chat';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with chats
+ */
+export declare class ChatService extends BaseRestService<ChatBase, Chat> implements IEventListener {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    private sseService;
+    modelClass: typeof Chat;
+    url: string;
+    isHydra: boolean;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any, sseService: SseService);
+    /**
+     * SSE and Event Dispatcher Services listeners
+     */
+    listenEvents(): void;
+    /**
+     * Listen chats events
+     */
+    listenChats(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatService>;
+}

package/lib/services/chat/message-document.service.d.ts

@@ -0,0 +1,50 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { MessageDocument } from '../../models/chat/message-document';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Message Documents
+ */
+export declare class MessageDocumentService implements IEventListener {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    cache: Readonly<Array<Readonly<MessageDocument>>>;
+    cacheSubject: ReplaySubject<Readonly<Array<Readonly<MessageDocument>>>>;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * SSE and Event Dispatcher Services listeners
+     */
+    listenEvents(): void;
+    /**
+     * listen new messages event to update documents cache
+     */
+    listenMessages(): void;
+    /**
+     * get list of message documents
+     */
+    get(): Observable<Readonly<MessageDocument[]>>;
+    /**
+     * Upload file to chat
+     * @param chatId
+     * @param file
+     */
+    add(chatId: number, file: File): Observable<MessageDocument>;
+    /**
+     * Upload multiple files to chat
+     * @param chatId
+     * @param files
+     */
+    addBatch(chatId: number, files: File[]): Observable<MessageDocument[]>;
+    /**
+     * Delete uploaded chat document
+     * @param chatId
+     * @param documentId
+     */
+    delete(chatId: number, documentId: number): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDocumentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageDocumentService>;
+}

package/lib/services/chat/message.service.d.ts

@@ -0,0 +1,31 @@
+import { Message as MessageBase } from '../../db/Models/message';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { HttpClient } from '@angular/common/http';
+import { Message } from '../../models/chat/message';
+import { BaseRestService } from '../base-rest.service';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { SseService } from '../event/sse.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with messages
+ */
+export declare class MessageService extends BaseRestService<MessageBase, Message> implements IEventListener {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    private sseService;
+    modelClass: typeof Message;
+    url: string;
+    isHydra: boolean;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any, sseService: SseService);
+    /**
+     * SSE and Event Dispatcher Services listeners
+     */
+    listenEvents(): void;
+    /**
+     * subscribe to new chat messages
+     */
+    private listenMessages;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}

package/lib/services/client/client-invite.service.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { ClientInvite as ClientInviteBase } from '../../db/Models/client-invite';
+import { BaseRestService } from '../base-rest.service';
+import { ClientInvite } from '../../models/client/client-invite';
+import * as i0 from "@angular/core";
+export declare class ClientInviteService extends BaseRestService<ClientInviteBase, ClientInvite> {
+    url: string;
+    modelClass: typeof ClientInvite;
+    /**
+     * Import employees for firm from CSV file
+     * @param file
+     */
+    import(file: File): Observable<ClientInvite[]>;
+    /**
+     * Accept client invitation from firm to user
+     * @param invite
+     */
+    accept(invite: ClientInvite): Observable<any>;
+    /**
+     * Reject client invitation from firm to user
+     * @param invite
+     */
+    reject(invite: ClientInvite): Observable<ClientInvite>;
+    /**
+     * Resend invitation from firm to client
+     * @param invite
+     */
+    resend(invite: ClientInvite): Observable<ClientInvite>;
+    /**
+     * Send invitation from client to firm
+     * @param invite
+     */
+    inviteFirmByUser(invite: ClientInvite): Observable<ClientInvite>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientInviteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientInviteService>;
+}

package/lib/services/client/client-movement.service.d.ts

@@ -0,0 +1,40 @@
+import { ClientMovement as ClientMovementBase } from '../../db/Models/client-movement';
+import { Observable } from 'rxjs';
+import { ClientMovementCollection } from '../../collections/client-movement.collection';
+import { FirmTypeEnum } from '../../db/Enums/firm-type.enum';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { ClientMovement } from '../../models/client/client-movement';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+export declare class ClientMovementService extends BaseRestService<ClientMovementBase, ClientMovement> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof ClientMovement;
+    url: string;
+    isHydra: boolean;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * @TODO BaseRestService should return collection
+     */
+    getAll(): Observable<ClientMovementCollection>;
+    getActive(): Observable<ClientMovementCollection>;
+    getActiveByFirmType(type: FirmTypeEnum): Observable<ClientMovementCollection>;
+    update(movement: ClientMovement): Observable<ClientMovement>;
+    updateBatch(clientMovements: ClientMovement[]): Observable<ClientMovement[]>;
+    /**
+     * Reject current firm
+     */
+    close(clientMovement: ClientMovement): Observable<void>;
+    /**
+     * Listen Event Dispatcher service
+     */
+    listenEvents(): void;
+    /**
+     * Listen to EventDispatcherService event related to clients invitations
+     */
+    private listenClientInvites;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientMovementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientMovementService>;
+}

package/lib/services/client/client-portfolio-report.service.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { ClientPortfolioReportCollection } from '../../collections/client-portfolio-report.collection';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with employee clients tax summary data
+ */
+export declare class ClientPortfolioReportService {
+    private http;
+    private environment;
+    url: string;
+    constructor(http: HttpClient, environment: any);
+    get(): Observable<ClientPortfolioReportCollection>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientPortfolioReportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientPortfolioReportService>;
+}

package/lib/services/depreciation/capital-project.service.d.ts

@@ -0,0 +1,20 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { DepreciationCapitalProject } from '../../models/depreciation/depreciation-capital-project';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with DepreciationCapitalProjects
+ */
+export declare class CapitalProjectService {
+    private http;
+    private environment;
+    cache: DepreciationCapitalProject[];
+    cacheSubject: ReplaySubject<DepreciationCapitalProject[]>;
+    constructor(http: HttpClient, environment: any);
+    get(propertyId: number): Observable<DepreciationCapitalProject[]>;
+    add(capitalProject: DepreciationCapitalProject, propertyId: number): Observable<void>;
+    update(capitalProject: DepreciationCapitalProject, propertyId: number): Observable<void>;
+    delete(capitalProject: DepreciationCapitalProject, propertyId: number): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CapitalProjectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CapitalProjectService>;
+}

package/lib/services/depreciation/depreciation.service.d.ts

@@ -0,0 +1,59 @@
+import { Observable } from 'rxjs';
+import { Depreciation as DepreciationBase } from '../../db/Models/depreciation';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { Depreciation } from '../../models/depreciation/depreciation';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+export declare class DepreciationService extends BaseRestService<DepreciationBase, Depreciation> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof Depreciation;
+    url: string;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Add a single depreciation
+     * @TODO add auto-generation for events
+     */
+    add(depreciation: Depreciation): Observable<Depreciation>;
+    /**
+     * Add multiple depreciations
+     * @TODO add auto-generation for events
+     */
+    addBatch(depreciations: Depreciation[]): Observable<Depreciation[]>;
+    /**
+     * Listen to Depreciations events
+     */
+    listenEvents(): void;
+    /**
+     * Get depreciations related to Vehicle category
+     */
+    getVehicleDepreciations(): Observable<Depreciation[]>;
+    getCloseBalance(depreciation: Depreciation): Observable<number>;
+    /**
+     * @TODO wrong place, move to collection model
+     */
+    calculateSummaryAmount(depreciationList: Depreciation[]): number;
+    calculateBorrowingExpenses(depreciationList: Depreciation[]): Observable<number>;
+    calculateDepreciations(depreciationList: Depreciation[]): Observable<number>;
+    /**
+     * Upload depreciation receipt
+     * @param depreciation for which will be uploaded receipt
+     */
+    uploadReceipt(depreciation: Depreciation): void;
+    /**
+     * Listen to EventDispatcherService event related to updated bank loan
+     */
+    private listenToUpdatedLoan;
+    /**
+     * Listen to EventDispatcherService event related to updated bank account
+     */
+    private listenToUpdatedBankAccount;
+    /**
+     * Listen to EventDispatcherService event related to updated vehicle claim
+     */
+    private listenToVehicleClaim;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DepreciationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DepreciationService>;
+}

package/lib/services/document/document-folder.service.d.ts

@@ -0,0 +1,40 @@
+import { DocumentFolder as DocumentFolderBase } from '../../db/Models/document-folder';
+import { HttpClient } from '@angular/common/http';
+import { Document } from '../../models/document/document';
+import { Observable } from 'rxjs';
+import { BaseRestService } from '../base-rest.service';
+import { DocumentFolder } from '../../models/document/document-folder';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service to handle document-folders and depending documents logic
+ */
+export declare class DocumentFolderService extends BaseRestService<DocumentFolderBase, DocumentFolder> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof DocumentFolder;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Add new document to the folder
+     * @param file to be uploaded to the folder
+     * @param folder for document
+     */
+    addDocument(file: File, folder: DocumentFolder): Observable<void>;
+    /**
+     * Edit folder document by moving it from one folder to another
+     * @param editedDocument
+     * @param selectedFolder to move the document to
+     * @param oldFolderId: id of old folder from which need to remove the document
+     */
+    updateDocument(editedDocument: Document, selectedFolder: DocumentFolder, oldFolderId: number): Observable<void>;
+    /**
+     * Delete document from folder
+     * @param document to remove
+     * @param folder from which document should be removed
+     */
+    deleteDocument(document: Document, folder: DocumentFolder): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentFolderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentFolderService>;
+}

package/lib/services/employee/employee-invite.service.d.ts

@@ -0,0 +1,21 @@
+import { EmployeeInvite as EmployeeInviteBase } from '../../db/Models/employee-invite';
+import { Observable } from 'rxjs';
+import { EmployeeInvite } from '../../models/employee/employee-invite';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+export declare class EmployeeInviteService extends BaseRestService<EmployeeInviteBase, EmployeeInvite> {
+    url: string;
+    modelClass: typeof EmployeeInvite;
+    /**
+     * Import employees for firm from CSV file
+     * @param file
+     */
+    import(file: File): Observable<EmployeeInvite[]>;
+    /**
+     * Resend invitation from firm to client
+     * @param invite
+     */
+    resend(invite: EmployeeInvite): Observable<EmployeeInvite>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmployeeInviteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmployeeInviteService>;
+}