taxtank-core 0.32.89 → 0.33.1

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

@@ -0,0 +1,37 @@
+import { Inject, Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusinessLoss } from '../../../../models';
+import { AppEventTypeEnum } from '../../../../models';
+import * as i0 from "@angular/core";
+export class SoleBusinessLossService extends RestService {
+    constructor(environment) {
+        super(environment);
+        this.environment = environment;
+        this.modelClass = SoleBusinessLoss;
+        this.url = 'sole-business-losses';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenBusinessCreated();
+    }
+    /**
+     * Listen business created because we create prior year losses together with business
+     */
+    listenBusinessCreated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.SOLE_BUSINESS_CREATED).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessLossService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessLossService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleBusinessLossService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,73 @@
+import { Inject, Injectable } from '@angular/core';
+import { SoleDepreciationMethod } from '../../../../models';
+import { ReplaySubject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum } from '../../../../models';
+import { throwError as observableThrowError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../event";
+import * as i3 from "../../../toast";
+/**
+ * @TODO Alex: extend rest service when refactored
+ */
+export class SoleDepreciationMethodService {
+    constructor(http, environment, eventDispatcherService, toastService) {
+        this.http = http;
+        this.environment = environment;
+        this.eventDispatcherService = eventDispatcherService;
+        this.toastService = toastService;
+        this.cacheSubject = new ReplaySubject(1);
+        this.url = 'sole-depreciation-methods';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenSoleDetailsChanges();
+    }
+    get() {
+        if (!this.cache) {
+            this.http.get(`${this.environment.apiV2}/${this.url}`)
+                .pipe(map((response) => plainToClass(SoleDepreciationMethod, response[0])))
+                .subscribe((soleDepreciationMethod) => {
+                this.cache = soleDepreciationMethod;
+                this.cacheSubject.next(this.cache);
+                return soleDepreciationMethod;
+            });
+        }
+        return this.cacheSubject.asObservable();
+    }
+    update(soleDepreciationMethod) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${soleDepreciationMethod.id}`, soleDepreciationMethod)
+            .pipe(map((soleDepreciationMethodBase) => {
+            const method = plainToClass(SoleDepreciationMethod, soleDepreciationMethodBase);
+            this.cache = method;
+            this.cacheSubject.next(this.cache);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SOLE_DEPRECIATION_METHOD_UPDATED, method));
+            return this.cache;
+        }), catchError((error) => {
+            // @TODO test
+            this.toastService.error(error.error['detail']);
+            return observableThrowError(error);
+        }));
+    }
+    listenSoleDetailsChanges() {
+        this.eventDispatcherService.on([AppEventTypeEnum.SOLE_DETAILS_CREATED, AppEventTypeEnum.SOLE_DETAILS_UPDATED])
+            .subscribe(() => {
+            this.cache = null;
+            this.get().subscribe();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleDepreciationMethodService, deps: [{ token: i1.HttpClient }, { token: 'environment' }, { token: i2.EventDispatcherService }, { token: i3.ToastService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleDepreciationMethodService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleDepreciationMethodService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i2.EventDispatcherService }, { type: i3.ToastService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+import { Inject, Injectable } from '@angular/core';
+import { SoleDetails } from '../../../../models';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum } from '../../../../models';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../event";
+/**
+ * @TODO TT-1777 Alex: extend from rest service when it refactored
+ */
+export class SoleDetailsService {
+    constructor(http, environment, eventDispatcherService) {
+        this.http = http;
+        this.environment = environment;
+        this.eventDispatcherService = eventDispatcherService;
+        this.cacheSubject = new ReplaySubject(1);
+    }
+    get() {
+        if (!this.cache) {
+            this.http.get(`${this.environment.apiV2}/sole-details`)
+                .pipe(map((response) => plainToClass(SoleDetails, response[0])))
+                .subscribe((soleDetails) => {
+                // undefined when user not created sole details
+                if (!soleDetails) {
+                    soleDetails = plainToClass(SoleDetails, {});
+                }
+                this.cache = soleDetails;
+                this.cacheSubject.next(this.cache);
+                return soleDetails;
+            });
+        }
+        return this.cacheSubject.asObservable();
+    }
+    add(soleDetails) {
+        return this.http.post(`${this.environment.apiV2}/sole-details`, soleDetails).pipe(map((soleDetailsBase) => {
+            this.cache = plainToClass(SoleDetails, soleDetailsBase);
+            this.cacheSubject.next(this.cache);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SOLE_DETAILS_CREATED, soleDetails));
+            return this.cache;
+        }));
+    }
+    update(soleDetails) {
+        return this.http.put(`${this.environment.apiV2}/sole-details/${soleDetails.id}`, soleDetails).pipe(map((soleDetailsBase) => {
+            this.cache = plainToClass(SoleDetails, soleDetailsBase);
+            this.cacheSubject.next(this.cache);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SOLE_DETAILS_UPDATED, soleDetails));
+            return this.cache;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleDetailsService, deps: [{ token: i1.HttpClient }, { token: 'environment' }, { token: i2.EventDispatcherService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleDetailsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleDetailsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i2.EventDispatcherService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,48 @@
+import { Inject, Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleInvoice } from '../../../../models';
+import last from 'lodash/last';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export class SoleInvoiceService extends RestService {
+    constructor(environment) {
+        super(environment);
+        this.environment = environment;
+        this.modelClass = SoleInvoice;
+        this.url = 'sole-invoices';
+        this.roles = [UserRolesEnum.SOLE_TANK];
+    }
+    updateStatus(invoice, status) {
+        // @TODO use id only to avoid unexpected changes
+        return this.update(Object.assign({}, invoice, { status }));
+    }
+    send(invoice, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/${this.url}/${invoice.id}/send`, formData);
+    }
+    /**
+     * @TODO use backend
+     * Return the next number from the last invoice.
+     * Basically needed to create a new invoice to show its number when the invoice has not yet been sent to the backend
+     */
+    getNewInvoiceNumber() {
+        if (!this.cache) {
+            return 0;
+        }
+        const number = last(this.cache)?.number ?? 0;
+        return number + 1;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleInvoiceService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleInvoiceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SoleInvoiceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,7 @@
+export * from './service-payment/service-payment.service';
+export * from './service-payment-method/service-payment-method.service';
+export * from './service-price/service-price.service';
+export * from './service-subscription/subscription.service';
+export * from './service-subscription/subscription-messages.enum';
+export * from './service-product/service-product.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zdWJzY3JpcHRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLHlEQUF5RCxDQUFDO0FBQ3hFLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsMkNBQTJDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlcnZpY2UtcGF5bWVudC9zZXJ2aWNlLXBheW1lbnQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UtcGF5bWVudC1tZXRob2Qvc2VydmljZS1wYXltZW50LW1ldGhvZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZS1wcmljZS9zZXJ2aWNlLXByaWNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlLXN1YnNjcmlwdGlvbi9zdWJzY3JpcHRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2Utc3Vic2NyaXB0aW9uL3N1YnNjcmlwdGlvbi1tZXNzYWdlcy5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZS1wcm9kdWN0L3NlcnZpY2UtcHJvZHVjdC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/src/lib/services/http/subscription/service-payment/service-payment.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { Collection } from '../../../../collections';
+import { RestService } from '../../rest';
+import { ServicePayment } from '../../../../models/service-subscription/service-payment';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ServicePaymentService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'service-payments';
+        this.modelClass = ServicePayment;
+        this.collectionClass = Collection;
+        this.disabledMethods = ['post', 'put', 'putBatch', 'delete', 'deleteBatch'];
+    }
+    /**
+     * Stripe stores actual links to payment invoices for 30 days. After that, we need to request an actual link
+     */
+    getInvoiceUrl(payment) {
+        if (!payment.isInvoiceLinkExpired()) {
+            return of(payment.receipt);
+        }
+        return this.http.get(`${this.environment.apiV2}/service-payments/${payment.id}/invoice-url`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePaymentService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePaymentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/subscription/service-payment-method/service-payment-method.service.mjs

@@ -0,0 +1,45 @@
+import { Inject, Injectable } from '@angular/core';
+import { RestService } from '../../rest';
+import { ServicePaymentMethod } from '../../../../models';
+import { Collection } from '../../../../collections';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import * as i0 from "@angular/core";
+export class ServicePaymentMethodService extends RestService {
+    constructor(environment) {
+        super(environment);
+        this.environment = environment;
+        this.endpointUri = 'service-payment-methods';
+        this.collectionClass = Collection;
+        this.modelClass = ServicePaymentMethod;
+        this.mercureTopic = 'servicePaymentMethods';
+        this.listenEvents();
+    }
+    listenEvents() {
+        // @TODO remove when TT-3826 is ready
+        this.listenSSE();
+    }
+    /**
+     * Get Stripe client secret required for Payment form initialization
+     */
+    getSecret() {
+        return this.http.get(`${this.apiUrl}/setup-intent-secret`)
+            .pipe(map((response) => response));
+    }
+    setAsDefault(paymentMethod) {
+        return this.http.put(`${this.apiUrl}/${paymentMethod.id}/default`, {})
+            .pipe(map((updatedPaymentMethod) => plainToClass(ServicePaymentMethod, updatedPaymentMethod)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePaymentMethodService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePaymentMethodService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePaymentMethodService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/subscription/service-price/service-price.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { ServicePrice } from '../../../../models';
+import { RestService } from '../../rest';
+import { ServicePriceCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling banks logic
+ */
+export class ServicePriceService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'service-prices';
+        this.modelClass = ServicePrice;
+        this.collectionClass = ServicePriceCollection;
+        this.disabledMethods = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePriceService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePriceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ServicePriceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/subscription/service-product/service-product.service.mjs

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

package/esm2022/src/lib/services/http/subscription/service-subscription/subscription-messages.enum.mjs

@@ -0,0 +1,10 @@
+export var SubscriptionMessagesEnum;
+(function (SubscriptionMessagesEnum) {
+    SubscriptionMessagesEnum["PROMOCODE_ERROR"] = "This promo code can\u2019t be applied to your subscription. Please contact support.";
+    SubscriptionMessagesEnum["SUCCEEDED"] = "Success! Payment received.";
+    SubscriptionMessagesEnum["SUCCEEDED_FREE"] = "Success! We'll update you soon.";
+    SubscriptionMessagesEnum["PROCESSING"] = "Payment processing. We'll update you when payment is received.";
+    SubscriptionMessagesEnum["REQUIRES_PAYMENT_METHOD"] = "Payment failed. Please try another payment method.";
+    SubscriptionMessagesEnum["ERROR"] = "Something went wrong.";
+})(SubscriptionMessagesEnum || (SubscriptionMessagesEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2NyaXB0aW9uLW1lc3NhZ2VzLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zdWJzY3JpcHRpb24vc2VydmljZS1zdWJzY3JpcHRpb24vc3Vic2NyaXB0aW9uLW1lc3NhZ2VzLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksd0JBT1g7QUFQRCxXQUFZLHdCQUF3QjtJQUNsQyxtSUFBa0csQ0FBQTtJQUNsRyxvRUFBd0MsQ0FBQTtJQUN4Qyw4RUFBa0QsQ0FBQTtJQUNsRCx5R0FBNkUsQ0FBQTtJQUM3RSwwR0FBOEUsQ0FBQTtJQUM5RSwyREFBK0IsQ0FBQTtBQUNqQyxDQUFDLEVBUFcsd0JBQXdCLEtBQXhCLHdCQUF3QixRQU9uQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFN1YnNjcmlwdGlvbk1lc3NhZ2VzRW51bSB7XG4gIFBST01PQ09ERV9FUlJPUiA9ICdUaGlzIHByb21vIGNvZGUgY2Fu4oCZdCBiZSBhcHBsaWVkIHRvIHlvdXIgc3Vic2NyaXB0aW9uLiBQbGVhc2UgY29udGFjdCBzdXBwb3J0LicsXG4gIFNVQ0NFRURFRCA9ICdTdWNjZXNzISBQYXltZW50IHJlY2VpdmVkLicsXG4gIFNVQ0NFRURFRF9GUkVFID0gYFN1Y2Nlc3MhIFdlJ2xsIHVwZGF0ZSB5b3Ugc29vbi5gLFxuICBQUk9DRVNTSU5HID0gYFBheW1lbnQgcHJvY2Vzc2luZy4gV2UnbGwgdXBkYXRlIHlvdSB3aGVuIHBheW1lbnQgaXMgcmVjZWl2ZWQuYCxcbiAgUkVRVUlSRVNfUEFZTUVOVF9NRVRIT0QgPSAnUGF5bWVudCBmYWlsZWQuIFBsZWFzZSB0cnkgYW5vdGhlciBwYXltZW50IG1ldGhvZC4nLFxuICBFUlJPUiA9ICdTb21ldGhpbmcgd2VudCB3cm9uZy4nXG59XG4iXX0=

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

@@ -0,0 +1,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { catchError, map } from 'rxjs/operators';
+import { classToPlain, plainToClass } from 'class-transformer';
+import { ServicePromoCode, ServiceSubscription } from '../../../../models';
+import { RestService } from '../../rest';
+import { ServiceSubscriptionCollection } from '../../../../collections';
+import { throwError as observableThrowError } from 'rxjs';
+import { SubscriptionMessagesEnum } from './subscription-messages.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * @TODO Alex refactor
+ */
+export class SubscriptionService extends RestService {
+    constructor(http, environment) {
+        super(environment);
+        this.http = http;
+        this.environment = environment;
+        this.endpointUri = 'service-subscriptions';
+        this.modelClass = ServiceSubscription;
+        this.collectionClass = ServiceSubscriptionCollection;
+        this.disabledMethods = ['putBatch', 'delete', 'deleteBatch'];
+        this.mercureTopic = 'serviceSubscriptions';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenSSE();
+    }
+    startTrial(subscription) {
+        return this.post(subscription, `${this.apiUrl}/trial`);
+    }
+    postStripeSubscription(subscription) {
+        return this.http.post(this.apiUrl, classToPlain(subscription))
+            .pipe(map((response) => response), catchError((error) => {
+            this.toastService.error(SubscriptionMessagesEnum.PROMOCODE_ERROR);
+            return observableThrowError(error);
+        }));
+    }
+    getActive() {
+        return this.get().pipe(map((subscriptions) => subscriptions.getActive()));
+    }
+    getTrials() {
+        return this.get().pipe(map((subscriptions) => subscriptions.getTrials()));
+    }
+    getActiveTrials() {
+        return this.getActive().pipe(map((subscriptions) => subscriptions.getTrials()));
+    }
+    /**
+     * Get difference between current subscription and selected new subscription
+     */
+    getProrationCost(subscription) {
+        return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}/proration-cost`, subscription).pipe(map((prorationCost) => prorationCost));
+    }
+    /**
+     * @TODO it's not a change, it's request to change
+     * Change subscription plan
+     */
+    changeSubscription(subscription) {
+        return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}`, subscription);
+    }
+    cancel(subscription) {
+        return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}/cancel`, {});
+    }
+    renew(subscription) {
+        return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}/renewal`, {});
+    }
+    getCoupon(code) {
+        return this.http.get(`${this.environment.apiV2}/service-promo-codes`, {
+            params: { code }
+        }).pipe(map((response) => plainToClass(ServicePromoCode, response)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SubscriptionService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SubscriptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SubscriptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/tt-core/src/lib/services/http/subscription/service-subscription/subscription.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAc,WAAW,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;;;AAGxE;;GAEG;AAIH,MAAM,OAAO,mBAAoB,SAAQ,WAAwF;IAO/H,YAAsB,IAAgB,EAAmC,WAAgB;QACvF,KAAK,CAAC,WAAW,CAAC,CAAC;QADC,SAAI,GAAJ,IAAI,CAAY;QAAmC,gBAAW,GAAX,WAAW,CAAK;QANzF,gBAAW,GAAG,uBAAuB,CAAC;QACtC,eAAU,GAA+B,mBAAmB,CAAC;QAC7D,oBAAe,GAAyC,6BAA6B,CAAC;QACtF,oBAAe,GAAiB,CAAC,UAAU,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;QACtE,iBAAY,GAAG,sBAAsB,CAAC;QAIpC,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,YAAY;QACV,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAED,UAAU,CAAC,YAAiC;QAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC;IACzD,CAAC;IAED,sBAAsB,CAAC,YAAiC;QACtD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;aAC3D,IAAI,CACH,GAAG,CAAC,CAAC,QAAgB,EAAE,EAAE,CAAC,QAAQ,CAAC,EACnC,UAAU,CAAC,CAAC,KAAwB,EAAE,EAAE;YACtC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC;YAElE,OAAO,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IAClF,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,YAAiC;QAChD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,0BAA0B,YAAY,CAAC,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAC,IAAI,CAC1H,GAAG,CAAC,CAAC,aAAqB,EAAE,EAAE,CAAC,aAAa,CAAC,CAC9C,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,kBAAkB,CAAC,YAAiC;QAClD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,0BAA0B,YAAY,CAAC,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC;IAC3G,CAAC;IAED,MAAM,CAAC,YAAiC;QACtC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,0BAA0B,YAAY,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;IACxG,CAAC;IAED,KAAK,CAAC,YAAiC;QACrC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,0BAA0B,YAAY,CAAC,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;IACzG,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,sBAAsB,EAAE;YACpE,MAAM,EAAE,EAAE,IAAI,EAAE;SACjB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAgB,EAAE,EAAE,CAAC,YAAY,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAC1E,CAAC;IACJ,CAAC;8GA1EU,mBAAmB,4CAOkB,aAAa;kHAPlD,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAQ0C,MAAM;2BAAC,aAAa","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { classToPlain, plainToClass } from 'class-transformer';\nimport { ServicePromoCode, ServiceSubscription } from '../../../../models';\nimport { RestMethod, RestService } from '../../rest';\nimport { ServiceSubscription as ServiceSubscriptionBase } from '../../../../db/Models';\nimport { ServiceSubscriptionCollection } from '../../../../collections';\nimport { throwError as observableThrowError } from 'rxjs';\nimport { SubscriptionMessagesEnum } from './subscription-messages.enum';\nimport { IEventListener } from '../../../../interfaces';\n\n/**\n * @TODO Alex refactor\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class SubscriptionService extends RestService<ServiceSubscriptionBase, ServiceSubscription, ServiceSubscriptionCollection> implements IEventListener {\n  endpointUri = 'service-subscriptions';\n  modelClass: typeof ServiceSubscription = ServiceSubscription;\n  collectionClass: typeof ServiceSubscriptionCollection = ServiceSubscriptionCollection;\n  disabledMethods: RestMethod[] = ['putBatch', 'delete', 'deleteBatch'];\n  mercureTopic = 'serviceSubscriptions';\n\n  constructor(protected http: HttpClient, @Inject('environment') protected environment: any) {\n    super(environment);\n    this.listenEvents();\n  }\n\n  listenEvents() {\n    this.listenSSE();\n  }\n\n  startTrial(subscription: ServiceSubscription): Observable<ServiceSubscription> {\n    return this.post(subscription, `${this.apiUrl}/trial`);\n  }\n\n  postStripeSubscription(subscription: ServiceSubscription): Observable<string | void> {\n    return this.http.post(this.apiUrl, classToPlain(subscription))\n      .pipe(\n        map((response: string) => response),\n        catchError((error: HttpErrorResponse) => {\n          this.toastService.error(SubscriptionMessagesEnum.PROMOCODE_ERROR);\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  getActive(): Observable<ServiceSubscriptionCollection> {\n    return this.get().pipe(map((subscriptions) => subscriptions.getActive()));\n  }\n\n  getTrials(): Observable<ServiceSubscriptionCollection> {\n    return this.get().pipe(map((subscriptions) => subscriptions.getTrials()));\n  }\n\n  getActiveTrials(): Observable<ServiceSubscriptionCollection> {\n    return this.getActive().pipe(map((subscriptions) => subscriptions.getTrials()));\n  }\n\n  /**\n   * Get difference between current subscription and selected new subscription\n   */\n  getProrationCost(subscription: ServiceSubscription): Observable<number> {\n    return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}/proration-cost`, subscription).pipe(\n      map((prorationCost: number) => prorationCost)\n    );\n  }\n\n  /**\n   * @TODO it's not a change, it's request to change\n   * Change subscription plan\n   */\n  changeSubscription(subscription: ServiceSubscription): Observable<object> {\n    return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}`, subscription);\n  }\n\n  cancel(subscription: ServiceSubscription): Observable<object> {\n    return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}/cancel`, {});\n  }\n\n  renew(subscription: ServiceSubscription): Observable<object> {\n    return this.http.put(`${this.environment.apiV2}/service-subscriptions/${subscription.id}/renewal`, {});\n  }\n\n  getCoupon(code: string): Observable<any> {\n    return this.http.get(`${this.environment.apiV2}/service-promo-codes`, {\n      params: { code }\n    }).pipe(map((response: object) => plainToClass(ServicePromoCode, response))\n    );\n  }\n}\n"]}

package/esm2022/src/lib/services/http/tax-review/index.mjs

@@ -0,0 +1,4 @@
+export * from './tax-review-history/tax-review-history.service';
+export * from './tax-review.service';
+export * from './tax-review-messages.enum';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC90YXgtcmV2aWV3L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaURBQWlELENBQUM7QUFDaEUsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90YXgtcmV2aWV3LWhpc3RvcnkvdGF4LXJldmlldy1oaXN0b3J5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YXgtcmV2aWV3LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YXgtcmV2aWV3LW1lc3NhZ2VzLmVudW0nO1xuIl19