@veeroute/lss-studio-angular 6.20.2258 → 7.1.2439

package/README.md

@@ -1,4 +1,4 @@
-## @veeroute/lss-studio-angular@6.20.2258
+## @veeroute/lss-studio-angular@7.1.2439
 
 ## General usage
 

package/api/api.d.ts

@@ -4,6 +4,9 @@ export * from './experimentsServiceInterface';
 export * from './explorerService';
 import { ExplorerService } from './explorerService';
 export * from './explorerServiceInterface';
+export * from './factsService';
+import { FactsService } from './factsService';
+export * from './factsServiceInterface';
 export * from './hardlinksService';
 import { HardlinksService } from './hardlinksService';
 export * from './hardlinksServiceInterface';
@@ -25,4 +28,4 @@ export * from './transportsServiceInterface';
 export * from './tripsService';
 import { TripsService } from './tripsService';
 export * from './tripsServiceInterface';
-export declare const APIS: (typeof ExperimentsService | typeof ExplorerService | typeof HardlinksService | typeof LocationsService | typeof OrdersService | typeof PerformersService | typeof SystemService | typeof TransportsService | typeof TripsService)[];
+export declare const APIS: (typeof ExperimentsService | typeof ExplorerService | typeof FactsService | typeof HardlinksService | typeof LocationsService | typeof OrdersService | typeof PerformersService | typeof SystemService | typeof TransportsService | typeof TripsService)[];

package/api/experimentsService.d.ts

@@ -1,9 +1,11 @@
 import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { CalculationHistoryElementStudio } from '../model/calculationHistoryElement';
+import { ExperimentNeighborsStudio } from '../model/experimentNeighbors';
 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, ReadExperimentNeighborsRequestParams, 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 +26,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 +48,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 +70,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 +92,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 +114,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 +136,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 +180,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 +202,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 +224,62 @@ 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>>>;
+    /**
+     * Experiment neighbors
+     * Experiment neighbors.
+     * @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.
+     */
+    readExperimentNeighbors(requestParameters: ReadExperimentNeighborsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExperimentNeighborsStudio>;
+    readExperimentNeighbors(requestParameters: ReadExperimentNeighborsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExperimentNeighborsStudio>>;
+    readExperimentNeighbors(requestParameters: ReadExperimentNeighborsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExperimentNeighborsStudio>>;
     /**
      * Run calculation
      * Experiment calculation run.
@@ -214,14 +290,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 +312,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 +334,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 +356,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 +378,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 +400,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.2258
+ * The version of the OpenAPI document: 7.1.2439
  * Contact: servicedesk@veeroute.com
  *
  * NOTE: This class is auto generated by OpenAPI Generator.
@@ -10,6 +10,8 @@
 import { HttpHeaders } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { BasicProcessStudio } from '../model/models';
+import { CalculationHistoryElementStudio } from '../model/models';
+import { ExperimentNeighborsStudio } from '../model/models';
 import { ExperimentSettingsStudio } from '../model/models';
 import { ExperimentSpecificationStudio } from '../model/models';
 import { ExperimentStudio } from '../model/models';
@@ -38,10 +40,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 +53,17 @@ export interface ImportJsonUrlRequestParams {
 export interface ImportXlsxRequestParams {
     experimentKey: string;
     body: string;
-    timezone?: number;
 }
 export interface ReadExperimentRequestParams {
     experimentKey: string;
 }
+export interface ReadExperimentCalculationHistoryRequestParams {
+    experimentKey: string;
+}
+export interface ReadExperimentNeighborsRequestParams {
+    experimentKey: string;
+    sortDirection?: 'ASC' | 'DESC';
+}
 export interface RunExperimentCalculationRequestParams {
     experimentKey: string;
     processName: BasicProcessStudio;
@@ -119,11 +127,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 +140,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 +150,18 @@ 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>>;
+    /**
+     * Experiment neighbors
+     * Experiment neighbors.
+* @param requestParameters
+     */
+    readExperimentNeighbors(requestParameters: ReadExperimentNeighborsRequestParams, extraHttpRequestParams?: any): Observable<ExperimentNeighborsStudio>;
     /**
      * 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>;