@veeroute/lss-studio-angular 6.20.2252 → 7.0.2395

package/README.md

@@ -1,4 +1,4 @@
-## @veeroute/lss-studio-angular@6.20.2252
+## @veeroute/lss-studio-angular@7.0.2395
 
 ## General usage
 

package/api/experimentsService.d.ts

@@ -1,9 +1,10 @@
 import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { CalculationHistoryElementStudio } from '../model/calculationHistoryElement';
 import { ExperimentStudio } from '../model/experiment';
 import { UniversalDataStudio } from '../model/universalData';
 import { Configuration } from '../configuration';
-import { ExperimentsServiceInterface, CreateExperimentRequestParams, DeleteExperimentRequestParams, DuplicateExperimentRequestParams, ExportJsonRequestParams, ExportXlsxRequestParams, ImportJsonRequestParams, ImportJsonTracecodeRequestParams, ImportJsonUrlRequestParams, ImportXlsxRequestParams, ReadExperimentRequestParams, RunExperimentCalculationRequestParams, RunExperimentValidationRequestParams, StopExperimentCalculationRequestParams, UpdateExperimentRequestParams, UpdateExperimentIndicatorsRequestParams, UpdateExperimentSettingsRequestParams } from './experimentsServiceInterface';
+import { ExperimentsServiceInterface, CreateExperimentRequestParams, DeleteExperimentRequestParams, DuplicateExperimentRequestParams, ExportJsonRequestParams, ExportXlsxRequestParams, ImportJsonRequestParams, ImportJsonTracedataRequestParams, ImportJsonUrlRequestParams, ImportXlsxRequestParams, ReadExperimentRequestParams, ReadExperimentCalculationHistoryRequestParams, RunExperimentCalculationRequestParams, RunExperimentValidationRequestParams, StopExperimentCalculationRequestParams, UpdateExperimentRequestParams, UpdateExperimentIndicatorsRequestParams, UpdateExperimentSettingsRequestParams } from './experimentsServiceInterface';
 import * as i0 from "@angular/core";
 export declare class ExperimentsService implements ExperimentsServiceInterface {
     protected httpClient: HttpClient;
@@ -24,14 +25,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     createExperiment(requestParameters: CreateExperimentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<string>;
     createExperiment(requestParameters: CreateExperimentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<string>>;
     createExperiment(requestParameters: CreateExperimentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<string>>;
     /**
      * Experiment removal
@@ -43,14 +47,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     deleteExperiment(requestParameters: DeleteExperimentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<any>;
     deleteExperiment(requestParameters: DeleteExperimentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<any>>;
     deleteExperiment(requestParameters: DeleteExperimentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<any>>;
     /**
      * Experiment duplicate
@@ -62,14 +69,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     duplicateExperiment(requestParameters: DuplicateExperimentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<string>;
     duplicateExperiment(requestParameters: DuplicateExperimentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<string>>;
     duplicateExperiment(requestParameters: DuplicateExperimentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<string>>;
     /**
      * Export (JSON)
@@ -81,14 +91,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     exportJson(requestParameters: ExportJsonRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<UniversalDataStudio>;
     exportJson(requestParameters: ExportJsonRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<UniversalDataStudio>>;
     exportJson(requestParameters: ExportJsonRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<UniversalDataStudio>>;
     /**
      * Export (XLSX)
@@ -100,14 +113,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     exportXlsx(requestParameters: ExportXlsxRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/octet-stream' | 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<string>;
     exportXlsx(requestParameters: ExportXlsxRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/octet-stream' | 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<string>>;
     exportXlsx(requestParameters: ExportXlsxRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/octet-stream' | 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<string>>;
     /**
      * Import (JSON)
@@ -119,33 +135,39 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     importJson(requestParameters: ImportJsonRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     importJson(requestParameters: ImportJsonRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     importJson(requestParameters: ImportJsonRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
-     * Import by tracecode
-     * Importing new data from a VRt.Universal JSON file by tracecode. If the entity is already present in the experiment (determined by its key), it is updated, if not, a new one is created.
+     * Import by tracedata
+     * Importing new data from a VRt.Universal JSON file by &#x60;tracedata.process_code&#x60;. If the entity is already present in the experiment (determined by its key), it is updated, if not, a new one is created.
      * @param requestParameters
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    importJsonTracecode(requestParameters: ImportJsonTracecodeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+    importJsonTracedata(requestParameters: ImportJsonTracedataRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
-    importJsonTracecode(requestParameters: ImportJsonTracecodeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+    importJsonTracedata(requestParameters: ImportJsonTracedataRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
-    importJsonTracecode(requestParameters: ImportJsonTracecodeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+    importJsonTracedata(requestParameters: ImportJsonTracedataRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Import by URL (JSON)
@@ -157,18 +179,21 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     importJsonUrl(requestParameters: ImportJsonUrlRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     importJsonUrl(requestParameters: ImportJsonUrlRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     importJsonUrl(requestParameters: ImportJsonUrlRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Import (XLSX)
-     * Import (XLSX).
+     * Importing new data from an XLSX file. If an entity is already present in the experiment (determined by its key), it is updated; if not, a new one is created. The data time zone is taken from the XLSX file.
      * @param requestParameters
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
@@ -176,14 +201,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     importXlsx(requestParameters: ImportXlsxRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     importXlsx(requestParameters: ImportXlsxRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     importXlsx(requestParameters: ImportXlsxRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Reading experiment
@@ -195,15 +223,40 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     readExperiment(requestParameters: ReadExperimentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     readExperiment(requestParameters: ReadExperimentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     readExperiment(requestParameters: ReadExperimentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
+    /**
+     * Calculation history
+     * Read calculation history.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    readExperimentCalculationHistory(requestParameters: ReadExperimentCalculationHistoryRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<CalculationHistoryElementStudio>>;
+    readExperimentCalculationHistory(requestParameters: ReadExperimentCalculationHistoryRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<CalculationHistoryElementStudio>>>;
+    readExperimentCalculationHistory(requestParameters: ReadExperimentCalculationHistoryRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<CalculationHistoryElementStudio>>>;
     /**
      * Run calculation
      * Experiment calculation run.
@@ -214,14 +267,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     runExperimentCalculation(requestParameters: RunExperimentCalculationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     runExperimentCalculation(requestParameters: RunExperimentCalculationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     runExperimentCalculation(requestParameters: RunExperimentCalculationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Run validation
@@ -233,14 +289,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     runExperimentValidation(requestParameters: RunExperimentValidationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     runExperimentValidation(requestParameters: RunExperimentValidationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     runExperimentValidation(requestParameters: RunExperimentValidationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Calculation stop
@@ -252,14 +311,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     stopExperimentCalculation(requestParameters: StopExperimentCalculationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<any>;
     stopExperimentCalculation(requestParameters: StopExperimentCalculationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<any>>;
     stopExperimentCalculation(requestParameters: StopExperimentCalculationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<any>>;
     /**
      * Experiment update
@@ -271,14 +333,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     updateExperiment(requestParameters: UpdateExperimentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     updateExperiment(requestParameters: UpdateExperimentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     updateExperiment(requestParameters: UpdateExperimentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Indicators update
@@ -290,14 +355,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     updateExperimentIndicators(requestParameters: UpdateExperimentIndicatorsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     updateExperimentIndicators(requestParameters: UpdateExperimentIndicatorsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     updateExperimentIndicators(requestParameters: UpdateExperimentIndicatorsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     /**
      * Settings update
@@ -309,14 +377,17 @@ export declare class ExperimentsService implements ExperimentsServiceInterface {
     updateExperimentSettings(requestParameters: UpdateExperimentSettingsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentStudio>;
     updateExperimentSettings(requestParameters: UpdateExperimentSettingsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentStudio>>;
     updateExperimentSettings(requestParameters: UpdateExperimentSettingsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentStudio>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExperimentsService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ExperimentsService>;

package/api/experimentsServiceInterface.d.ts

@@ -1,7 +1,7 @@
 /**
  * VRt.Studio [ST]
  *
- * The version of the OpenAPI document: 6.20.2252
+ * The version of the OpenAPI document: 7.0.2395
  * Contact: servicedesk@veeroute.com
  *
  * NOTE: This class is auto generated by OpenAPI Generator.
@@ -10,6 +10,7 @@
 import { HttpHeaders } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { BasicProcessStudio } from '../model/models';
+import { CalculationHistoryElementStudio } from '../model/models';
 import { ExperimentSettingsStudio } from '../model/models';
 import { ExperimentSpecificationStudio } from '../model/models';
 import { ExperimentStudio } from '../model/models';
@@ -38,10 +39,10 @@ export interface ImportJsonRequestParams {
     experimentKey: string;
     universalDataStudio: UniversalDataStudio;
 }
-export interface ImportJsonTracecodeRequestParams {
+export interface ImportJsonTracedataRequestParams {
     experimentKey: string;
     source: ImportSourceStudio;
-    tracecode: string;
+    processCode: string;
     sample: ImportSampleStudio;
 }
 export interface ImportJsonUrlRequestParams {
@@ -51,11 +52,13 @@ export interface ImportJsonUrlRequestParams {
 export interface ImportXlsxRequestParams {
     experimentKey: string;
     body: string;
-    timezone?: number;
 }
 export interface ReadExperimentRequestParams {
     experimentKey: string;
 }
+export interface ReadExperimentCalculationHistoryRequestParams {
+    experimentKey: string;
+}
 export interface RunExperimentCalculationRequestParams {
     experimentKey: string;
     processName: BasicProcessStudio;
@@ -119,11 +122,11 @@ export interface ExperimentsServiceInterface {
      */
     importJson(requestParameters: ImportJsonRequestParams, extraHttpRequestParams?: any): Observable<ExperimentStudio>;
     /**
-     * Import by tracecode
-     * Importing new data from a VRt.Universal JSON file by tracecode. If the entity is already present in the experiment (determined by its key), it is updated, if not, a new one is created.
+     * Import by tracedata
+     * Importing new data from a VRt.Universal JSON file by &#x60;tracedata.process_code&#x60;. If the entity is already present in the experiment (determined by its key), it is updated, if not, a new one is created.
 * @param requestParameters
      */
-    importJsonTracecode(requestParameters: ImportJsonTracecodeRequestParams, extraHttpRequestParams?: any): Observable<ExperimentStudio>;
+    importJsonTracedata(requestParameters: ImportJsonTracedataRequestParams, extraHttpRequestParams?: any): Observable<ExperimentStudio>;
     /**
      * Import by URL (JSON)
      * Importing new data from a VRt.Universal JSON file by url. If the entity is already present in the experiment (determined by its key), it is updated, if not, a new one is created.
@@ -132,7 +135,7 @@ export interface ExperimentsServiceInterface {
     importJsonUrl(requestParameters: ImportJsonUrlRequestParams, extraHttpRequestParams?: any): Observable<ExperimentStudio>;
     /**
      * Import (XLSX)
-     * Import (XLSX).
+     * Importing new data from an XLSX file. If an entity is already present in the experiment (determined by its key), it is updated; if not, a new one is created. The data time zone is taken from the XLSX file.
 * @param requestParameters
      */
     importXlsx(requestParameters: ImportXlsxRequestParams, extraHttpRequestParams?: any): Observable<ExperimentStudio>;
@@ -142,6 +145,12 @@ export interface ExperimentsServiceInterface {
 * @param requestParameters
      */
     readExperiment(requestParameters: ReadExperimentRequestParams, extraHttpRequestParams?: any): Observable<ExperimentStudio>;
+    /**
+     * Calculation history
+     * Read calculation history.
+* @param requestParameters
+     */
+    readExperimentCalculationHistory(requestParameters: ReadExperimentCalculationHistoryRequestParams, extraHttpRequestParams?: any): Observable<Array<CalculationHistoryElementStudio>>;
     /**
      * Run calculation
      * Experiment calculation run.

package/api/explorerService.d.ts

@@ -3,7 +3,7 @@ import { Observable } from 'rxjs';
 import { ExperimentListStudio } from '../model/experimentList';
 import { FilesystemStudio } from '../model/filesystem';
 import { Configuration } from '../configuration';
-import { ExplorerServiceInterface, CreateFolderRequestParams, DeleteFolderRequestParams, GlobalSearchRequestParams, ReadFolderRequestParams, UpdateFolderRequestParams } from './explorerServiceInterface';
+import { ExplorerServiceInterface, CreateFolderRequestParams, DeleteExperimentsBatchRequestParams, DeleteFolderRequestParams, DeleteFoldersBatchRequestParams, GlobalSearchRequestParams, ReadFolderRequestParams, UpdateFolderRequestParams } from './explorerServiceInterface';
 import * as i0 from "@angular/core";
 export declare class ExplorerService implements ExplorerServiceInterface {
     protected httpClient: HttpClient;
@@ -24,15 +24,40 @@ export declare class ExplorerService implements ExplorerServiceInterface {
     createFolder(requestParameters: CreateFolderRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<string>;
     createFolder(requestParameters: CreateFolderRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<string>>;
     createFolder(requestParameters: CreateFolderRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<string>>;
+    /**
+     * Batch delete experiments
+     * Batch delete experiments.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    deleteExperimentsBatch(requestParameters: DeleteExperimentsBatchRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    deleteExperimentsBatch(requestParameters: DeleteExperimentsBatchRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    deleteExperimentsBatch(requestParameters: DeleteExperimentsBatchRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
     /**
      * Folder removal
      * Folder removal by key.
@@ -43,14 +68,39 @@ export declare class ExplorerService implements ExplorerServiceInterface {
     deleteFolder(requestParameters: DeleteFolderRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<any>;
     deleteFolder(requestParameters: DeleteFolderRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<any>>;
     deleteFolder(requestParameters: DeleteFolderRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Batch delete folders
+     * Batch delete folders.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    deleteFoldersBatch(requestParameters: DeleteFoldersBatchRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    deleteFoldersBatch(requestParameters: DeleteFoldersBatchRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    deleteFoldersBatch(requestParameters: DeleteFoldersBatchRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<any>>;
     /**
      * Experiment search
@@ -62,14 +112,17 @@ export declare class ExplorerService implements ExplorerServiceInterface {
     globalSearch(requestParameters: GlobalSearchRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentListStudio>;
     globalSearch(requestParameters: GlobalSearchRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentListStudio>>;
     globalSearch(requestParameters: GlobalSearchRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentListStudio>>;
     /**
      * Getting a filesystem
@@ -80,14 +133,17 @@ export declare class ExplorerService implements ExplorerServiceInterface {
     readFilesystem(observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<FilesystemStudio>;
     readFilesystem(observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<FilesystemStudio>>;
     readFilesystem(observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<FilesystemStudio>>;
     /**
      * Experiment list
@@ -99,14 +155,17 @@ export declare class ExplorerService implements ExplorerServiceInterface {
     readFolder(requestParameters: ReadFolderRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ExperimentListStudio>;
     readFolder(requestParameters: ReadFolderRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ExperimentListStudio>>;
     readFolder(requestParameters: ReadFolderRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ExperimentListStudio>>;
     /**
      * Update folder
@@ -118,14 +177,17 @@ export declare class ExplorerService implements ExplorerServiceInterface {
     updateFolder(requestParameters: UpdateFolderRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<FilesystemStudio>;
     updateFolder(requestParameters: UpdateFolderRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<FilesystemStudio>>;
     updateFolder(requestParameters: UpdateFolderRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<FilesystemStudio>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExplorerService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ExplorerService>;

package/api/explorerServiceInterface.d.ts

@@ -1,7 +1,7 @@
 /**
  * VRt.Studio [ST]
  *
- * The version of the OpenAPI document: 6.20.2252
+ * The version of the OpenAPI document: 7.0.2395
  * Contact: servicedesk@veeroute.com
  *
  * NOTE: This class is auto generated by OpenAPI Generator.
@@ -16,9 +16,15 @@ import { Configuration } from '../configuration';
 export interface CreateFolderRequestParams {
     folderSpecificationStudio: FolderSpecificationStudio;
 }
+export interface DeleteExperimentsBatchRequestParams {
+    requestBody: Array<string>;
+}
 export interface DeleteFolderRequestParams {
     folderKey: string;
 }
+export interface DeleteFoldersBatchRequestParams {
+    requestBody: Array<string>;
+}
 export interface GlobalSearchRequestParams {
     filter?: string;
     offset?: number;
@@ -28,6 +34,9 @@ export interface GlobalSearchRequestParams {
 export interface ReadFolderRequestParams {
     folderKey: string;
     filter?: string;
+    offset?: number;
+    limit?: number;
+    sortDirection?: 'ASC' | 'DESC';
 }
 export interface UpdateFolderRequestParams {
     folderKey: string;
@@ -42,12 +51,24 @@ export interface ExplorerServiceInterface {
 * @param requestParameters
      */
     createFolder(requestParameters: CreateFolderRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Batch delete experiments
+     * Batch delete experiments.
+* @param requestParameters
+     */
+    deleteExperimentsBatch(requestParameters: DeleteExperimentsBatchRequestParams, extraHttpRequestParams?: any): Observable<{}>;
     /**
      * Folder removal
      * Folder removal by key.
 * @param requestParameters
      */
     deleteFolder(requestParameters: DeleteFolderRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+    /**
+     * Batch delete folders
+     * Batch delete folders.
+* @param requestParameters
+     */
+    deleteFoldersBatch(requestParameters: DeleteFoldersBatchRequestParams, extraHttpRequestParams?: any): Observable<{}>;
     /**
      * Experiment search
      * Experiment global search.