taxtank-core 0.32.88 → 0.33.1

package/esm2022/src/lib/services/http/rest/rest.service.mjs

@@ -0,0 +1,296 @@
+import { Inject, Injectable, inject } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { first, map } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService, SseService } from '../../event';
+import { classToPlain } from 'class-transformer';
+import { ObservableModel } from '../../../db/Models';
+import { AppEvent2 } from '../../../models';
+import { toArray } from '../../../functions/array';
+import { DataService } from '../../data.service';
+import { ToastService } from '../../toast';
+import merge from 'lodash/merge';
+import intersection from 'lodash/intersection';
+import last from 'lodash/last';
+import clone from 'lodash/clone';
+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
+ * CollectionModel - entity collection class
+ */
+export class RestService extends DataService {
+    constructor(environment) {
+        super();
+        this.environment = environment;
+        /**
+         * Subject for service cache
+         */
+        this.cacheSubject = new ReplaySubject(1);
+        /**
+         * List of methods unavailable for current API
+         * @TODO Alex: add and handle enabled methods too
+         * @TODO Alex: disable batch by default
+         */
+        this.disabledMethods = [];
+        this.sseService = inject(SseService);
+        this.toastService = inject(ToastService);
+        this.http = inject(HttpClient);
+        this.eventDispatcherService = inject(EventDispatcherService);
+        this.roles = [];
+    }
+    get apiUrl() {
+        return `${this.environment.apiV2}/${this.endpointUri}`;
+    }
+    setCache(data, next = false) {
+        super.setCache(data);
+        if (next) {
+            this.cacheSubject.next(this.cache);
+        }
+    }
+    /**
+     * Refresh cache with actual backend data
+     */
+    refreshCache() {
+        this.cache = undefined;
+        this.get();
+    }
+    /**
+     * perform a shallow copy of the emitted data to make it immutable
+     */
+    getCacheSubjectObservable() {
+        return this.cacheSubject.asObservable().pipe(map((cache) => clone(cache)));
+    }
+    /**
+     * Get data from backend and fill the cache
+     */
+    fetch(path = this.apiUrl) {
+        this.handleAccessError('get');
+        if (!this.hasRoles()) {
+            this.setCache([], true);
+            return this.getCacheSubjectObservable();
+        }
+        // Set cache as empty collection to avoid multiple requests before cache filled
+        this.setCache([]);
+        return this.http.get(path)
+            .pipe(map((response) => Array.isArray(response) ? response : toArray(response)), map((response) => {
+            this.setCache(response, true);
+            return this.cache;
+        }));
+    }
+    get(path = this.apiUrl) {
+        if (!this.cache) {
+            this.fetch(path).pipe(first()).subscribe();
+        }
+        return this.getCacheSubjectObservable();
+    }
+    getBy(path, values) {
+        return this.get().pipe(map((projects) => projects.filterBy(path, values)));
+    }
+    getFirst() {
+        this.handleAccessError('get');
+        return this.get().pipe(map((collection) => collection.first));
+    }
+    hasInCache(id) {
+        return !!this.getCache()?.findBy('id', id);
+    }
+    getArray() {
+        return this.get().pipe(map((collection) => collection.toArray()));
+    }
+    getArrayBy(path, values) {
+        return this.getBy(path, values).pipe(map((collection) => collection.toArray()));
+    }
+    /**
+     * Create a new Model instance in database
+     */
+    post(model, path = this.apiUrl) {
+        this.handleAccessError('post');
+        return this.http.post(path, classToPlain(model))
+            .pipe(map((response) => {
+            const result = this.createModelInstance(response);
+            if (!this.mercureTopic) {
+                this.handleResponse([result], 'post');
+            }
+            return result;
+        }));
+    }
+    /**
+     * Create multiple new Model instances in database
+     */
+    postBatch(models) {
+        this.handleAccessError('postBatch');
+        return this.http.post(this.apiUrl, classToPlain(models))
+            .pipe(map((response) => {
+            const result = response.map((item) => this.createModelInstance(item));
+            if (!this.mercureTopic) {
+                this.handleResponse(result, 'post');
+            }
+            return result;
+        }));
+    }
+    /**
+     * Change an existing Model instance in database
+     */
+    put(model, path = `${this.apiUrl}/${model.id}`) {
+        this.handleAccessError('put');
+        return this.http.put(path, classToPlain(model))
+            .pipe(map((response) => {
+            const result = this.createModelInstance(response);
+            if (!this.mercureTopic) {
+                this.handleResponse([result], 'put');
+            }
+            return result;
+        }));
+    }
+    /**
+     * Change multiple existing Model instances in database
+     */
+    putBatch(models) {
+        this.handleAccessError('putBatch');
+        return this.http.put(this.apiUrl, classToPlain(models))
+            .pipe(map((response) => {
+            const result = response.map((item) => this.createModelInstance(item));
+            if (!this.mercureTopic) {
+                this.handleResponse(result, 'put');
+            }
+            return result;
+        }));
+    }
+    /**
+     * Remove a Model instance from database
+     */
+    delete(model) {
+        this.handleAccessError('delete');
+        return this.http.delete(`${this.apiUrl}/${model.id}`)
+            .pipe(map(() => {
+            if (!this.mercureTopic) {
+                this.handleResponse([model], 'delete');
+            }
+        }));
+    }
+    /**
+     * Remove multiple Model instances from database
+     */
+    deleteBatch(models) {
+        this.handleAccessError('deleteBatch');
+        return this.http.post(`${this.apiUrl}/delete`, classToPlain(models))
+            .pipe(map(() => {
+            if (!this.mercureTopic) {
+                this.handleResponse(models, 'delete');
+            }
+        }));
+    }
+    /**
+     * Handle response data - update cache and dispatch event if it is needed
+     */
+    handleResponse(response, method) {
+        if (this.getCache() !== undefined) {
+            this.updateCache(response, method);
+        }
+        // dispatch event for interested services
+        if (response[0] instanceof ObservableModel) {
+            this.dispatchEvent(method, response);
+        }
+    }
+    /**
+     * Update cache with passed items. Add/Update detects automatically, Delete via optional flag
+     */
+    updateCache(items, method) {
+        let cache;
+        switch (method) {
+            case 'post':
+                cache = this.cache.push(...items);
+                break;
+            case 'put':
+                // @TODO Alex old instance
+                items.forEach((item) => {
+                    cache = this.cache.replaceBy('id', item.id, item);
+                });
+                break;
+            case 'delete':
+                cache = this.cache.removeBy('id', items.map((item) => item.id));
+                break;
+            case 'get':
+                cache = this.createCollectionInstance(this.collectionClass, items);
+        }
+        this.setCache(cache.toArray(), true);
+    }
+    /**
+     * Generate and dispatch rest event
+     */
+    dispatchEvent(method, items) {
+        const eventName = this.modelClass.getEventName(method);
+        this.eventDispatcherService.dispatch2(new AppEvent2(eventName, items));
+    }
+    /**
+     * Check if method is not disabled. Throw exception otherwise.
+     * Some entities does not have endpoints for all methods.
+     */
+    handleAccessError(method) {
+        if (!this.disabledMethods.includes(method)) {
+            return;
+        }
+        throw new Error(`Method ${method}() is not allowed for ${this.constructor.name}`);
+    }
+    /**
+     * 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
+     */
+    listenCSE(modelClass, callback, methods = ['post', 'put', 'delete']) {
+        callback = callback.bind(this);
+        methods.forEach((method) => {
+            this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data) => {
+                callback(data);
+            });
+        });
+    }
+    /**
+     * check if user has subscription role to access api
+     */
+    hasRoles() {
+        if (!this.roles.length) {
+            return true;
+        }
+        return !!intersection(JSON.parse(localStorage.getItem('roles')), this.roles).length;
+    }
+    /**
+     * Listen for Server-Sent Events (SSE) on the specified Mercure topic
+     */
+    listenSSE() {
+        if (!this.mercureTopic) {
+            return;
+        }
+        this.sseService.on(this.mercureTopic).pipe(map((response) => {
+            let model = this.createModelInstance(response);
+            let method;
+            if (model.id) {
+                method = this.hasInCache(model.id) ? 'put' : 'post';
+            }
+            else {
+                method = 'delete';
+                // we got empty body when item deleted, so we should get id from Api Platform data (@id)
+                model = merge(model, { id: +last(model['@id'].split('/')) });
+            }
+            return { method, model };
+        })).subscribe((change) => {
+            this.handleResponse([change.model], change.method);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RestService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/rest/rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, inject } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { first, map } from 'rxjs/operators';\nimport { HttpClient } from '@angular/common/http';\nimport { EventDispatcherService, SseService } from '../../event';\nimport { classToPlain } from 'class-transformer';\nimport { Collection } from '../../../collections';\nimport { AbstractModel, ObservableModel } from '../../../db/Models';\nimport { AppEvent2 } from '../../../models';\nimport { toArray } from '../../../functions/array';\nimport { RestMethod } from './rest-method.type';\nimport { HttpMethod } from './http-method.type';\nimport { DataService } from '../../data.service';\nimport { UserRolesEnum } from 'taxtank-core/common';\nimport { ToastService } from '../../toast';\nimport merge from 'lodash/merge';\nimport intersection from 'lodash/intersection';\nimport last from 'lodash/last';\nimport clone from 'lodash/clone';\n\n/**\n * Abstract base service that implements common services functionality\n * and describe abstract methods/properties that have to be implemented in child services\n * Model - entity service is working with\n * BaseModel - base entity model that extends by Model\n * CollectionModel - entity collection class\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport abstract class RestService<BaseModel, Model extends AbstractModel, CollectionModel extends Collection<Model>>\n  extends DataService<BaseModel, Model, CollectionModel> {\n\n  /**\n   * Url part for service entity API\n   */\n  protected abstract endpointUri: string;\n\n  /**\n   * Subject for service cache\n   */\n  protected cacheSubject: ReplaySubject<CollectionModel> = new ReplaySubject(1);\n\n  /**\n   * List of methods unavailable for current API\n   * @TODO Alex: add and handle enabled methods too\n   * @TODO Alex: disable batch by default\n   */\n  disabledMethods: RestMethod[] = [];\n  protected sseService: SseService = inject(SseService);\n  protected toastService: ToastService = inject(ToastService);\n  protected http: HttpClient = inject(HttpClient);\n  protected eventDispatcherService: EventDispatcherService = inject(EventDispatcherService);\n\n  roles: UserRolesEnum[] = [];\n  mercureTopic: string;\n\n  constructor(@Inject('environment') protected environment: any) {\n    super();\n  }\n\n  protected get apiUrl(): string {\n    return `${this.environment.apiV2}/${this.endpointUri}`;\n  }\n\n  setCache(data: any[], next = false): void {\n    super.setCache(data);\n\n    if (next) {\n      this.cacheSubject.next(this.cache);\n    }\n  }\n\n  /**\n   * Refresh cache with actual backend data\n   */\n  refreshCache(): void {\n    this.cache = undefined;\n    this.get();\n  }\n\n  /**\n   * perform a shallow copy of the emitted data to make it immutable\n   */\n  getCacheSubjectObservable(): Observable<CollectionModel> {\n    return this.cacheSubject.asObservable().pipe(map((cache) => clone(cache)));\n  }\n\n  /**\n   * Get data from backend and fill the cache\n   */\n  protected fetch(path = this.apiUrl): Observable<CollectionModel> {\n    this.handleAccessError('get');\n\n    if (!this.hasRoles()) {\n      this.setCache([], true);\n      return this.getCacheSubjectObservable();\n    }\n\n    // Set cache as empty collection to avoid multiple requests before cache filled\n    this.setCache([]);\n    return this.http.get(path)\n      .pipe(\n        map((response: object | object[]) => Array.isArray(response) ? response : toArray(response)),\n        map((response: BaseModel[]) => {\n          this.setCache(response, true);\n\n          return this.cache;\n        })\n      );\n  }\n\n  get(path: string = this.apiUrl): Observable<CollectionModel> {\n    if (!this.cache) {\n      this.fetch(path).pipe(first()).subscribe();\n    }\n\n    return this.getCacheSubjectObservable();\n  }\n\n  getBy(path: string, values: any): Observable<CollectionModel> {\n    return this.get().pipe(map((projects) => projects.filterBy(path, values)));\n  }\n\n  getFirst(): Observable<Model> {\n    this.handleAccessError('get');\n\n    return this.get().pipe(\n      map((collection: CollectionModel) => collection.first)\n    );\n  }\n\n  hasInCache(id: number): boolean {\n    return !!this.getCache()?.findBy('id', id);\n  }\n\n  getArray(): Observable<Model[]> {\n    return this.get().pipe(map((collection: CollectionModel) => collection.toArray()));\n  }\n\n  getArrayBy(path: string, values: any): Observable<Model[]> {\n    return this.getBy(path, values).pipe(map((collection: CollectionModel) => collection.toArray()));\n  }\n\n  /**\n   * Create a new Model instance in database\n   */\n  post(model: Model, path: string = this.apiUrl): Observable<Model> {\n    this.handleAccessError('post');\n\n    return this.http.post(path, classToPlain(model))\n      .pipe(\n        map((response: object) => {\n          const result: Model = this.createModelInstance(response);\n          if (!this.mercureTopic) {\n            this.handleResponse([result], 'post');\n          }\n\n          return result;\n        })\n      );\n  }\n\n  /**\n   * Create multiple new Model instances in database\n   */\n  postBatch(models: Model[]): Observable<Model[]> {\n    this.handleAccessError('postBatch');\n\n    return this.http.post(this.apiUrl, classToPlain(models))\n      .pipe(\n        map((response: object[]) => {\n          const result: Model[] = response.map((item: object): Model => this.createModelInstance(item));\n          if (!this.mercureTopic) {\n            this.handleResponse(result, 'post');\n          }\n\n          return result;\n        })\n      );\n  }\n\n  /**\n   * Change an existing Model instance in database\n   */\n  put(model: Model, path = `${this.apiUrl}/${model.id}`): Observable<Model> {\n    this.handleAccessError('put');\n\n    return this.http.put(path, classToPlain(model))\n      .pipe(\n        map((response: object) => {\n          const result: Model = this.createModelInstance(response);\n          if (!this.mercureTopic) {\n            this.handleResponse([result], 'put');\n          }\n\n          return result;\n        })\n      );\n  }\n\n  /**\n   * Change multiple existing Model instances in database\n   */\n  putBatch(models: Model[]): Observable<Model[]> {\n    this.handleAccessError('putBatch');\n\n    return this.http.put(this.apiUrl, classToPlain(models))\n      .pipe(\n        map((response: object[]) => {\n          const result: Model[] = response.map((item: object): Model => this.createModelInstance(item));\n          if (!this.mercureTopic) {\n            this.handleResponse(result, 'put');\n          }\n\n          return result;\n        })\n      );\n  }\n\n  /**\n   * Remove a Model instance from database\n   */\n  delete(model: Model): Observable<void> {\n    this.handleAccessError('delete');\n\n    return this.http.delete(`${this.apiUrl}/${model.id}`)\n      .pipe(\n        map(() => {\n          if (!this.mercureTopic) {\n            this.handleResponse([model], 'delete');\n          }\n        })\n      );\n  }\n\n  /**\n   * Remove multiple Model instances from database\n   */\n  deleteBatch(models: Model[]): Observable<void> {\n    this.handleAccessError('deleteBatch');\n\n    return this.http.post(`${this.apiUrl}/delete`, classToPlain(models))\n      .pipe(\n        map(() => {\n          if (!this.mercureTopic) {\n            this.handleResponse(models, 'delete');\n          }\n        })\n      );\n  }\n\n  /**\n   * Handle response data - update cache and dispatch event if it is needed\n   */\n  protected handleResponse(response: Model[], method: HttpMethod) {\n    if (this.getCache() !== undefined) {\n      this.updateCache(response, method);\n    }\n\n    // dispatch event for interested services\n    if (response[0] instanceof ObservableModel) {\n      this.dispatchEvent(method, response as unknown as ObservableModel[]);\n    }\n  }\n\n  /**\n   * Update cache with passed items. Add/Update detects automatically, Delete via optional flag\n   */\n  protected updateCache(items: Model[], method: HttpMethod): void {\n    let cache: CollectionModel;\n\n    switch (method) {\n      case 'post':\n        cache = this.cache.push(...items);\n        break;\n\n      case 'put':\n        // @TODO Alex old instance\n        items.forEach((item: Model) => {\n          cache = this.cache.replaceBy('id', item.id, item);\n        });\n        break;\n\n      case 'delete':\n        cache = this.cache.removeBy('id', items.map((item: Model) => item.id));\n        break;\n\n      case 'get':\n        cache = this.createCollectionInstance(this.collectionClass, items);\n    }\n\n    this.setCache(cache.toArray(), true);\n  }\n\n  /**\n   * Generate and dispatch rest event\n   */\n  protected dispatchEvent(method: HttpMethod, items: ObservableModel[]): void {\n    const eventName: string = this.modelClass.getEventName(method);\n    this.eventDispatcherService.dispatch2(new AppEvent2(eventName, items));\n  }\n\n  /**\n   * Check if method is not disabled. Throw exception otherwise.\n   * Some entities does not have endpoints for all methods.\n   */\n  private handleAccessError(method: RestMethod): void {\n    if (!this.disabledMethods.includes(method)) {\n      return;\n    }\n\n    throw new Error(`Method ${method}() is not allowed for ${this.constructor.name}`);\n  }\n\n  /**\n   * Subscribe to http events and run callback.\n   * CSE - Cleint Sent Events\n   * @param modelClass\n   * @param methods The list of http methods should be listened for\n   * @param callback The function to be called when event triggered\n   */\n  protected listenCSE(modelClass: typeof ObservableModel, callback: Function, methods: HttpMethod[] = ['post', 'put', 'delete']): void {\n    callback = callback.bind(this);\n\n    methods.forEach((method: HttpMethod) => {\n      this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data: ObservableModel[]) => {\n        callback(data);\n      });\n    })\n  }\n\n  /**\n   * check if user has subscription role to access api\n   */\n  hasRoles(): boolean {\n    if (!this.roles.length) {\n      return true;\n    }\n\n    return !!intersection(JSON.parse(localStorage.getItem('roles')), this.roles).length;\n  }\n\n  /**\n   * Listen for Server-Sent Events (SSE) on the specified Mercure topic\n   */\n  listenSSE(): void {\n    if (!this.mercureTopic) {\n      return;\n    }\n\n    this.sseService.on(this.mercureTopic).pipe(\n      map((response: object) => {\n        let model = this.createModelInstance(response);\n        let method: HttpMethod;\n        if (model.id) {\n          method = this.hasInCache(model.id) ? 'put' : 'post';\n        } else {\n          method = 'delete';\n          // we got empty body when item deleted, so we should get id from Api Platform data (@id)\n          model = merge(model, { id: +last(model['@id'].split('/')) });\n        }\n\n        return { method, model };\n      })\n    ).subscribe((change) => {\n      this.handleResponse([change.model], change.method)\n    });\n  }\n}\n"]}

package/esm2022/src/lib/services/http/service-notification/index.mjs

@@ -0,0 +1,2 @@
+export * from './service-notification.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zZXJ2aWNlLW5vdGlmaWNhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlLW5vdGlmaWNhdGlvbi5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/src/lib/services/http/service-notification/service-notification.service.mjs

@@ -0,0 +1,72 @@
+import { Inject, Injectable } from '@angular/core';
+import { Notification } from '../../../models';
+import { replace } from '../../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../rest/rest-old.service';
+import { AppEvent, AppEventTypeEnum } from '../../../models';
+import clone from 'lodash/clone';
+import { Toast } from '../../../models/toast/toast';
+import { ToastTypeEnum } from '../../../models/toast/toast-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../event";
+import * as i2 from "../../toast";
+/**
+ * Service to handle service notifications logic
+ */
+export class ServiceNotificationService extends RestService {
+    constructor(eventDispatcherService, environment, toastService, sseService) {
+        super(environment);
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.toastService = toastService;
+        this.sseService = sseService;
+        this.modelClass = Notification;
+        this.url = 'service-notifications';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenNotifications();
+    }
+    /**
+     * @TODO refactor with listenSSE
+     */
+    listenNotifications() {
+        this.sseService.on(`serviceNotification`).subscribe((notificationBase) => {
+            const notification = plainToClass(Notification, notificationBase);
+            const cache = clone(this.cache);
+            // update existing notification if read and add new notification if not read
+            if (notification.isRead) {
+                replace(cache, notification);
+            }
+            else {
+                cache.unshift(notification);
+                this.toastService.add(plainToClass(Toast, {
+                    type: ToastTypeEnum.INFO,
+                    title: 'Information',
+                    message: notification.message,
+                    // read notification when user manually closed toast
+                    onCloseClick: () => {
+                        notification.isRead = true;
+                        this.update(notification).subscribe();
+                    }
+                }));
+            }
+            this.cache = cache;
+            this.cacheSubject.next(this.cache);
+            // @TODO TT-2280 Alex wrong event, it's updated, added or deleted. Not just added
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.NOTIFICATION_ADDED, notification));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServiceNotificationService, deps: [{ token: i1.EventDispatcherService }, { token: 'environment' }, { token: i2.ToastService }, { token: i1.SseService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServiceNotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServiceNotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i2.ToastService }, { type: i1.SseService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/setup-item/setup-item.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { AccountSetupItemCollection } from '../../../collections';
+import { AccountSetupItem } from '../../../models/account-setup/account-setup-item';
+import { RestService } from '../rest';
+import * as i0 from "@angular/core";
+export class SetupItemService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'setup-items';
+        this.modelClass = AccountSetupItem;
+        this.collectionClass = AccountSetupItemCollection;
+        this.disabledMethods = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SetupItemService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SetupItemService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SetupItemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXAtaXRlbS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvc2V0dXAtaXRlbS9zZXR1cC1pdGVtLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVsRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxrREFBa0QsQ0FBQztBQUNwRixPQUFPLEVBQWMsV0FBVyxFQUFFLE1BQU0sU0FBUyxDQUFDOztBQUtsRCxNQUFNLE9BQU8sZ0JBQWlCLFNBQVEsV0FBb0U7SUFIMUc7O1FBSVksZ0JBQVcsR0FBRyxhQUFhLENBQUM7UUFDdEMsZUFBVSxHQUE0QixnQkFBZ0IsQ0FBQztRQUN2RCxvQkFBZSxHQUFzQywwQkFBMEIsQ0FBQztRQUNoRixvQkFBZSxHQUFpQixDQUFDLE1BQU0sRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsYUFBYSxDQUFDLENBQUM7S0FDbkc7OEdBTFksZ0JBQWdCO2tIQUFoQixnQkFBZ0IsY0FGZixNQUFNOzsyRkFFUCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWNjb3VudFNldHVwSXRlbUNvbGxlY3Rpb24gfSBmcm9tICcuLi8uLi8uLi9jb2xsZWN0aW9ucyc7XG5pbXBvcnQgeyBTZXR1cEl0ZW0gfSBmcm9tICcuLi8uLi8uLi9kYi9Nb2RlbHMvc2V0dXAtaXRlbSc7XG5pbXBvcnQgeyBBY2NvdW50U2V0dXBJdGVtIH0gZnJvbSAnLi4vLi4vLi4vbW9kZWxzL2FjY291bnQtc2V0dXAvYWNjb3VudC1zZXR1cC1pdGVtJztcbmltcG9ydCB7IFJlc3RNZXRob2QsIFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vcmVzdCc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFNldHVwSXRlbVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxTZXR1cEl0ZW0sIEFjY291bnRTZXR1cEl0ZW0sIEFjY291bnRTZXR1cEl0ZW1Db2xsZWN0aW9uPiB7XG4gIHByb3RlY3RlZCBlbmRwb2ludFVyaSA9ICdzZXR1cC1pdGVtcyc7XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBBY2NvdW50U2V0dXBJdGVtID0gQWNjb3VudFNldHVwSXRlbTtcbiAgY29sbGVjdGlvbkNsYXNzOiB0eXBlb2YgQWNjb3VudFNldHVwSXRlbUNvbGxlY3Rpb24gPSBBY2NvdW50U2V0dXBJdGVtQ29sbGVjdGlvbjtcbiAgZGlzYWJsZWRNZXRob2RzOiBSZXN0TWV0aG9kW10gPSBbJ3Bvc3QnLCAncG9zdEJhdGNoJywgJ3B1dCcsICdwdXRCYXRjaCcsICdkZWxldGUnLCAnZGVsZXRlQmF0Y2gnXTtcbn1cbiJdfQ==

package/esm2022/src/lib/services/http/sole/bas-report/bas-report.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { BasReport } from '../../../../models';
+import * as i0 from "@angular/core";
+export class BasReportService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = BasReport;
+        this.url = 'bas-reports';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BasReportService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BasReportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BasReportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzLXJlcG9ydC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvc29sZS9iYXMtcmVwb3J0L2Jhcy1yZXBvcnQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUxRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBSy9DLE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxXQUFxQztJQUgzRTs7UUFJRSxlQUFVLEdBQXFCLFNBQVMsQ0FBQztRQUN6QyxRQUFHLEdBQUcsYUFBYSxDQUFDO0tBQ3JCOzhHQUhZLGdCQUFnQjtrSEFBaEIsZ0JBQWdCLGNBRmYsTUFBTTs7MkZBRVAsZ0JBQWdCO2tCQUg1QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vcmVzdC9yZXN0LW9sZC5zZXJ2aWNlJztcbmltcG9ydCB7IEJhc1JlcG9ydCBhcyBCYXNSZXBvcnRCYXNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vZGIvTW9kZWxzL3NvbGUvYmFzLXJlcG9ydCc7XG5pbXBvcnQgeyBCYXNSZXBvcnQgfSBmcm9tICcuLi8uLi8uLi8uLi9tb2RlbHMnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCYXNSZXBvcnRTZXJ2aWNlIGV4dGVuZHMgUmVzdFNlcnZpY2U8QmFzUmVwb3J0QmFzZSwgQmFzUmVwb3J0PntcbiAgbW9kZWxDbGFzczogdHlwZW9mIEJhc1JlcG9ydCA9IEJhc1JlcG9ydDtcbiAgdXJsID0gJ2Jhcy1yZXBvcnRzJztcbn1cbiJdfQ==

package/esm2022/src/lib/services/http/sole/index.mjs

@@ -0,0 +1,11 @@
+export * from './sole-business';
+export * from './sole-business-activity/sole-business-activity.service';
+export * from './sole-business-loss/sole-business-loss.service';
+export * from './sole-business-loss/sole-business-loss-rules/sole-business-loss-offset-rule.service';
+export * from './sole-contact/sole-contact.service';
+export * from './sole-depreciation-method/sole-depreciation-method.service';
+export * from './sole-details/sole-details.service';
+export * from './sole-invoice/sole-invoice.service';
+export * from './sole-invoice-template/sole-invoice-template.service';
+export * from './bas-report/bas-report.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zb2xlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx5REFBeUQsQ0FBQztBQUN4RSxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsc0ZBQXNGLENBQUM7QUFDckcsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDZEQUE2RCxDQUFDO0FBQzVFLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NvbGUtYnVzaW5lc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWJ1c2luZXNzLWFjdGl2aXR5L3NvbGUtYnVzaW5lc3MtYWN0aXZpdHkuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NvbGUtYnVzaW5lc3MtbG9zcy9zb2xlLWJ1c2luZXNzLWxvc3Muc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NvbGUtYnVzaW5lc3MtbG9zcy9zb2xlLWJ1c2luZXNzLWxvc3MtcnVsZXMvc29sZS1idXNpbmVzcy1sb3NzLW9mZnNldC1ydWxlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWNvbnRhY3Qvc29sZS1jb250YWN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWRlcHJlY2lhdGlvbi1tZXRob2Qvc29sZS1kZXByZWNpYXRpb24tbWV0aG9kLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWRldGFpbHMvc29sZS1kZXRhaWxzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWludm9pY2Uvc29sZS1pbnZvaWNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWludm9pY2UtdGVtcGxhdGUvc29sZS1pbnZvaWNlLXRlbXBsYXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9iYXMtcmVwb3J0L2Jhcy1yZXBvcnQuc2VydmljZSc7XG4iXX0=

package/esm2022/src/lib/services/http/sole/sole-business/index.mjs

@@ -0,0 +1,3 @@
+export * from './sole-business-messages.enum';
+export * from './sole-business.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zb2xlL3NvbGUtYnVzaW5lc3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zb2xlLWJ1c2luZXNzLW1lc3NhZ2VzLmVudW0nO1xuZXhwb3J0ICogZnJvbSAnLi9zb2xlLWJ1c2luZXNzLnNlcnZpY2UnO1xuIl19

package/esm2022/src/lib/services/http/sole/sole-business/sole-business-messages.enum.mjs

@@ -0,0 +1,5 @@
+export var SoleBusinessMessagesEnum;
+(function (SoleBusinessMessagesEnum) {
+    SoleBusinessMessagesEnum["LOGO_UPDATED"] = "Logo updated successfully";
+})(SoleBusinessMessagesEnum || (SoleBusinessMessagesEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sZS1idXNpbmVzcy1tZXNzYWdlcy5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvc29sZS9zb2xlLWJ1c2luZXNzL3NvbGUtYnVzaW5lc3MtbWVzc2FnZXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSx3QkFFWDtBQUZELFdBQVksd0JBQXdCO0lBQ2xDLHNFQUEwQyxDQUFBO0FBQzVDLENBQUMsRUFGVyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBRW5DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gU29sZUJ1c2luZXNzTWVzc2FnZXNFbnVtIHtcbiAgTE9HT19VUERBVEVEID0gJ0xvZ28gdXBkYXRlZCBzdWNjZXNzZnVsbHknXG59XG4iXX0=

package/esm2022/src/lib/services/http/sole/sole-business/sole-business.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusiness } from '../../../../models';
+import { map } from 'rxjs/operators';
+import { AppEvent, AppEventTypeEnum } from '../../../../models';
+import * as i0 from "@angular/core";
+export class SoleBusinessService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusiness;
+        this.url = 'sole-businesses';
+    }
+    add(soleBusiness) {
+        return super.add(soleBusiness).pipe(map((business) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SOLE_BUSINESS_CREATED, business));
+            return business;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/sole/sole-business-activity/sole-business-activity.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusinessActivity } from '../../../../models';
+import * as i0 from "@angular/core";
+export class SoleBusinessActivityService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusinessActivity;
+        this.url = 'sole-business-activities';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessActivityService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessActivityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessActivityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sZS1idXNpbmVzcy1hY3Rpdml0eS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvc29sZS9zb2xlLWJ1c2luZXNzLWFjdGl2aXR5L3NvbGUtYnVzaW5lc3MtYWN0aXZpdHkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUxRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFLMUQsTUFBTSxPQUFPLDJCQUE0QixTQUFRLFdBQTJEO0lBSDVHOztRQUlFLGVBQVUsR0FBZ0Msb0JBQW9CLENBQUM7UUFDL0QsUUFBRyxHQUFHLDBCQUEwQixDQUFDO0tBQ2xDOzhHQUhZLDJCQUEyQjtrSEFBM0IsMkJBQTJCLGNBRjFCLE1BQU07OzJGQUVQLDJCQUEyQjtrQkFIdkMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZXN0U2VydmljZSB9IGZyb20gJy4uLy4uL3Jlc3QvcmVzdC1vbGQuc2VydmljZSc7XG5pbXBvcnQgeyBTb2xlQnVzaW5lc3NBY3Rpdml0eSBhcyBTb2xlQnVzaW5lc3NBY3Rpdml0eUJhc2UgfSBmcm9tICcuLi8uLi8uLi8uLi9kYi9Nb2RlbHMvc29sZS9zb2xlLWJ1c2luZXNzLWFjdGl2aXR5JztcbmltcG9ydCB7IFNvbGVCdXNpbmVzc0FjdGl2aXR5IH0gZnJvbSAnLi4vLi4vLi4vLi4vbW9kZWxzJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgU29sZUJ1c2luZXNzQWN0aXZpdHlTZXJ2aWNlIGV4dGVuZHMgUmVzdFNlcnZpY2U8U29sZUJ1c2luZXNzQWN0aXZpdHlCYXNlLCBTb2xlQnVzaW5lc3NBY3Rpdml0eT57XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBTb2xlQnVzaW5lc3NBY3Rpdml0eSA9IFNvbGVCdXNpbmVzc0FjdGl2aXR5O1xuICB1cmwgPSAnc29sZS1idXNpbmVzcy1hY3Rpdml0aWVzJztcbn1cbiJdfQ==

package/esm2022/src/lib/services/http/sole/sole-business-loss/sole-business-loss-rules/sole-business-loss-offset-rule.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../../rest/rest-old.service';
+import { SoleBusinessLossOffsetRule } from '../../../../../models';
+import * as i0 from "@angular/core";
+/**
+ * @TODO vik replace with json when the final list is confirmed
+ */
+export class SoleBusinessLossOffsetRuleService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusinessLossOffsetRule;
+        this.url = 'sole-business-loss-offset-rules';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessLossOffsetRuleService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessLossOffsetRuleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessLossOffsetRuleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sZS1idXNpbmVzcy1sb3NzLW9mZnNldC1ydWxlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zb2xlL3NvbGUtYnVzaW5lc3MtbG9zcy9zb2xlLWJ1c2luZXNzLWxvc3MtcnVsZXMvc29sZS1idXNpbmVzcy1sb3NzLW9mZnNldC1ydWxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDN0QsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBRW5FOztHQUVHO0FBSUgsTUFBTSxPQUFPLGlDQUFrQyxTQUFRLFdBQW1FO0lBSDFIOztRQUlFLGVBQVUsR0FBc0MsMEJBQTBCLENBQUM7UUFDM0UsUUFBRyxHQUFHLGlDQUFpQyxDQUFDO0tBQ3pDOzhHQUhZLGlDQUFpQztrSEFBakMsaUNBQWlDLGNBRmhDLE1BQU07OzJGQUVQLGlDQUFpQztrQkFIN0MsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZXN0U2VydmljZSB9IGZyb20gJy4uLy4uLy4uL3Jlc3QvcmVzdC1vbGQuc2VydmljZSc7XG5pbXBvcnQgeyBTb2xlQnVzaW5lc3NMb3NzT2Zmc2V0UnVsZSB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL21vZGVscyc7XG5cbi8qKlxuICogQFRPRE8gdmlrIHJlcGxhY2Ugd2l0aCBqc29uIHdoZW4gdGhlIGZpbmFsIGxpc3QgaXMgY29uZmlybWVkXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFNvbGVCdXNpbmVzc0xvc3NPZmZzZXRSdWxlU2VydmljZSBleHRlbmRzIFJlc3RTZXJ2aWNlPFNvbGVCdXNpbmVzc0xvc3NPZmZzZXRSdWxlLCBTb2xlQnVzaW5lc3NMb3NzT2Zmc2V0UnVsZT4ge1xuICBtb2RlbENsYXNzOiB0eXBlb2YgU29sZUJ1c2luZXNzTG9zc09mZnNldFJ1bGUgPSBTb2xlQnVzaW5lc3NMb3NzT2Zmc2V0UnVsZTtcbiAgdXJsID0gJ3NvbGUtYnVzaW5lc3MtbG9zcy1vZmZzZXQtcnVsZXMnO1xufVxuIl19