taxtank-core 0.0.2 → 0.1.2

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

@@ -0,0 +1,16 @@
+import { BaseRestService } from '../base-rest.service';
+import { User as UserBase } from '../../db/Models/user';
+import { Observable } from 'rxjs';
+import { User } from '../../models/user/user';
+import * as i0 from "@angular/core";
+export declare class EmployeeService extends BaseRestService<UserBase, User> {
+    url: string;
+    modelClass: typeof User;
+    /**
+     * Grant/Remove Manager role to employee
+     * @param employee
+     */
+    toggleManagerRole(employee: User): Observable<User>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmployeeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmployeeService>;
+}

package/lib/services/event/event-dispatcher.service.d.ts

@@ -0,0 +1,17 @@
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class EventDispatcherService {
+    private eventSubject;
+    /**
+     * subscription to specific event type
+     */
+    on(eventType: AppEventTypeEnum | AppEventTypeEnum[]): Observable<any>;
+    /**
+     * deliver new event
+     */
+    dispatch<T>(event: AppEvent<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventDispatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventDispatcherService>;
+}

package/lib/services/event/sse.service.d.ts

@@ -0,0 +1,16 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { JwtService } from '../auth/jwt.service';
+import * as i0 from "@angular/core";
+export declare class SseService {
+    private zone;
+    private jwtService;
+    private environment;
+    constructor(zone: NgZone, jwtService: JwtService, environment: any);
+    /**
+     * list to url for server events
+     */
+    on(topic: string): Observable<object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SseService>;
+}

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

@@ -0,0 +1,27 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { FirmTypeEnum } from '../../db/Enums/firm-type.enum';
+import { Firm } from '../../db/Models/firm';
+import * as i0 from "@angular/core";
+export declare class FirmService {
+    private http;
+    protected environment: any;
+    firm: Firm;
+    firmSubject: ReplaySubject<Firm>;
+    constructor(http: HttpClient, environment: any);
+    /**
+     * Register new firm
+     * @param data: firm and firm owner data to register
+     */
+    register(data: Firm): Observable<Firm>;
+    get(): Observable<Firm>;
+    update(firm: Firm): Observable<void>;
+    /**
+     * get list of all registered firms
+     */
+    getAll(): Observable<Firm[]>;
+    getByType(type: FirmTypeEnum): Observable<Firm[]>;
+    updatePhoto(firm: Firm, photo: FormData): Observable<Firm>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FirmService>;
+}

package/lib/services/header-title/header-title.service.d.ts

@@ -0,0 +1,11 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class HeaderTitleService {
+    private router;
+    private activatedRoute;
+    constructor(router: Router, activatedRoute: ActivatedRoute);
+    handleTitle(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeaderTitleService>;
+}

package/lib/services/income-source/income-source-forecast.service.d.ts

@@ -0,0 +1,36 @@
+import { HttpClient } from '@angular/common/http';
+import { IncomeSourceForecast as IncomeSourceForecastBase } from '../../db/Models/income-source-forecast';
+import { BaseRestService } from '../base-rest.service';
+import { IncomeSourceForecast } from '../../models/income-source/income-source-forecast';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with Other Income Forecasts
+ */
+export declare class IncomeSourceForecastService extends BaseRestService<IncomeSourceForecastBase, IncomeSourceForecast> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof IncomeSourceForecast;
+    url: string;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Listen to Income Sources events
+     */
+    listenEvents(): void;
+    /**
+     * Listen to EventDispatcherService event related to added Income Sources
+     */
+    private listenToAddedIncomeSources;
+    /**
+     * Listen to EventDispatcherService event related to updated Income Sources
+     */
+    private listenToUpdatedIncomeSources;
+    /**
+     * Assign other income forecasts based on provided income sources
+     * @param incomeSources by which other income forecasts will be assigned
+     */
+    private assignIncomeSourceForecasts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncomeSourceForecastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IncomeSourceForecastService>;
+}

package/lib/services/income-source/income-source.service.d.ts

@@ -0,0 +1,48 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { IncomeSource as IncomeSourceBase } from '../../db/Models/income-source';
+import { BaseRestService } from '../base-rest.service';
+import { IncomeSourceType } from '../../models/income-source/income-source-type';
+import { SalaryForecast } from '../../models/income-source/salary-forecast';
+import { IncomeSourceTypeEnum } from '../../db/Enums/income-source-type.enum';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { IncomeSource } from '../../models/income-source/income-source';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with income sources
+ */
+export declare class IncomeSourceService extends BaseRestService<IncomeSourceBase, IncomeSource> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof IncomeSource;
+    incomeSourceTypes: IncomeSourceType[];
+    incomeSourceTypeSubject: ReplaySubject<IncomeSourceType[]>;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Get income sources tax calculation
+     * @param salaryForecast for which tax should be calculated
+     */
+    getTaxCalculation(salaryForecast: SalaryForecast): Observable<SalaryForecast>;
+    /**
+     * Add batch of income sources
+     * @param incomeSources to add
+     */
+    addBatch(incomeSources: IncomeSource[]): Observable<IncomeSource[]>;
+    /**
+     * Update batch of income sources
+     */
+    updateBatch(incomeSources: IncomeSource[], queryParams?: object): Observable<IncomeSource[]>;
+    /**
+     * Get income sources by provided types
+     * @param types
+     */
+    getByTypes(types: IncomeSourceTypeEnum[]): Observable<IncomeSource[]>;
+    /**
+     * Get other incomes types
+     */
+    getIncomeSourceTypes(): Observable<IncomeSourceType[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncomeSourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IncomeSourceService>;
+}

package/lib/services/income-source/salary-forecast.service.d.ts

@@ -0,0 +1,37 @@
+import { SalaryForecast as SalaryForecastBase } from '../../db/Models/salary-forecast';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { SalaryForecast } from '../../models/income-source/salary-forecast';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with Salary Forecasts
+ */
+export declare class SalaryForecastService extends BaseRestService<SalaryForecastBase, SalaryForecast> implements IEventListener {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof SalaryForecast;
+    url: string;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Listen to Income Sources events
+     */
+    listenEvents(): void;
+    /**
+     * Listen to EventDispatcherService event related to added Income Sources
+     */
+    private listenToAddedIncomeSources;
+    /**
+     * Listen to EventDispatcherService event related to updated Income Sources
+     */
+    private listenToUpdatedIncomeSources;
+    /**
+     * Assign salary forecasts based on provided income sources
+     * @param incomeSources by which salary forecasts will be assigned
+     */
+    private assignSalaryForecasts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SalaryForecastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SalaryForecastService>;
+}

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

@@ -0,0 +1,21 @@
+import { User } from '../../models/user/user';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with intercom
+ */
+export declare class IntercomService {
+    private environment;
+    constructor(environment: any);
+    /**
+     * Init object with user credentials
+     * @param user
+     */
+    initUser(user: User): object;
+    /**
+     * Init connection for provided data
+     * @param user
+     */
+    initConnection(user: User): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntercomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntercomService>;
+}

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

@@ -0,0 +1,63 @@
+import { Observable } from 'rxjs';
+import { Loan as LoanBase } from '../../db/Models/loan';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { Loan } from '../../models/loan/loan';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { LoanPayout } from '../../models/loan/loan-payout';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling loans logic
+ */
+export declare class LoanService extends BaseRestService<LoanBase, Loan> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof Loan;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Listen to Loans events
+     */
+    listenEvents(): void;
+    listenToAddedLoans(): void;
+    listenToUpdatedBankAccounts(): void;
+    /**
+     * Create Loan
+     */
+    add(model: Loan): Observable<Loan>;
+    /**
+     * Updated loan
+     * @param loan
+     */
+    update(loan: Loan): Observable<Loan>;
+    /**
+     * Get list of vehicle loans
+     */
+    getVehicleLoans(): Observable<Loan[]>;
+    /**
+     * Calculate loan payments
+     * @param loan
+     */
+    calculateLoanPayments(loan: Loan): Observable<any>;
+    /**
+     * Add new loan payout
+     * @param loan
+     * @param paidOutLoan
+     */
+    addPayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any>;
+    /**
+     * Delete loan payout
+     * @param loan
+     * @param payout
+     */
+    deletePayoutLoan(loan: Loan, payout: LoanPayout): Observable<any>;
+    /**
+     * Update loan payout
+     * @param loan
+     * @param paidOutLoan
+     */
+    updatePayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoanService>;
+}

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

@@ -0,0 +1,31 @@
+import { ServiceNotification as NotificationBase } from '../../db/Models/service-notification';
+import { Notification } from '../../models/notification/notification';
+import { HttpClient } from '@angular/common/http';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+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 to handle service notifications logic
+ */
+export declare class NotificationService extends BaseRestService<NotificationBase, Notification> implements IEventListener {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    private sseService;
+    modelClass: typeof Notification;
+    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 listenNotifications;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}

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

@@ -0,0 +1,12 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Endpoint } from '../../models/endpoint/endpoint';
+import * as i0 from "@angular/core";
+export declare class PreloaderService {
+    activePreloaders: BehaviorSubject<Endpoint[]>;
+    constructor();
+    get(): Observable<Endpoint[]>;
+    add(endpoint: Endpoint): void;
+    delete(endpoint: Endpoint): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreloaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreloaderService>;
+}

package/lib/services/property/corelogic.service.d.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { CorelogicSuggestion } from '../../models/property/corelogic-suggestion';
+import * as i0 from "@angular/core";
+export declare class CorelogicService {
+    private http;
+    private environment;
+    _accessToken: string;
+    accessTokenSubject: ReplaySubject<string>;
+    constructor(http: HttpClient, environment: any);
+    getAccessToken(force?: boolean): Observable<string>;
+    getSuggestions(query: string, country?: string): Observable<CorelogicSuggestion[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CorelogicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CorelogicService>;
+}

package/lib/services/property/property-calculation.service.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'rxjs';
+import { BankAccountCollection } from '../../collections/bank-account.collection';
+import { DepreciationCollection } from '../../collections/depreciation.collection';
+import { LoanCollection } from '../../collections/loan.collection';
+import { PropertyCollection } from '../../collections/property.collection';
+import { TransactionCollection } from '../../collections/transaction.collection';
+import * as i0 from "@angular/core";
+/**
+ * Service with calculations methods for properties related with other entities.
+ * Logic here works like collections methods but for several entities
+ */
+export declare class PropertyCalculationService {
+    getTaxPosition(transactions: TransactionCollection, depreciations: DepreciationCollection): number;
+    getTaxPosition$(transactions$: Observable<TransactionCollection>, depreciations$: Observable<DepreciationCollection>): Observable<number>;
+    taxPositionGrowth(properties: PropertyCollection, transactions: TransactionCollection, depreciations: DepreciationCollection): number;
+    taxPositionGrowth$(properties$: Observable<PropertyCollection>, transactions$: Observable<TransactionCollection>, depreciations$: Observable<DepreciationCollection>): Observable<number>;
+    getRentalReturn(properties: PropertyCollection, transactions: TransactionCollection): number;
+    getLoanAmount(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number;
+    getLoanValue(properties: PropertyCollection, bankAccounts: BankAccountCollection): number;
+    /**
+     * LVR
+     */
+    getLvr(properties: PropertyCollection, bankAccounts: BankAccountCollection): number;
+    getLvr$(properties$: Observable<PropertyCollection>, bankAccounts$: Observable<BankAccountCollection>): Observable<number>;
+    getLvrCommencement(properties: PropertyCollection, loans: LoanCollection, bankAccounts: BankAccountCollection): number;
+    getLvrCommencement$(properties$: Observable<PropertyCollection>, bankAccounts$: Observable<BankAccountCollection>, loans$: Observable<LoanCollection>): Observable<number>;
+    getLvrGrowth(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number;
+    getLvrGrowth$(properties$: Observable<PropertyCollection>, bankAccounts$: Observable<BankAccountCollection>, loans$: Observable<LoanCollection>): Observable<number>;
+    getEquityPosition(properties: PropertyCollection, bankAccounts: BankAccountCollection): number;
+    getPurchaseEquity(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyCalculationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyCalculationService>;
+}

package/lib/services/property/property-capital-cost.service.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { PropertyCapitalCost as PropertyCapitalCostBase } from '../../db/Models/property-capital-cost';
+import { BaseRestService } from '../base-rest.service';
+import { PropertyCapitalCost } from '../../models/property/property-capital-cost';
+import { Property } from '../../models/property/property';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with capital costs
+ */
+export declare class PropertyCapitalCostService extends BaseRestService<PropertyCapitalCostBase, PropertyCapitalCost> {
+    url: string;
+    modelClass: typeof PropertyCapitalCost;
+    /**
+     * Get property capital costs
+     * @param property which params will be taken for list of property capital costs
+     */
+    getByProperty(property: Property): Observable<PropertyCapitalCost[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyCapitalCostService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyCapitalCostService>;
+}

package/lib/services/property/property-category.service.d.ts

@@ -0,0 +1,13 @@
+import { PropertyCategory as PropertyCategoryBase } from '../../db/Models/property-category';
+import { BaseRestService } from '../base-rest.service';
+import { PropertyCategory } from '../../models/property/property-category';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Property Categories
+ */
+export declare class PropertyCategoryService extends BaseRestService<PropertyCategoryBase, PropertyCategory> {
+    modelClass: typeof PropertyCategory;
+    url: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyCategoryService>;
+}

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

@@ -0,0 +1,31 @@
+import { Observable } from 'rxjs';
+import { PropertyDocument as PropertyDocumentBase } from '../../db/Models/property-document';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { PropertyDocument } from '../../models/property/property-document';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+/**
+ * Class for work with Property Documents
+ */
+export declare class PropertyDocumentService extends BaseRestService<PropertyDocumentBase, PropertyDocument> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof PropertyDocument;
+    url: string;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Add new Property Document
+     */
+    upload(file: File, propertyId: number): Observable<PropertyDocument>;
+    /**
+     * Get documents by property id
+     * @param propertyId to get desired documents
+     */
+    getByPropertyId(propertyId: number): Observable<PropertyDocument[]>;
+    private listenEvents;
+    private listenPropertyUpdateWithDocument;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyDocumentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyDocumentService>;
+}

package/lib/services/property/property-owner.service.d.ts

@@ -0,0 +1,52 @@
+import { Observable } from 'rxjs';
+import { PropertyOwner as PropertyOwnerBase } from '../../db/Models/property-owner';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { PropertyOwner } from '../../models/property/property-owner';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+export declare class PropertyOwnerService extends BaseRestService<PropertyOwnerBase, PropertyOwner> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof PropertyOwner;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Listen to Event Dispatcher events
+     */
+    listenEvents(): void;
+    /**
+     * Updated loan
+     */
+    update(propertyOwner: PropertyOwner): Observable<PropertyOwner>;
+    /**
+     * Re-invite property owner
+     * @param share user to share property
+     */
+    reinvite(share: PropertyOwner): Observable<object>;
+    /**
+     * Get incoming property owners list
+     */
+    getIncoming(): Observable<PropertyOwner[]>;
+    /**
+     * Get outcoming property owners list
+     */
+    getOutcoming(): Observable<PropertyOwner[]>;
+    /**
+     * Filter outcoming property owners
+     * @param propertyOwners which should be filtered
+     */
+    filterOutcoming(propertyOwners: PropertyOwner[]): PropertyOwner[];
+    /**
+     * Get list of co-owners filtered by property id
+     * @param propertyId
+     */
+    getByPropertyId(propertyId: number): Observable<PropertyOwner[]>;
+    /**
+     * Listen to User updated event
+     */
+    private listenUserUpdated;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyOwnerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyOwnerService>;
+}

package/lib/services/property/property-sold.service.d.ts

@@ -0,0 +1,13 @@
+import { PropertySold as PropertySoldBase } from '../../db/Models/property-sold';
+import { PropertySold } from '../../models/property/property-sold';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Property Sold
+ */
+export declare class PropertySoldService extends BaseRestService<PropertySoldBase, PropertySold> {
+    modelClass: typeof PropertySold;
+    url: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertySoldService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertySoldService>;
+}

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

@@ -0,0 +1,50 @@
+import { Property as PropertyBase } from '../../db/Models/property';
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { Property } from '../../models/property/property';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Property
+ */
+export declare class PropertyService extends BaseRestService<PropertyBase, Property> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof Property;
+    url: string;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    listenEvents(): void;
+    /**
+     * Update cache when owner invitation accepted
+     */
+    private listenCoOwnerInviteAccepted;
+    /**
+     * Update cache when user's service subscription is updated
+     */
+    private listenServiceSubscriptionUpdated;
+    update(property: Property): Observable<Property>;
+    getByCategoryId(id: number): Observable<Property[]>;
+    /**
+     * Activate deactivated property
+     */
+    activate(property: Property): Observable<void>;
+    /**
+     * Deactivate activated property
+     */
+    deactivate(property: Property): Observable<void>;
+    /**
+     * Update property photo
+     * @param property Property instance for photo update
+     * @param photoFormData FormData with property photo image
+     */
+    updatePhoto(property: Property, photoFormData: FormData): Observable<void>;
+    getByCoOwnerId(id: number): Observable<Property[]>;
+    /**
+     * Get list of active user's properties
+     */
+    getActive(): Observable<Property[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyService>;
+}

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

@@ -0,0 +1,47 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { ServiceSubscriptionCollection } from '../../collections/service-subscription.collection';
+import { ServiceSubscription } from '../../models/service-subscription/service-subscription';
+import { ServicePayment } from '../../models/service-subscription/service-payment';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { ServiceSubscriptionItem } from '../../models/service-subscription/service-subscription-item';
+import * as i0 from "@angular/core";
+export declare class SubscriptionService {
+    private http;
+    private eventDispatcherService;
+    private environment;
+    _serviceSubscription: ServiceSubscription;
+    serviceSubscriptionSubject: ReplaySubject<ServiceSubscription>;
+    _serviceSubscriptions: ServiceSubscriptionCollection;
+    serviceSubscriptionsSubject: ReplaySubject<ServiceSubscriptionCollection>;
+    stripe: any;
+    servicePaymentsSubject: ReplaySubject<ServicePayment[]>;
+    _servicePayments: ServicePayment[];
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    getSubscription(): Observable<ServiceSubscription>;
+    /**
+     * @TODO right now we have only monthly prices, the function should be refactored to support other options in future
+     *
+     * create available subscription plans based on existing products
+     */
+    getSubscriptionPlans(): Observable<ServiceSubscriptionCollection>;
+    /**
+     * redirect to stripe payment page
+     */
+    checkoutRedirect(subscription: ServiceSubscription, successUrl: string, cancelUrl: string): Promise<any>;
+    /**
+     * redirect to stripe billing page
+     */
+    billingRedirect(returnUrl: string): void;
+    getPayments(): Observable<ServicePayment[]>;
+    /**
+     * Get difference between current subscription and selected new subscription
+     */
+    getProrationCost(items: ServiceSubscriptionItem[]): Observable<number>;
+    /**
+     * Change subscription plan
+     */
+    changeSubscription(items: ServiceSubscriptionItem[]): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubscriptionService>;
+}

package/lib/services/tax-review/tax-review-history.service.d.ts

@@ -0,0 +1,19 @@
+import { TaxReview as TaxReviewBase } from '../../db/Models/tax-review';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { TaxReview } from '../../models/tax-review/tax-review';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with tax review history
+ */
+export declare class TaxReviewHistoryService extends BaseRestService<TaxReviewBase, TaxReview> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof TaxReview;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaxReviewHistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaxReviewHistoryService>;
+}