taxtank-core 2.0.1 → 2.0.3

package/src/lib/services/http/property/borrowing-report/borrowing-report.service.d.ts

@@ -0,0 +1,13 @@
+import { RestMethod, RestService } from '../../rest';
+import { BorrowingReport as BorrowingReportBase } from '../../../../db/Models/property/borrowing-report';
+import { BorrowingReport } from '../../../../models';
+import { Collection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export declare class BorrowingReportService extends RestService<BorrowingReportBase, BorrowingReport, Collection<BorrowingReport>> {
+    endpointUri: string;
+    modelClass: typeof BorrowingReport;
+    collectionClass: typeof Collection;
+    disabledMethods: RestMethod[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BorrowingReportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BorrowingReportService>;
+}

package/src/lib/services/http/property/borrowing-report/index.d.ts

@@ -0,0 +1,2 @@
+export * from './borrowing-report.service';
+export * from './borrowing-report-messages.enum';

package/src/lib/services/http/property/index.d.ts

@@ -0,0 +1,9 @@
+export * from './borrowing-report';
+export * from './property-category';
+export * from './property-category-movement';
+export * from './property-document';
+export * from './property-sale';
+export * from './property-share';
+export * from './property-valuation';
+export * from './property-messages.enum';
+export * from './property.service';

package/src/lib/services/http/property/property-category/index.d.ts

@@ -0,0 +1 @@
+export * from './property-category.service';

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

@@ -0,0 +1,16 @@
+import { PropertyCategory as PropertyCategoryBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { PropertyCategory } from '../../../../models';
+import { Collection } from '../../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Property Categories
+ */
+export declare class PropertyCategoryService extends RestService<PropertyCategoryBase, PropertyCategory, Collection<PropertyCategory>> {
+    modelClass: typeof PropertyCategory;
+    collectionClass: typeof Collection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyCategoryService>;
+}

package/src/lib/services/http/property/property-category-movement/index.d.ts

@@ -0,0 +1 @@
+export * from './property-category-movement.service';

package/src/lib/services/http/property/property-category-movement/property-category-movement.service.d.ts

@@ -0,0 +1,17 @@
+import { PropertyCategoryMovement } from '../../../../models';
+import { PropertyCategoryMovement as PropertyCategoryMovementBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { PropertyCategoryMovementCollection } from '../../../../collections';
+import { IEventListener } from '../../../../interfaces';
+import * as i0 from "@angular/core";
+export declare class PropertyCategoryMovementService extends RestService<PropertyCategoryMovementBase, PropertyCategoryMovement, PropertyCategoryMovementCollection> implements IEventListener {
+    protected environment: any;
+    modelClass: typeof PropertyCategoryMovement;
+    collectionClass: typeof PropertyCategoryMovementCollection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    constructor(environment: any);
+    listenEvents(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyCategoryMovementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyCategoryMovementService>;
+}

package/src/lib/services/http/property/property-document/index.d.ts

@@ -0,0 +1,2 @@
+export * from './property-document-messages.enum';
+export * from './property-document.service';

package/src/lib/services/http/property/property-document/property-document-messages.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum PropertyDocumentMessagesEnum {
+    CREATED = "Property document created",
+    UPDATED = "Property document updated",
+    CONFIRM_DELETE = "Are you sure you want to delete the document?",
+    DELETED = "Property document deleted"
+}

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

@@ -0,0 +1,18 @@
+import { PropertyDocument as PropertyDocumentBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { AppFile, Property, PropertyDocument } from '../../../../models';
+import { Collection } from '../../../../collections';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Class for work with Property Documents
+ */
+export declare class PropertyDocumentService extends RestService<PropertyDocumentBase, PropertyDocument, Collection<PropertyDocument>> {
+    modelClass: typeof PropertyDocument;
+    collectionClass: typeof Collection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    postFiles(property: Property, files: AppFile[]): Observable<PropertyDocument[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyDocumentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyDocumentService>;
+}

package/src/lib/services/http/property/property-messages.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum PropertyMessagesEnum {
+    PHOTO_UPDATED = "Property photo updated",
+    PROPERTY_UPDATED = "Property updated",
+    DELETE_CONFIRM = "Are you sure you want to delete property?",
+    DELETE = "Property deleted",
+    DELETE_500 = "Only properties without transactions can be removed",
+    SHARESIGHT_CONNECTED = "Property connected to sharesight",
+    SHARESIGHT_DISCONNECTED = "Property disconnected from sharesight"
+}

package/src/lib/services/http/property/property-sale/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../../../json/tax-exemption/tax-exemption.service';
+export * from './property-sale.service';

package/src/lib/services/http/property/property-sale/property-sale.service.d.ts

@@ -0,0 +1,15 @@
+import { PropertySale as PropertySaleBase } from '../../../../db/Models';
+import { PropertySale } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { PropertySaleCollection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export declare class PropertySaleService extends RestService<PropertySaleBase, PropertySale, PropertySaleCollection> {
+    modelClass: typeof PropertySale;
+    collectionClass: typeof PropertySaleCollection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    roles: UserRolesEnum[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertySaleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertySaleService>;
+}

package/src/lib/services/http/property/property-share/index.d.ts

@@ -0,0 +1 @@
+export * from './property-share.service';

package/src/lib/services/http/property/property-share/property-share.service.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { PropertyShare as PropertyShareBase } from '../../../../db/Models';
+import { PropertyShare } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { IEventListener } from '../../../../interfaces';
+import { PropertyShareCollection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export declare class PropertyShareService extends RestService<PropertyShareBase, PropertyShare, PropertyShareCollection> implements IEventListener {
+    protected environment: any;
+    endpointUri: string;
+    modelClass: typeof PropertyShare;
+    collectionClass: typeof PropertyShareCollection;
+    disabledMethods: RestMethod[];
+    roles: UserRolesEnum[];
+    constructor(environment: any);
+    /**
+     * Listen to Event Dispatcher events
+     */
+    listenEvents(): void;
+    accept(share: PropertyShare): Observable<PropertyShare>;
+    reject(share: PropertyShare): Observable<PropertyShare>;
+    /**
+     * Re-invite property share
+     * @param share user to share property
+     */
+    reinvite(share: PropertyShare): Observable<object>;
+    /**
+     * Listen to User updated event
+     */
+    private listenUserUpdated;
+    /**
+     * @Todo Alex refactor after PropertyShare functionality in PropertyService will be cleared up
+     */
+    private listenSalesChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyShareService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyShareService>;
+}

package/src/lib/services/http/property/property-valuation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './property-valuation.service';
+export * from './property-valuation-messages.enum';

package/src/lib/services/http/property/property-valuation/property-valuation-messages.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum PropertyValuationMessages {
+    CREATED = "Property valuation created",
+    UPDATED = "Property valuation updated",
+    DELETED = "Property valuation deleted"
+}

package/src/lib/services/http/property/property-valuation/property-valuation.service.d.ts

@@ -0,0 +1,14 @@
+import { RestMethod, RestService } from '../../rest';
+import { PropertyValuation as PropertyValuationBase } from '../../../../db/Models';
+import { PropertyValuation } from '../../../../models';
+import { PropertyValuationCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export declare class PropertyValuationService extends RestService<PropertyValuationBase, PropertyValuation, PropertyValuationCollection> {
+    protected endpointUri: string;
+    modelClass: typeof PropertyValuation;
+    collectionClass: typeof PropertyValuationCollection;
+    disabledMethods: RestMethod[];
+    useBackendError: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyValuationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyValuationService>;
+}

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

@@ -0,0 +1,48 @@
+import { Property as PropertyBase } from '../../../db/Models';
+import { Observable } from 'rxjs';
+import { Property, PropertyCorelogicStatsInterface } from '../../../models';
+import { IEventListener } from '../../../interfaces';
+import { RestMethod, RestService } from '../rest';
+import { PropertyCollection } from '../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * @Todo Alex remove functionality related to PropertyShare
+ * @TODO Alex (TT-1777): replace all event listeners with the new this.listen()
+ * Service for work with Property
+ */
+export declare class PropertyService extends RestService<PropertyBase, Property, PropertyCollection> implements IEventListener {
+    protected environment: any;
+    modelClass: typeof Property;
+    collectionClass: typeof PropertyCollection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    constructor(environment: any);
+    get(): Observable<PropertyCollection>;
+    getAll(): Observable<PropertyCollection>;
+    /**
+     * @TODO remove when forecast moved to separated api
+     */
+    put(property: Property): Observable<Property>;
+    sharesightConnect(property: Property): Observable<Property>;
+    sharesightDisconnect(property: Property): Observable<Property>;
+    /**
+     * @TODO no refresh cache with this.updateCache([this.getCache().findBy('id', change.model.property.id)], 'put');
+     */
+    listenEvents(): void;
+    private listenNotifications;
+    updateDepreciationCalculation(property: Property): Observable<void>;
+    /**
+     * @TODO move to separated api
+     * Activate deactivated property
+     */
+    activate(property: Property): Observable<void>;
+    /**
+     * @TODO move to separated api
+     * Deactivate activated property
+     */
+    deactivate(property: Property): Observable<void>;
+    delete(property: Property): Observable<void>;
+    getCorelogicStats(property: Property): Observable<PropertyCorelogicStatsInterface>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyService>;
+}

package/src/lib/services/http/rest/http-error-messages.const.d.ts

@@ -0,0 +1,13 @@
+export declare const HTTP_ERROR_MESSAGES: {
+    400: string;
+    401: string;
+    403: string;
+    404: string;
+    405: string;
+    408: string;
+    429: string;
+    500: string;
+    502: string;
+    503: string;
+    504: string;
+};

package/src/lib/services/http/rest/http-method.type.d.ts

@@ -0,0 +1 @@
+export declare type HttpMethod = 'get' | 'post' | 'put' | 'delete';

package/src/lib/services/http/rest/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rest.service';
+export * from './http-error-messages.const';
+export * from './rest-method.type';
+export * from './http-method.type';

package/src/lib/services/http/rest/rest-method.type.d.ts

@@ -0,0 +1 @@
+export declare type RestMethod = 'get' | 'post' | 'postBatch' | 'put' | 'putBatch' | 'delete' | 'deleteBatch';

package/src/lib/services/http/rest/rest-old.service.d.ts

@@ -0,0 +1,122 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../../event';
+import { ToastService } from '../../toast';
+import { UserRolesEnum } from 'taxtank-core/common';
+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
+ * @TODO TT-1777 Alex: remove when all services refactored
+ */
+export declare abstract class RestService<BaseModel, Model extends BaseModel> {
+    protected environment: any;
+    private inFlight$?;
+    protected toastService: ToastService;
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    abstract url: string;
+    abstract modelClass: any;
+    protected cache: Model[];
+    protected cacheSubject: ReplaySubject<Model[]>;
+    messageCreated: string;
+    messageCreatedBatch: string;
+    messageUpdated: string;
+    messageUpdatedBatch: string;
+    messageDeleted: string;
+    messageDeletedBatch: string;
+    roles: UserRolesEnum[];
+    constructor(environment: any);
+    protected get apiUrl(): string;
+    /**
+     * get list of base class instances directly from backend
+     */
+    protected fetch(path?: string, cache?: boolean, params?: {}): Observable<Model[]>;
+    /**
+     * get cached list of all instances
+     */
+    get(path?: string): Observable<Model[]>;
+    /**
+     * get instance by id from cache
+     * @param id ID of required item
+     */
+    findById(id: number): Observable<Model>;
+    find(id: number): Model;
+    /**
+     * add new instance and update cache
+     */
+    private create;
+    /**
+     * @TODO Alex TT-1777 rename to post
+     */
+    add(model: Model, shouldUpdateCache?: boolean): Observable<Model>;
+    /**
+     * @TODO Alex TT-1777 rename to upload
+     */
+    postForm(file: File, params?: {
+        [key: string]: string;
+    }): Observable<Model>;
+    /**
+     * Add several new items
+     * @param models Array of new items for saving
+     * @param queryParams query parameters for request
+     * @TODO Alex TT-1777 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 Alex TT-1777 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 Alex TT-1777 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>;
+    /**
+     * @deprecated use removeBatch
+     * delete multiple instances of class
+     * @param models Class instances array for deleting
+     */
+    deleteBatch(models: Model[]): Observable<void>;
+    /**
+     * collect array of redo transactions requests observable
+     */
+    removeBatch(models: Model[]): Observable<void>[];
+    /**
+     * clear service cache
+     */
+    refreshCache(): void;
+    setCache(data: any[], next?: boolean): void;
+    /**
+     * Update cache subject with current cache array value
+     */
+    protected updateCache(): void;
+    /**
+     * perform a shallow copy of the emitted data to make it immutable
+     */
+    getCacheSubjectObservable(): Observable<Model[]>;
+    /**
+     * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)
+     * Create new instance of class
+     * @param model instance that we will use as constructor options
+     */
+    protected createModelInstance(model: BaseModel | object): Model;
+    /**
+     * never return cache directly to prevent update
+     */
+    getCache(): Model[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RestService<any, any>>;
+}

package/src/lib/services/http/rest/rest.service.d.ts

@@ -0,0 +1,167 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService, SseService } from '../../event';
+import { Collection } from '../../../collections';
+import { AbstractModel, ObservableModel } from '../../../db/Models';
+import { RestMethod } from './rest-method.type';
+import { HttpMethod } from './http-method.type';
+import { DataService } from '../../data.service';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { ToastService } from '../../toast';
+import * as i0 from "@angular/core";
+/**
+ * @TODO refactor to behavior subject?
+ * 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
+ * CollectionModel - entity collection class
+ */
+export declare abstract class RestService<BaseModel, Model extends AbstractModel, CollectionModel extends Collection<Model>> extends DataService<BaseModel, Model, CollectionModel> {
+    protected environment: any;
+    private inFlight$?;
+    /**
+     * Url part for service entity API
+     */
+    protected abstract endpointUri: string;
+    /**
+     * Subject for service cache
+     */
+    protected cacheSubject: ReplaySubject<CollectionModel>;
+    /**
+     * List of methods unavailable for current API
+     * @TODO Alex: add and handle enabled methods too
+     * @TODO Alex: disable batch by default
+     */
+    disabledMethods: RestMethod[];
+    protected sseService: SseService;
+    protected toastService: ToastService;
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    /**
+     * adds new entities to the beginning when true
+     * @TODO make true by default when all services refactored
+     */
+    protected orderByDesc: boolean;
+    roles: UserRolesEnum[];
+    mercureTopic: string;
+    /**
+     * flag to use error messages from api or default ones
+     * @TODO: TT-4642 check customHttpErrorMessages fix change to backend errors
+     */
+    protected useBackendError: boolean;
+    /**
+     * mapping with HTTP errors codes and general messages
+     */
+    protected httpErrorMessages: {
+        [key: number]: string;
+    };
+    constructor(environment: any);
+    get apiUrl(): string;
+    setCache(data: any[], next?: boolean): void;
+    /**
+     * Refresh cache with actual backend data
+     */
+    refreshCache(): void;
+    /**
+     * perform a shallow copy of the emitted data to make it immutable
+     */
+    getCacheSubjectObservable(): Observable<CollectionModel>;
+    /**
+     * Get data from backend and fill the cache
+     */
+    fetch(path?: string, cache?: boolean, queryParams?: {}): Observable<CollectionModel>;
+    fetchFirst(path?: string, cache?: boolean, queryParams?: {}): Observable<Model>;
+    get(path?: string): Observable<CollectionModel>;
+    getBy(path: string, values: any): Observable<CollectionModel>;
+    getFirst(): Observable<Model>;
+    hasInCache(id: number): boolean;
+    getArray(): Observable<Model[]>;
+    getArrayBy(path: string, values: any): Observable<Model[]>;
+    /**
+     * Create a new Model instance in database
+     */
+    post(model: Model, path?: string): Observable<Model>;
+    /**
+     * Create multiple new Model instances in database
+     */
+    postBatch(models: Model[]): Observable<Model[]>;
+    /**
+     * Create multiple new Model instances in database for resources which support only single entity post
+     */
+    postParallel(models: Model[]): Observable<Model[]>;
+    /**
+     * Change an existing Model instance in database
+     */
+    put(model: Model, path?: string): Observable<Model>;
+    /**
+     * Change multiple existing Model instances in database
+     */
+    putBatch(models: Model[]): Observable<Model[]>;
+    /**
+     * Change multiple existing Model instances in database for resources which support only single entity put
+     */
+    putParallel(models: Model[]): Observable<Model[]>;
+    /**
+     * Remove a Model instance from database
+     */
+    delete(model: Model, path?: string): Observable<void>;
+    /**
+     * Remove multiple Model instances from database
+     */
+    deleteBatch(models: Model[]): Observable<void>;
+    /**
+     * @todo: remove deleteBatch after backend refactor
+     */
+    deleteBatchV2(models: Model[]): Observable<void>;
+    /**
+     * Remove multiple Model instances from database for resources which support only single entity delete
+     */
+    deleteParallel(models: Model[]): Observable<void>;
+    /**
+     * method with messages that can be redefined in other classes to customize httpErrorMessages
+     */
+    protected getCustomHttpErrorMessages(): Record<number, string>;
+    /**
+     * Handle response errors - shows error in toast
+     * and throws error further
+     * @param error - any backend error
+     * @throws HttpErrorResponse | Error - Always throws the error further as an Observable<never>
+     */
+    handleError(error: unknown): Observable<never>;
+    /**
+     * Handle response data - update cache and dispatch event if it is needed
+     */
+    protected handleResponse(response: Model[], method: HttpMethod): void;
+    /**
+     * Update cache with passed items. Add/Update detects automatically, Delete via optional flag
+     */
+    protected updateCache(items: Model[], method: HttpMethod): void;
+    /**
+     * Generate and dispatch rest event
+     */
+    protected dispatchEvent(method: HttpMethod, items: ObservableModel[]): void;
+    /**
+     * Check if method is not disabled. Throw exception otherwise.
+     * Some entities does not have endpoints for all methods.
+     */
+    private handleAccessError;
+    /**
+     * Subscribe to http events and run callback.
+     * CSE - Cleint Sent Events
+     * @param modelClass
+     * @param methods The list of http methods should be listened for
+     * @param callback The function to be called when event triggered
+     */
+    protected listenCSE(modelClass: typeof ObservableModel, callback: Function, methods?: HttpMethod[]): void;
+    /**
+     * check if user has subscription role to access api
+     */
+    hasRoles(): boolean;
+    /**
+     * Listen for Server-Sent Events (SSE) on the specified Mercure topic
+     */
+    listenSSE(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestService<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RestService<any, any, any>>;
+}

package/src/lib/services/http/rest-messages.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum RestMessagesEnum {
+    POST = "Created",
+    PUT = "Updated",
+    DELETE = "Deleted"
+}

package/src/lib/services/http/service-notification/index.d.ts

@@ -0,0 +1 @@
+export * from './service-notification.service';

package/src/lib/services/http/service-notification/service-notification.service.d.ts

@@ -0,0 +1,27 @@
+import { ServiceNotification as NotificationBase } from '../../../db/Models/service-notification';
+import { Notification } from '../../../models';
+import { RestService } from '../rest/rest-old.service';
+import { EventDispatcherService } from '../../event';
+import { SseService } from '../../event';
+import { ToastService } from '../../toast';
+import { IEventListener } from '../../../interfaces';
+import * as i0 from "@angular/core";
+/**
+ * Service to handle service notifications logic
+ */
+export declare class ServiceNotificationService extends RestService<NotificationBase, Notification> implements IEventListener {
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    protected toastService: ToastService;
+    private sseService;
+    modelClass: typeof Notification;
+    url: string;
+    constructor(eventDispatcherService: EventDispatcherService, environment: any, toastService: ToastService, sseService: SseService);
+    listenEvents(): void;
+    /**
+     * @TODO refactor with listenSSE
+     */
+    private listenNotifications;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceNotificationService>;
+}

package/src/lib/services/http/setup-item/setup-item.service.d.ts

@@ -0,0 +1,13 @@
+import { AccountSetupItemCollection } from '../../../collections';
+import { SetupItem } from '../../../db/Models/setup-item';
+import { AccountSetupItem } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import * as i0 from "@angular/core";
+export declare class SetupItemService extends RestService<SetupItem, AccountSetupItem, AccountSetupItemCollection> {
+    protected endpointUri: string;
+    modelClass: typeof AccountSetupItem;
+    collectionClass: typeof AccountSetupItemCollection;
+    disabledMethods: RestMethod[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SetupItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SetupItemService>;
+}

package/src/lib/services/http/sharesight/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sharesight-details.service';
+export * from './sharesight-portfolio.service';

package/src/lib/services/http/sharesight/sharesight-details.service.d.ts

@@ -0,0 +1,15 @@
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+import { SharesightDetails, SharesightDetailsInterface } from '../../../models';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SharesightDetailsService extends RestService<SharesightDetailsInterface, SharesightDetails, Collection<SharesightDetails>> {
+    modelClass: typeof SharesightDetails;
+    collectionClass: typeof Collection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    protected getCustomHttpErrorMessages(): Record<number, string>;
+    reconnect(sharesightDetails: SharesightDetails): Observable<SharesightDetails>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharesightDetailsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SharesightDetailsService>;
+}