@veeroute/lss-packer-angular 6.20.2258 → 7.0.2395

package/README.md

@@ -1,4 +1,4 @@
-## @veeroute/lss-packer-angular@6.20.2258
+## @veeroute/lss-packer-angular@7.0.2395
 
 ## General usage
 

package/api/packService.d.ts

@@ -5,7 +5,7 @@ import { CalculationStatePacker } from '../model/calculationState';
 import { PackResultPacker } from '../model/packResult';
 import { ValidateResultPacker } from '../model/validateResult';
 import { Configuration } from '../configuration';
-import { PackServiceInterface, CancelPackCalculationRequestParams, DeletePackResultRequestParams, ReadPackCalculationStateRequestParams, ReadPackResultRequestParams, RunPackCalculationRequestParams, RunPackCalculationAsyncRequestParams, RunPackValidationRequestParams } from './packServiceInterface';
+import { PackServiceInterface, CancelPackCalculationRequestParams, DeletePackResultRequestParams, ReadPackResultRequestParams, ReadPackStateRequestParams, RunPackCalculationRequestParams, RunPackCalculationAsyncRequestParams, RunPackValidationRequestParams } from './packServiceInterface';
 import * as i0 from "@angular/core";
 export declare class PackService implements PackServiceInterface {
     protected httpClient: HttpClient;
@@ -26,14 +26,17 @@ export declare class PackService implements PackServiceInterface {
     cancelPackCalculation(requestParameters: CancelPackCalculationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<any>;
     cancelPackCalculation(requestParameters: CancelPackCalculationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<any>>;
     cancelPackCalculation(requestParameters: CancelPackCalculationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<any>>;
     /**
      * Result removal
@@ -45,53 +48,62 @@ export declare class PackService implements PackServiceInterface {
     deletePackResult(requestParameters: DeletePackResultRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<any>;
     deletePackResult(requestParameters: DeletePackResultRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<any>>;
     deletePackResult(requestParameters: DeletePackResultRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<any>>;
     /**
-     * Calculation state
-     * Read calculation state by the calculation identifier.
+     * Getting the result
+     * Getting the result based on the calculation identifier.
      * @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.
      */
-    readPackCalculationState(requestParameters: ReadPackCalculationStateRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+    readPackResult(requestParameters: ReadPackResultRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
-    }): Observable<CalculationStatePacker>;
-    readPackCalculationState(requestParameters: ReadPackCalculationStateRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        transferCache?: boolean;
+    }): Observable<PackResultPacker>;
+    readPackResult(requestParameters: ReadPackResultRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
-    }): Observable<HttpResponse<CalculationStatePacker>>;
-    readPackCalculationState(requestParameters: ReadPackCalculationStateRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PackResultPacker>>;
+    readPackResult(requestParameters: ReadPackResultRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
-    }): Observable<HttpEvent<CalculationStatePacker>>;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PackResultPacker>>;
     /**
-     * Getting the result
-     * Getting the result based on the calculation identifier.
+     * Calculation state
+     * Read calculation state by the calculation identifier.
      * @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.
      */
-    readPackResult(requestParameters: ReadPackResultRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+    readPackState(requestParameters: ReadPackStateRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
-    }): Observable<PackResultPacker>;
-    readPackResult(requestParameters: ReadPackResultRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        transferCache?: boolean;
+    }): Observable<CalculationStatePacker>;
+    readPackState(requestParameters: ReadPackStateRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
-    }): Observable<HttpResponse<PackResultPacker>>;
-    readPackResult(requestParameters: ReadPackResultRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CalculationStatePacker>>;
+    readPackState(requestParameters: ReadPackStateRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
-    }): Observable<HttpEvent<PackResultPacker>>;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CalculationStatePacker>>;
     /**
      * Packing (SYNC)
      * Planning the optimal package.
@@ -102,14 +114,17 @@ export declare class PackService implements PackServiceInterface {
     runPackCalculation(requestParameters: RunPackCalculationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<PackResultPacker>;
     runPackCalculation(requestParameters: RunPackCalculationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<PackResultPacker>>;
     runPackCalculation(requestParameters: RunPackCalculationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<PackResultPacker>>;
     /**
      * Packing (ASYNC)
@@ -121,14 +136,17 @@ export declare class PackService implements PackServiceInterface {
     runPackCalculationAsync(requestParameters: RunPackCalculationAsyncRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<CalculationAsyncResultPacker>;
     runPackCalculationAsync(requestParameters: RunPackCalculationAsyncRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<CalculationAsyncResultPacker>>;
     runPackCalculationAsync(requestParameters: RunPackCalculationAsyncRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<CalculationAsyncResultPacker>>;
     /**
      * Data validation
@@ -140,14 +158,17 @@ export declare class PackService implements PackServiceInterface {
     runPackValidation(requestParameters: RunPackValidationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ValidateResultPacker>;
     runPackValidation(requestParameters: RunPackValidationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ValidateResultPacker>>;
     runPackValidation(requestParameters: RunPackValidationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ValidateResultPacker>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<PackService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PackService>;

package/api/packServiceInterface.d.ts

@@ -1,7 +1,7 @@
 /**
  * VRt.Packer [PC]
  *
- * The version of the OpenAPI document: 6.20.2258
+ * The version of the OpenAPI document: 7.0.2395
  * Contact: servicedesk@veeroute.com
  *
  * NOTE: This class is auto generated by OpenAPI Generator.
@@ -16,16 +16,16 @@ import { PackTaskPacker } from '../model/models';
 import { ValidateResultPacker } from '../model/models';
 import { Configuration } from '../configuration';
 export interface CancelPackCalculationRequestParams {
-    id: string;
+    processCode: string;
 }
 export interface DeletePackResultRequestParams {
-    id: string;
-}
-export interface ReadPackCalculationStateRequestParams {
-    id: string;
+    processCode: string;
 }
 export interface ReadPackResultRequestParams {
-    id: string;
+    processCode: string;
+}
+export interface ReadPackStateRequestParams {
+    processCode: string;
 }
 export interface RunPackCalculationRequestParams {
     packTaskPacker: PackTaskPacker;
@@ -51,18 +51,18 @@ export interface PackServiceInterface {
 * @param requestParameters
      */
     deletePackResult(requestParameters: DeletePackResultRequestParams, extraHttpRequestParams?: any): Observable<{}>;
-    /**
-     * Calculation state
-     * Read calculation state by the calculation identifier.
-* @param requestParameters
-     */
-    readPackCalculationState(requestParameters: ReadPackCalculationStateRequestParams, extraHttpRequestParams?: any): Observable<CalculationStatePacker>;
     /**
      * Getting the result
      * Getting the result based on the calculation identifier.
 * @param requestParameters
      */
     readPackResult(requestParameters: ReadPackResultRequestParams, extraHttpRequestParams?: any): Observable<PackResultPacker>;
+    /**
+     * Calculation state
+     * Read calculation state by the calculation identifier.
+* @param requestParameters
+     */
+    readPackState(requestParameters: ReadPackStateRequestParams, extraHttpRequestParams?: any): Observable<CalculationStatePacker>;
     /**
      * Packing (SYNC)
      * Planning the optimal package.

package/api/systemService.d.ts

@@ -23,14 +23,17 @@ export declare class SystemService implements SystemServiceInterface {
     check(observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<CheckResultPacker>;
     check(observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<CheckResultPacker>>;
     check(observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<CheckResultPacker>>;
     /**
      * Getting the documentation
@@ -42,14 +45,17 @@ export declare class SystemService implements SystemServiceInterface {
     file(requestParameters: FileRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'text/html' | 'text/plain' | 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<string>;
     file(requestParameters: FileRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'text/html' | 'text/plain' | 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<string>>;
     file(requestParameters: FileRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'text/html' | 'text/plain' | 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<string>>;
     /**
      * Getting the service version
@@ -60,14 +66,17 @@ export declare class SystemService implements SystemServiceInterface {
     version(observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<VersionResultPacker>;
     version(observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<VersionResultPacker>>;
     version(observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<VersionResultPacker>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SystemService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SystemService>;

package/api/systemServiceInterface.d.ts

@@ -1,7 +1,7 @@
 /**
  * VRt.Packer [PC]
  *
- * The version of the OpenAPI document: 6.20.2258
+ * The version of the OpenAPI document: 7.0.2395
  * Contact: servicedesk@veeroute.com
  *
  * NOTE: This class is auto generated by OpenAPI Generator.

package/cfg/{method_groups.json → process_types.json}

@@ -4,61 +4,61 @@
             "method": "POST",
             "uri": "/packer/pack/calculation",
             "operation_id": "run_pack_calculation",
-            "group": "PACK"
+            "type": "PLAN"
         },
         {
             "method": "POST",
-            "uri": "/packer/pack/calculation_async",
+            "uri": "/packer/pack/calculation-async",
             "operation_id": "run_pack_calculation_async",
-            "group": "PACK"
-        },
-        {
-            "method": "GET",
-            "uri": "/packer/pack/calculation_async/{id}",
-            "operation_id": "read_pack_calculation_state",
-            "group": "NOTRACE"
+            "type": "PLAN"
         },
         {
             "method": "DELETE",
-            "uri": "/packer/pack/calculation_async/{id}",
+            "uri": "/packer/pack/calculation-async/{process_code}",
             "operation_id": "cancel_pack_calculation",
-            "group": "TRACE"
+            "type": "TRACE"
+        },
+        {
+            "method": "GET",
+            "uri": "/packer/pack/state/{process_code}",
+            "operation_id": "read_pack_state",
+            "type": "NOTRACE"
         },
         {
             "method": "GET",
-            "uri": "/packer/pack/result/{id}",
+            "uri": "/packer/pack/result/{process_code}",
             "operation_id": "read_pack_result",
-            "group": "TRACE"
+            "type": "TRACE"
         },
         {
             "method": "DELETE",
-            "uri": "/packer/pack/result/{id}",
+            "uri": "/packer/pack/result/{process_code}",
             "operation_id": "delete_pack_result",
-            "group": "TRACE"
+            "type": "TRACE"
         },
         {
             "method": "POST",
             "uri": "/packer/pack/validation",
             "operation_id": "run_pack_validation",
-            "group": "VALIDATE"
+            "type": "VALIDATE"
         },
         {
             "method": "GET",
             "uri": "/packer/system/check",
             "operation_id": "check",
-            "group": "NOTRACE"
+            "type": "NOTRACE"
         },
         {
             "method": "GET",
             "uri": "/packer/system/version",
             "operation_id": "version",
-            "group": "NOTRACE"
+            "type": "NOTRACE"
         },
         {
             "method": "GET",
             "uri": "/packer/file/{filename}",
             "operation_id": "file",
-            "group": "NOTRACE"
+            "type": "NOTRACE"
         }
     ]
 }