@veloceapps/api 11.0.0-2 → 11.0.0-20

package/esm2020/src/lib/services/catalog-api.service.mjs

@@ -0,0 +1,90 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class CatalogApiService {
+    constructor(service) {
+        this.service = service;
+        this.serviceUrl = '/product-catalogs';
+    }
+    fetchCatalogs$() {
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}`,
+        });
+    }
+    searchCatalogs$(searchParams, expression) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/search`,
+            params,
+            body: expression,
+        });
+    }
+    getCatalog$(id) {
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}/${id}`,
+        });
+    }
+    fetchCategories$(catalogId) {
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}/${catalogId}/categories`,
+        });
+    }
+    fetchCatalogProducts$(catalogId, searchParams, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/products`,
+            params,
+            body: context,
+        });
+    }
+    fetchCategoryProducts$(catalogId, categoryId, searchParams, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products`,
+            params,
+            body: context,
+        });
+    }
+    searchCategoryProducts$(catalogId, categoryId, searchParams, searchRequest, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/search`,
+            params,
+            body: {
+                configurationContext: context,
+                request: searchRequest,
+            },
+        });
+    }
+    fetchEligibleProducts$(searchParams, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/products`,
+            params: params,
+            body: context,
+        });
+    }
+    fetchProducts$(searchParams) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}/products`,
+            params: params,
+        });
+    }
+}
+CatalogApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+CatalogApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"catalog-api.service.js","sourceRoot":"","sources":["../../../../../../../libs/api/src/lib/services/catalog-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport {\n  BaseHttpService,\n  Catalog,\n  Category,\n  ConfigurationContext,\n  Expression,\n  Product,\n  SearchRequest,\n} from '@veloceapps/core';\nimport { Observable } from 'rxjs';\nimport { QuerySearchParams } from '../types';\n\n@Injectable()\nexport class CatalogApiService {\n  private readonly serviceUrl: string = '/product-catalogs';\n\n  constructor(private service: BaseHttpService) {}\n\n  public fetchCatalogs$(): Observable<Catalog[]> {\n    return this.service.api({\n      method: 'get',\n      url: `${this.serviceUrl}`,\n    });\n  }\n\n  public searchCatalogs$(searchParams?: QuerySearchParams, expression?: Expression): Observable<Catalog[]> {\n    const params = new HttpParams({ fromObject: searchParams });\n\n    return this.service.api({\n      method: 'post',\n      url: `${this.serviceUrl}/search`,\n      params,\n      body: expression,\n    });\n  }\n\n  public getCatalog$(id: string): Observable<Catalog> {\n    return this.service.api({\n      method: 'get',\n      url: `${this.serviceUrl}/${id}`,\n    });\n  }\n\n  public fetchCategories$(catalogId: string): Observable<Category[]> {\n    return this.service.api({\n      method: 'get',\n      url: `${this.serviceUrl}/${catalogId}/categories`,\n    });\n  }\n\n  public fetchCatalogProducts$(\n    catalogId: string,\n    searchParams?: QuerySearchParams,\n    context?: ConfigurationContext,\n  ): Observable<Product[]> {\n    const params = new HttpParams({ fromObject: searchParams });\n\n    return this.service.api({\n      method: 'post',\n      url: `${this.serviceUrl}/${catalogId}/products`,\n      params,\n      body: context,\n    });\n  }\n\n  public fetchCategoryProducts$(\n    catalogId: string,\n    categoryId: string,\n    searchParams?: QuerySearchParams,\n    context?: ConfigurationContext,\n  ): Observable<Product[]> {\n    const params = new HttpParams({ fromObject: searchParams });\n\n    return this.service.api({\n      method: 'post',\n      url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products`,\n      params,\n      body: context,\n    });\n  }\n\n  public searchCategoryProducts$(\n    catalogId: string,\n    categoryId: string,\n    searchParams?: QuerySearchParams,\n    searchRequest?: SearchRequest,\n    context?: ConfigurationContext,\n  ): Observable<Product[]> {\n    const params = new HttpParams({ fromObject: searchParams });\n\n    return this.service.api({\n      method: 'post',\n      url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/search`,\n      params,\n      body: {\n        configurationContext: context,\n        request: searchRequest,\n      },\n    });\n  }\n\n  public fetchEligibleProducts$(\n    searchParams?: QuerySearchParams,\n    context?: ConfigurationContext,\n  ): Observable<Product[]> {\n    const params = new HttpParams({ fromObject: searchParams });\n\n    return this.service.api({\n      method: 'post',\n      url: `${this.serviceUrl}/products`,\n      params: params,\n      body: context,\n    });\n  }\n\n  public fetchProducts$(searchParams?: QuerySearchParams): Observable<Product[]> {\n    const params = new HttpParams({ fromObject: searchParams });\n\n    return this.service.api({\n      method: 'get',\n      url: `${this.serviceUrl}/products`,\n      params: params,\n    });\n  }\n}\n"]}

package/esm2020/src/lib/services/configuration-settings-api.service.mjs

@@ -0,0 +1,96 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { ConfigurationSettingsDTO } from '../types/dto/configuration-settings-dto.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+import * as i2 from "primeng/api";
+export class ConfigurationSettingsApiService {
+    constructor(httpService, messageService) {
+        this.httpService = httpService;
+        this.messageService = messageService;
+        this.SERVICE_URL = '/configuration-settings';
+    }
+    fetchSettings(options) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}`,
+            method: 'get',
+            ...options,
+        })
+            .pipe(map((settings) => settings.map(setting => ConfigurationSettingsDTO.fromDTO(setting))));
+    }
+    fetchSetting(settingsKey, options) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}/byKey/${settingsKey}`,
+            method: 'get',
+            ...options,
+            skipErrorHandler: true,
+        })
+            .pipe(map((setting) => ConfigurationSettingsDTO.fromDTO(setting, settingsKey)), catchError(err => {
+            if (err instanceof HttpErrorResponse && err.status === 404) {
+                if (!options?.skipErrorHandler) {
+                    this.messageService.add({
+                        severity: 'error',
+                        summary: `Configuration Setting "${settingsKey}" is not found`,
+                        sticky: true,
+                    });
+                }
+                return of(null);
+            }
+            throw err;
+        }));
+    }
+    createSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}`,
+            method: 'post',
+            body: {
+                ...request,
+            },
+            ...options,
+        });
+    }
+    updateSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${request.id}`,
+            method: 'put',
+            body: {
+                ...request,
+            },
+            ...options,
+        });
+    }
+    removeSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${request.id}`,
+            method: 'delete',
+            ...options,
+        });
+    }
+    restoreSetting(settingId, options) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${settingId}/restore`,
+            method: 'patch',
+            ...options,
+        });
+    }
+    clear(name, options) {
+        return this.httpService.api({
+            method: 'get',
+            url: '/cache/evict/' + name,
+            ...options,
+        });
+    }
+}
+ConfigurationSettingsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationSettingsApiService, deps: [{ token: i1.BaseHttpService }, { token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationSettingsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationSettingsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationSettingsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: i2.MessageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration-settings-api.service.js","sourceRoot":"","sources":["../../../../../../../libs/api/src/lib/services/configuration-settings-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport {\n  BaseHttpService,\n  ConfigurationSettings,\n  DataAdministrationField,\n  HttpRequestConfigurableOptions,\n} from '@veloceapps/core';\nimport { MessageService } from 'primeng/api';\nimport { Observable, of } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { ConfigurationSettingsDTO } from '../types/dto/configuration-settings-dto.types';\n\n@Injectable()\nexport class ConfigurationSettingsApiService {\n  private readonly SERVICE_URL = '/configuration-settings';\n\n  constructor(private httpService: BaseHttpService, private messageService: MessageService) {}\n\n  public fetchSettings(options?: HttpRequestConfigurableOptions): Observable<ConfigurationSettings[]> {\n    return this.httpService\n      .api<ConfigurationSettingsDTO[]>({\n        url: `${this.SERVICE_URL}`,\n        method: 'get',\n        ...options,\n      })\n      .pipe(\n        map((settings: ConfigurationSettingsDTO[]) =>\n          settings.map(setting => ConfigurationSettingsDTO.fromDTO(setting)),\n        ),\n      );\n  }\n\n  public fetchSetting(\n    settingsKey: string,\n    options?: HttpRequestConfigurableOptions,\n  ): Observable<ConfigurationSettings | null> {\n    return this.httpService\n      .api<ConfigurationSettingsDTO>({\n        url: `${this.SERVICE_URL}/byKey/${settingsKey}`,\n        method: 'get',\n        ...options,\n        skipErrorHandler: true,\n      })\n      .pipe(\n        map((setting: ConfigurationSettingsDTO) => ConfigurationSettingsDTO.fromDTO(setting, settingsKey)),\n        catchError(err => {\n          if (err instanceof HttpErrorResponse && err.status === 404) {\n            if (!options?.skipErrorHandler) {\n              this.messageService.add({\n                severity: 'error',\n                summary: `Configuration Setting \"${settingsKey}\" is not found`,\n                sticky: true,\n              });\n            }\n\n            return of(null);\n          }\n\n          throw err;\n        }),\n      );\n  }\n\n  public createSetting(\n    setting: ConfigurationSettings,\n    options?: HttpRequestConfigurableOptions,\n  ): Observable<ConfigurationSettings> {\n    const request = ConfigurationSettingsDTO.toDTO(setting);\n\n    return this.httpService.api({\n      url: `${this.SERVICE_URL}`,\n      method: 'post',\n      body: {\n        ...request,\n      },\n      ...options,\n    });\n  }\n\n  public updateSetting(\n    setting: ConfigurationSettings,\n    options?: HttpRequestConfigurableOptions,\n  ): Observable<ConfigurationSettings> {\n    const request = ConfigurationSettingsDTO.toDTO(setting);\n\n    return this.httpService.api({\n      url: `${this.SERVICE_URL}/${request.id}`,\n      method: 'put',\n      body: {\n        ...request,\n      },\n      ...options,\n    });\n  }\n\n  public removeSetting(\n    setting: ConfigurationSettings,\n    options?: HttpRequestConfigurableOptions,\n  ): Observable<ConfigurationSettings> {\n    const request = ConfigurationSettingsDTO.toDTO(setting);\n\n    return this.httpService.api({\n      url: `${this.SERVICE_URL}/${request.id}`,\n      method: 'delete',\n      ...options,\n    });\n  }\n\n  public restoreSetting(settingId: string, options?: HttpRequestConfigurableOptions): Observable<void> {\n    return this.httpService.api({\n      url: `${this.SERVICE_URL}/${settingId}/restore`,\n      method: 'patch',\n      ...options,\n    });\n  }\n\n  public clear(name: DataAdministrationField, options?: HttpRequestConfigurableOptions): Observable<void> {\n    return this.httpService.api({\n      method: 'get',\n      url: '/cache/evict/' + name,\n      ...options,\n    });\n  }\n}\n"]}

package/esm2020/src/lib/services/contracted-price-api.service.mjs

@@ -0,0 +1,45 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class ContractedPriceApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/contracted-price';
+        this.fetchContractedPrices$ = () => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}` });
+        };
+        this.fetchContractedPrice$ = (id) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });
+        };
+        this.createContractedPrice$ = (data) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'put',
+                body: data,
+            });
+        };
+        this.updateContractedPrice$ = (data) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${data.id}`,
+                method: 'put',
+                body: data,
+            });
+        };
+        this.searchContractedPrices$ = (searchParams, expression) => {
+            const params = new HttpParams({ fromObject: { ...searchParams } });
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params,
+                body: expression || {},
+            });
+        };
+    }
+}
+ContractedPriceApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContractedPriceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContractedPriceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContractedPriceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContractedPriceApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/services/delta-api.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class DeltaApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/delta';
+    }
+    calculate$(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/calculate`,
+            body: request,
+            skipErrorHandler: true,
+        });
+    }
+}
+DeltaApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DeltaApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+DeltaApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DeltaApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DeltaApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsdGEtYXBpLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FwaS9zcmMvbGliL3NlcnZpY2VzL2RlbHRhLWFwaS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQU0zQyxNQUFNLE9BQU8sZUFBZTtJQUcxQixZQUFvQixXQUE0QjtRQUE1QixnQkFBVyxHQUFYLFdBQVcsQ0FBaUI7UUFGL0IsZ0JBQVcsR0FBRyxRQUFRLENBQUM7SUFFVyxDQUFDO0lBRTdDLFVBQVUsQ0FBQyxPQUE4QjtRQUM5QyxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFhO1lBQ3RDLE1BQU0sRUFBRSxNQUFNO1lBQ2QsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLFdBQVcsWUFBWTtZQUNwQyxJQUFJLEVBQUUsT0FBTztZQUNiLGdCQUFnQixFQUFFLElBQUk7U0FDdkIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7NEdBWlUsZUFBZTtnSEFBZixlQUFlOzJGQUFmLGVBQWU7a0JBRDNCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCYXNlSHR0cFNlcnZpY2UsIExpbmVJdGVtIH0gZnJvbSAnQHZlbG9jZWFwcHMvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDYWxjdWxhdGVEZWx0YVJlcXVlc3QgfSBmcm9tICcuLi90eXBlcy9kZWx0YS1yZXF1ZXN0LnR5cGVzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIERlbHRhQXBpU2VydmljZSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgU0VSVklDRV9VUkwgPSAnL2RlbHRhJztcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGh0dHBTZXJ2aWNlOiBCYXNlSHR0cFNlcnZpY2UpIHt9XG5cbiAgcHVibGljIGNhbGN1bGF0ZSQocmVxdWVzdDogQ2FsY3VsYXRlRGVsdGFSZXF1ZXN0KTogT2JzZXJ2YWJsZTxMaW5lSXRlbVtdPiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cFNlcnZpY2UuYXBpPExpbmVJdGVtW10+KHtcbiAgICAgIG1ldGhvZDogJ3Bvc3QnLFxuICAgICAgdXJsOiBgJHt0aGlzLlNFUlZJQ0VfVVJMfS9jYWxjdWxhdGVgLFxuICAgICAgYm9keTogcmVxdWVzdCxcbiAgICAgIHNraXBFcnJvckhhbmRsZXI6IHRydWUsXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/src/lib/services/document-attachment-api.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { map, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class DocumentAttachmentApiService {
+    constructor(httpService, fileDownloadService) {
+        this.httpService = httpService;
+        this.fileDownloadService = fileDownloadService;
+        this.SERVICE_URL = '/attachments';
+    }
+    getAttachments(searchRequest) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/search`,
+            method: 'post',
+            body: searchRequest,
+        });
+    }
+    createAttachment(attachment, file, reportProgress) {
+        const formData = new FormData();
+        if (file) {
+            formData.append('file', file, file.name);
+        }
+        formData.append('attachment', new Blob([JSON.stringify(attachment)], {
+            type: 'application/json',
+        }));
+        return this.httpService.upload({
+            url: `${this.SERVICE_URL}`,
+            body: formData,
+            method: 'post',
+            observe: reportProgress ? 'events' : undefined,
+            reportProgress,
+        });
+    }
+    updateAttachment(id, attachment) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            body: attachment,
+            method: 'put',
+        });
+    }
+    getAttachmentFile(id, isPreventDownload) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}/${id}/file`,
+            responseType: isPreventDownload ? 'arraybuffer' : 'blob',
+            observe: isPreventDownload ? 'body' : 'response',
+        })
+            .pipe(tap(response => {
+            if (!isPreventDownload) {
+                this.fileDownloadService.processDownload(response);
+            }
+        }), map(response => (isPreventDownload ? new Blob([response.body || response]) : response.body || response)));
+    }
+    removeAttachment(id) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            method: 'delete',
+        });
+    }
+}
+DocumentAttachmentApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DocumentAttachmentApiService, deps: [{ token: i1.BaseHttpService }, { token: i1.FileDownloadService }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentAttachmentApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DocumentAttachmentApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DocumentAttachmentApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: i1.FileDownloadService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtYXR0YWNobWVudC1hcGkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYXBpL3NyYy9saWIvc2VydmljZXMvZG9jdW1lbnQtYXR0YWNobWVudC1hcGkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRzNDLE9BQU8sRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7OztBQUkxQyxNQUFNLE9BQU8sNEJBQTRCO0lBR3ZDLFlBQW9CLFdBQTRCLEVBQVUsbUJBQXdDO1FBQTlFLGdCQUFXLEdBQVgsV0FBVyxDQUFpQjtRQUFVLHdCQUFtQixHQUFuQixtQkFBbUIsQ0FBcUI7UUFGakYsZ0JBQVcsR0FBRyxjQUFjLENBQUM7SUFFdUQsQ0FBQztJQUUvRixjQUFjLENBQUMsYUFBOEM7UUFDbEUsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQztZQUMxQixHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsV0FBVyxTQUFTO1lBQ2pDLE1BQU0sRUFBRSxNQUFNO1lBQ2QsSUFBSSxFQUFFLGFBQWE7U0FDcEIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVNLGdCQUFnQixDQUFDLFVBQXNCLEVBQUUsSUFBVyxFQUFFLGNBQXdCO1FBQ25GLE1BQU0sUUFBUSxHQUFhLElBQUksUUFBUSxFQUFFLENBQUM7UUFFMUMsSUFBSSxJQUFJLEVBQUU7WUFDUixRQUFRLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1NBQzFDO1FBRUQsUUFBUSxDQUFDLE1BQU0sQ0FDYixZQUFZLEVBQ1osSUFBSSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFDLEVBQUU7WUFDckMsSUFBSSxFQUFFLGtCQUFrQjtTQUN6QixDQUFDLENBQ0gsQ0FBQztRQUVGLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUM7WUFDN0IsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRTtZQUMxQixJQUFJLEVBQUUsUUFBUTtZQUNkLE1BQU0sRUFBRSxNQUFNO1lBQ2QsT0FBTyxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxTQUFTO1lBQzlDLGNBQWM7U0FDZixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU0sZ0JBQWdCLENBQUMsRUFBVSxFQUFFLFVBQXNCO1FBQ3hELE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUM7WUFDMUIsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLFdBQVcsSUFBSSxFQUFFLEVBQUU7WUFDaEMsSUFBSSxFQUFFLFVBQVU7WUFDaEIsTUFBTSxFQUFFLEtBQUs7U0FDZCxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU0saUJBQWlCLENBQUMsRUFBVSxFQUFFLGlCQUEyQjtRQUM5RCxPQUFPLElBQUksQ0FBQyxXQUFXO2FBQ3BCLEdBQUcsQ0FBQztZQUNILEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxXQUFXLElBQUksRUFBRSxPQUFPO1lBQ3JDLFlBQVksRUFBRSxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxNQUFNO1lBQ3hELE9BQU8sRUFBRSxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxVQUFVO1NBQ2pELENBQUM7YUFDRCxJQUFJLENBQ0gsR0FBRyxDQUFDLFFBQVEsQ0FBQyxFQUFFO1lBQ2IsSUFBSSxDQUFDLGlCQUFpQixFQUFFO2dCQUN0QixJQUFJLENBQUMsbUJBQW1CLENBQUMsZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDO2FBQ3BEO1FBQ0gsQ0FBQyxDQUFDLEVBQ0YsR0FBRyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsSUFBSSxJQUFJLENBQUMsQ0FBQyxRQUFRLENBQUMsSUFBSSxJQUFJLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLElBQUksUUFBUSxDQUFDLENBQUMsQ0FDekcsQ0FBQztJQUNOLENBQUM7SUFFTSxnQkFBZ0IsQ0FBQyxFQUFVO1FBQ2hDLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUM7WUFDMUIsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLFdBQVcsSUFBSSxFQUFFLEVBQUU7WUFDaEMsTUFBTSxFQUFFLFFBQVE7U0FDakIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7eUhBbEVVLDRCQUE0Qjs2SEFBNUIsNEJBQTRCOzJGQUE1Qiw0QkFBNEI7a0JBRHhDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBdHRhY2htZW50LCBCYXNlSHR0cFNlcnZpY2UsIEZpbGVEb3dubG9hZFNlcnZpY2UgfSBmcm9tICdAdmVsb2NlYXBwcy9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IG1hcCwgdGFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgVGVtcGxhdGVBdHRhY2htZW50U2VhcmNoUmVxdWVzdCB9IGZyb20gJy4uL3R5cGVzL2F0dGFjaG1lbnQudHlwZXMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRG9jdW1lbnRBdHRhY2htZW50QXBpU2VydmljZSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgU0VSVklDRV9VUkwgPSAnL2F0dGFjaG1lbnRzJztcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGh0dHBTZXJ2aWNlOiBCYXNlSHR0cFNlcnZpY2UsIHByaXZhdGUgZmlsZURvd25sb2FkU2VydmljZTogRmlsZURvd25sb2FkU2VydmljZSkge31cblxuICBwdWJsaWMgZ2V0QXR0YWNobWVudHMoc2VhcmNoUmVxdWVzdDogVGVtcGxhdGVBdHRhY2htZW50U2VhcmNoUmVxdWVzdCk6IE9ic2VydmFibGU8QXR0YWNobWVudFtdPiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cFNlcnZpY2UuYXBpKHtcbiAgICAgIHVybDogYCR7dGhpcy5TRVJWSUNFX1VSTH0vc2VhcmNoYCxcbiAgICAgIG1ldGhvZDogJ3Bvc3QnLFxuICAgICAgYm9keTogc2VhcmNoUmVxdWVzdCxcbiAgICB9KTtcbiAgfVxuXG4gIHB1YmxpYyBjcmVhdGVBdHRhY2htZW50KGF0dGFjaG1lbnQ6IEF0dGFjaG1lbnQsIGZpbGU/OiBGaWxlLCByZXBvcnRQcm9ncmVzcz86IGJvb2xlYW4pOiBPYnNlcnZhYmxlPEF0dGFjaG1lbnQ+IHtcbiAgICBjb25zdCBmb3JtRGF0YTogRm9ybURhdGEgPSBuZXcgRm9ybURhdGEoKTtcblxuICAgIGlmIChmaWxlKSB7XG4gICAgICBmb3JtRGF0YS5hcHBlbmQoJ2ZpbGUnLCBmaWxlLCBmaWxlLm5hbWUpO1xuICAgIH1cblxuICAgIGZvcm1EYXRhLmFwcGVuZChcbiAgICAgICdhdHRhY2htZW50JyxcbiAgICAgIG5ldyBCbG9iKFtKU09OLnN0cmluZ2lmeShhdHRhY2htZW50KV0sIHtcbiAgICAgICAgdHlwZTogJ2FwcGxpY2F0aW9uL2pzb24nLFxuICAgICAgfSksXG4gICAgKTtcblxuICAgIHJldHVybiB0aGlzLmh0dHBTZXJ2aWNlLnVwbG9hZCh7XG4gICAgICB1cmw6IGAke3RoaXMuU0VSVklDRV9VUkx9YCxcbiAgICAgIGJvZHk6IGZvcm1EYXRhLFxuICAgICAgbWV0aG9kOiAncG9zdCcsXG4gICAgICBvYnNlcnZlOiByZXBvcnRQcm9ncmVzcyA/ICdldmVudHMnIDogdW5kZWZpbmVkLFxuICAgICAgcmVwb3J0UHJvZ3Jlc3MsXG4gICAgfSk7XG4gIH1cblxuICBwdWJsaWMgdXBkYXRlQXR0YWNobWVudChpZDogc3RyaW5nLCBhdHRhY2htZW50OiBBdHRhY2htZW50KTogT2JzZXJ2YWJsZTxBdHRhY2htZW50PiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cFNlcnZpY2UuYXBpKHtcbiAgICAgIHVybDogYCR7dGhpcy5TRVJWSUNFX1VSTH0vJHtpZH1gLFxuICAgICAgYm9keTogYXR0YWNobWVudCxcbiAgICAgIG1ldGhvZDogJ3B1dCcsXG4gICAgfSk7XG4gIH1cblxuICBwdWJsaWMgZ2V0QXR0YWNobWVudEZpbGUoaWQ6IHN0cmluZywgaXNQcmV2ZW50RG93bmxvYWQ/OiBib29sZWFuKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5odHRwU2VydmljZVxuICAgICAgLmFwaSh7XG4gICAgICAgIHVybDogYCR7dGhpcy5TRVJWSUNFX1VSTH0vJHtpZH0vZmlsZWAsXG4gICAgICAgIHJlc3BvbnNlVHlwZTogaXNQcmV2ZW50RG93bmxvYWQgPyAnYXJyYXlidWZmZXInIDogJ2Jsb2InLFxuICAgICAgICBvYnNlcnZlOiBpc1ByZXZlbnREb3dubG9hZCA/ICdib2R5JyA6ICdyZXNwb25zZScsXG4gICAgICB9KVxuICAgICAgLnBpcGUoXG4gICAgICAgIHRhcChyZXNwb25zZSA9PiB7XG4gICAgICAgICAgaWYgKCFpc1ByZXZlbnREb3dubG9hZCkge1xuICAgICAgICAgICAgdGhpcy5maWxlRG93bmxvYWRTZXJ2aWNlLnByb2Nlc3NEb3dubG9hZChyZXNwb25zZSk7XG4gICAgICAgICAgfVxuICAgICAgICB9KSxcbiAgICAgICAgbWFwKHJlc3BvbnNlID0+IChpc1ByZXZlbnREb3dubG9hZCA/IG5ldyBCbG9iKFtyZXNwb25zZS5ib2R5IHx8IHJlc3BvbnNlXSkgOiByZXNwb25zZS5ib2R5IHx8IHJlc3BvbnNlKSksXG4gICAgICApO1xuICB9XG5cbiAgcHVibGljIHJlbW92ZUF0dGFjaG1lbnQoaWQ6IHN0cmluZyk6IE9ic2VydmFibGU8dW5rbm93bj4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBTZXJ2aWNlLmFwaSh7XG4gICAgICB1cmw6IGAke3RoaXMuU0VSVklDRV9VUkx9LyR7aWR9YCxcbiAgICAgIG1ldGhvZDogJ2RlbGV0ZScsXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/src/lib/services/endpoints-api.service.mjs

@@ -0,0 +1,80 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Expression } from '@veloceapps/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class EndpointsApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.adminServiceUrl = '/admin/api-endpoints';
+        this.serviceUrl = '/api-endpoints';
+    }
+    fetchEndpoints$() {
+        return this.searchEndpoints$(new Expression(), 0, -1);
+    }
+    searchEndpoints$(expression, skip, count) {
+        let params = new HttpParams();
+        params = params.set('skip', '' + skip);
+        params = params.set('count', '' + count);
+        return this.baseHttpService.api({
+            method: 'post',
+            url: `${this.adminServiceUrl}/search`,
+            params,
+            body: expression,
+        });
+    }
+    removeEndpoint$(id) {
+        return this.baseHttpService.api({
+            url: `${this.adminServiceUrl}/${id}`,
+            method: 'delete',
+        });
+    }
+    restoreEndpoint$(id) {
+        return this.baseHttpService.api({
+            url: `${this.adminServiceUrl}/${id}/restore`,
+            method: 'patch',
+        });
+    }
+    fetchEndpoint$(id) {
+        return this.baseHttpService.api({
+            url: `${this.adminServiceUrl}/${id}`,
+            method: 'get',
+        });
+    }
+    createEndpoint$(body) {
+        return this.baseHttpService.api({
+            url: `${this.adminServiceUrl}`,
+            method: 'post',
+            body,
+        });
+    }
+    updateEndpoint$(body) {
+        return this.baseHttpService.api({
+            url: `${this.adminServiceUrl}/${body.id}`,
+            method: 'put',
+            body,
+        });
+    }
+    duplicateEndpoint$(cloneRequest) {
+        return this.baseHttpService.api({
+            url: `${this.adminServiceUrl}/${cloneRequest.id}/clone`,
+            method: 'post',
+            body: cloneRequest,
+        });
+    }
+    executeEndpoint$(body) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/execute`,
+            method: 'post',
+            body,
+            responseType: 'text',
+            skipErrorHandler: true,
+        });
+    }
+}
+EndpointsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: EndpointsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+EndpointsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: EndpointsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: EndpointsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/services/flow-state-api.mjs

@@ -0,0 +1,142 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class FlowStateApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/configuration/states';
+    }
+    /**
+     * Initialize flow state
+     * @param request Request
+     * @returns Flow initialization response, which contains session ID and result of selectors
+     */
+    init(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/start`,
+            body: request,
+        });
+    }
+    /**
+     * Get existing state by ID
+     * @param id ID
+     * @returns Flow State
+     */
+    get(id) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${id}`,
+        });
+    }
+    /**
+     * Execute actions/selectors
+     * @param id State ID
+     * @param request Request
+     * @returns Execute result
+     */
+    execute(id, request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${id}/execute`,
+            body: request,
+        });
+    }
+    /**
+     * Save Quote in the state
+     * @param id State ID
+     */
+    save(id) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${id}/save`,
+        });
+    }
+    /**
+     * Submit Quote in the state
+     * @param id State ID
+     */
+    submit(id) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${id}/submit`,
+        });
+    }
+    /**
+     * Close Flow state
+     * @param id State ID
+     */
+    cancel(id) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${id}/cancel`,
+        });
+    }
+    /**
+     * Initialize stateful configuration
+     * @param stateId string
+     * @param request Request
+     * @returns Flow initialization response, which contains session ID and result of selectors
+     */
+    newConfiguration(stateId, request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${stateId}/configuration/new`,
+            body: request,
+        });
+    }
+    /**
+     * Start stateful configuration
+     * @param stateId string
+     * @param request Request
+     * @returns Flow initialization response, which contains session ID and result of selectors
+     */
+    startConfiguration(stateId, request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${stateId}/configuration/start`,
+            body: request,
+        });
+    }
+    /**
+     * Execute stateful configuration
+     * @param stateId string
+     * @param configurationId string
+     * @param request Request
+     * @returns Flow initialization response, which contains session ID and result of selectors
+     */
+    executeConfiguration(stateId, configurationId, request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${stateId}/configuration/${configurationId}/execute`,
+            body: request,
+        });
+    }
+    /**
+     * Save stateful configuration
+     * @param stateId string
+     * @param configurationId string
+     */
+    saveConfiguration(stateId, configurationId) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${stateId}/configuration/${configurationId}/save`,
+        });
+    }
+    /**
+     * Cancel stateful configuration
+     * @param stateId string
+     * @param configurationId string
+     */
+    cancelConfiguration(stateId, configurationId) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/quote/${stateId}/configuration/${configurationId}/cancel`,
+        });
+    }
+}
+FlowStateApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-state-api.js","sourceRoot":"","sources":["../../../../../../../libs/api/src/lib/services/flow-state-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  BaseHttpService,\n  ConfigurationStateExecuteRequest,\n  ConfigurationStateNewRequest,\n  ConfigurationStateStartRequest,\n  FlowState,\n  FlowStateExecutionRequestDTO,\n  FlowStateExecutionResult,\n  FlowStateInitRequest,\n  FlowStateInitResponse,\n} from '@veloceapps/core';\nimport { Observable } from 'rxjs';\n\n@Injectable()\nexport class FlowStateApiService {\n  private readonly SERVICE_URL = '/configuration/states';\n\n  constructor(private httpService: BaseHttpService) {}\n\n  /**\n   * Initialize flow state\n   * @param request Request\n   * @returns Flow initialization response, which contains session ID and result of selectors\n   */\n  public init(request: FlowStateInitRequest): Observable<FlowStateInitResponse> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/start`,\n      body: request,\n    });\n  }\n\n  /**\n   * Get existing state by ID\n   * @param id ID\n   * @returns Flow State\n   */\n  public get(id: string): Observable<FlowState> {\n    return this.httpService.api({\n      url: `${this.SERVICE_URL}/${id}`,\n    });\n  }\n\n  /**\n   * Execute actions/selectors\n   * @param id State ID\n   * @param request Request\n   * @returns Execute result\n   */\n  public execute(id: string, request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${id}/execute`,\n      body: request,\n    });\n  }\n\n  /**\n   * Save Quote in the state\n   * @param id State ID\n   */\n  public save(id: string): Observable<{ quoteId: string }> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${id}/save`,\n    });\n  }\n\n  /**\n   * Submit Quote in the state\n   * @param id State ID\n   */\n  public submit(id: string): Observable<{ quoteId: string }> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${id}/submit`,\n    });\n  }\n\n  /**\n   * Close Flow state\n   * @param id State ID\n   */\n  public cancel(id: string): Observable<void> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${id}/cancel`,\n    });\n  }\n\n  /**\n   * Initialize stateful configuration\n   * @param stateId string\n   * @param request Request\n   * @returns Flow initialization response, which contains session ID and result of selectors\n   */\n  public newConfiguration(\n    stateId: string,\n    request: ConfigurationStateNewRequest,\n  ): Observable<FlowStateExecutionResult> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${stateId}/configuration/new`,\n      body: request,\n    });\n  }\n\n  /**\n   * Start stateful configuration\n   * @param stateId string\n   * @param request Request\n   * @returns Flow initialization response, which contains session ID and result of selectors\n   */\n  public startConfiguration(\n    stateId: string,\n    request: ConfigurationStateStartRequest,\n  ): Observable<FlowStateExecutionResult> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${stateId}/configuration/start`,\n      body: request,\n    });\n  }\n\n  /**\n   * Execute stateful configuration\n   * @param stateId string\n   * @param configurationId string\n   * @param request Request\n   * @returns Flow initialization response, which contains session ID and result of selectors\n   */\n  public executeConfiguration(\n    stateId: string,\n    configurationId: string,\n    request: ConfigurationStateExecuteRequest,\n  ): Observable<FlowStateExecutionResult> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${stateId}/configuration/${configurationId}/execute`,\n      body: request,\n    });\n  }\n\n  /**\n   * Save stateful configuration\n   * @param stateId string\n   * @param configurationId string\n   */\n  public saveConfiguration(stateId: string, configurationId: string): Observable<{ quoteId: string }> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${stateId}/configuration/${configurationId}/save`,\n    });\n  }\n\n  /**\n   * Cancel stateful configuration\n   * @param stateId string\n   * @param configurationId string\n   */\n  public cancelConfiguration(stateId: string, configurationId: string): Observable<void> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/quote/${stateId}/configuration/${configurationId}/cancel`,\n    });\n  }\n}\n"]}