@lcdp/api-react-rest-client 2.6.8-develop.9061867467 → 2.6.8-develop.9095887712

package/order/src/apis/ManageOrderItemApi.d.ts

@@ -10,15 +10,23 @@
  * Do not edit the class manually.
  */
 import { BaseAPI, ApiResponse, BlobWithMeta } from '../runtime';
-import { OrderItem, OrderItemUpdateParameters, OrderRemovedItem, OrderRemovedItemUpdateParameters, ShoppedOffer } from '../models';
+import { OrderItem, OrderItemRefundedCreationParameters, OrderItemUpdateParameters, OrderRefundedItem, OrderRefundedItemUpdateParameters, OrderRemovedItem, OrderRemovedItemUpdateParameters, ShoppedOffer } from '../models';
 export interface CreateOrUpdateOrderItemRequest {
     orderReference: string;
     shoppedOffer: ShoppedOffer;
 }
+export interface CreateOrderRefundedItemRequest {
+    orderReference: string;
+    orderItemRefundedCreationParameters: OrderItemRefundedCreationParameters;
+}
 export interface DeleteOrderItemRequest {
     orderReference: string;
     orderItemId: number;
 }
+export interface DeleteOrderRefundedItemRequest {
+    orderReference: string;
+    refundedItemId: number;
+}
 export interface DeleteOrderRemovedItemRequest {
     orderReference: string;
     removedItemId: number;
@@ -28,6 +36,11 @@ export interface UpdateOrderItemRequest {
     orderItemId: number;
     orderItemUpdateParameters: OrderItemUpdateParameters;
 }
+export interface UpdateOrderRefundedItemRequest {
+    orderReference: string;
+    refundedItemId: number;
+    orderRefundedItemUpdateParameters: OrderRefundedItemUpdateParameters;
+}
 export interface UpdateOrderRemovedItemRequest {
     orderReference: string;
     removedItemId: number;
@@ -47,6 +60,16 @@ export declare class ManageOrderItemApi extends BaseAPI {
      * Add item to order identified by orderReference
      */
     createOrUpdateOrderItem(requestParameters: CreateOrUpdateOrderItemRequest): Promise<OrderItem | BlobWithMeta>;
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than order item quantity.   - Quantity should be greater than 0
+     * Create refunded item for order identified by orderReference
+     */
+    createOrderRefundedItemRaw(requestParameters: CreateOrderRefundedItemRequest): Promise<ApiResponse<OrderRefundedItem | BlobWithMeta>>;
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than order item quantity.   - Quantity should be greater than 0
+     * Create refunded item for order identified by orderReference
+     */
+    createOrderRefundedItem(requestParameters: CreateOrderRefundedItemRequest): Promise<OrderRefundedItem | BlobWithMeta>;
     /**
      * Preconditions :   - Order items can be removed (If refund is needed, deletion will be forbidden)   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
      * Delete order item
@@ -57,6 +80,16 @@ export declare class ManageOrderItemApi extends BaseAPI {
      * Delete order item
      */
     deleteOrderItem(requestParameters: DeleteOrderItemRequest): Promise<void>;
+    /**
+     * Allow to delete a refunded item
+     * Delete refunded item refundedItemId for order identified by orderReference
+     */
+    deleteOrderRefundedItemRaw(requestParameters: DeleteOrderRefundedItemRequest): Promise<ApiResponse<void>>;
+    /**
+     * Allow to delete a refunded item
+     * Delete refunded item refundedItemId for order identified by orderReference
+     */
+    deleteOrderRefundedItem(requestParameters: DeleteOrderRefundedItemRequest): Promise<void>;
     /**
      * Allow to delete a removed item
      * Delete removed item removedItemId for order identified by orderReference
@@ -68,15 +101,25 @@ export declare class ManageOrderItemApi extends BaseAPI {
      */
     deleteOrderRemovedItem(requestParameters: DeleteOrderRemovedItemRequest): Promise<void>;
     /**
-     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed.   In case of refund: you can set the quantity at 0 Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
+     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed. Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
      * Update order item
      */
     updateOrderItemRaw(requestParameters: UpdateOrderItemRequest): Promise<ApiResponse<OrderItem | BlobWithMeta>>;
     /**
-     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed.   In case of refund: you can set the quantity at 0 Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
+     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed. Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
      * Update order item
      */
     updateOrderItem(requestParameters: UpdateOrderItemRequest): Promise<OrderItem | BlobWithMeta>;
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than depending order item quantity.
+     * Update refunded item refundedItemId for order identified by orderReference
+     */
+    updateOrderRefundedItemRaw(requestParameters: UpdateOrderRefundedItemRequest): Promise<ApiResponse<OrderRefundedItem | BlobWithMeta>>;
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than depending order item quantity.
+     * Update refunded item refundedItemId for order identified by orderReference
+     */
+    updateOrderRefundedItem(requestParameters: UpdateOrderRefundedItemRequest): Promise<OrderRefundedItem | BlobWithMeta>;
     /**
      * Restictions :   Quantity requested cannot be greater than current removed item quantity.   Quantity should be greater than 0 Side Effects :   The difference between current quantity and requested quantity will be added to order item.
      * Update removed item removedItemId for order identified by orderReference

package/order/src/apis/ManageOrderItemApi.js

@@ -163,13 +163,101 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than order item quantity.   - Quantity should be greater than 0
+     * Create refunded item for order identified by orderReference
+     */
+    ManageOrderItemApi.prototype.createOrderRefundedItemRaw = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, _a, response, contentType, response_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (requestParameters.orderReference === null || requestParameters.orderReference === undefined) {
+                            throw new runtime_1.RequiredError('orderReference', 'Required parameter requestParameters.orderReference was null or undefined when calling createOrderRefundedItem.');
+                        }
+                        if (requestParameters.orderItemRefundedCreationParameters === null || requestParameters.orderItemRefundedCreationParameters === undefined) {
+                            throw new runtime_1.RequiredError('orderItemRefundedCreationParameters', 'Required parameter requestParameters.orderItemRefundedCreationParameters was null or undefined when calling createOrderRefundedItem.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (this.configuration && this.configuration.apiKey) {
+                            headerParameters["x-api-key"] = this.configuration.apiKey("x-api-key"); // apiKeyAuth authentication
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 4];
+                        token = this.configuration.accessToken;
+                        if (!(typeof token === 'function')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = token;
+                        _b.label = 3;
+                    case 3:
+                        tokenString = _a;
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.request({
+                                path: "/orders/{orderReference}/refunded-items".replace("{".concat("orderReference", "}"), encodeURIComponent(String(requestParameters.orderReference))),
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, models_1.OrderItemRefundedCreationParametersToJSON)(requestParameters.orderItemRefundedCreationParameters),
+                            })];
+                    case 5:
+                        response = _b.sent();
+                        contentType = response.headers.get("content-type");
+                        if (contentType && contentType.indexOf("application/json") !== -1) {
+                            return [2 /*return*/, new runtime_1.JSONApiResponse(response, function (jsonValue) { return (0, models_1.OrderRefundedItemFromJSON)(jsonValue); })];
+                        }
+                        else if (contentType && contentType.indexOf("text/plain") !== -1) {
+                            return [2 /*return*/, new runtime_1.TextApiResponse(response)];
+                        }
+                        else {
+                            // TODO : Better handling of others application types
+                            return [2 /*return*/, new runtime_1.BlobWithMetaApiResponse(response)];
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        response_2 = _b.sent();
+                        console.debug(response_2);
+                        throw response_2;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than order item quantity.   - Quantity should be greater than 0
+     * Create refunded item for order identified by orderReference
+     */
+    ManageOrderItemApi.prototype.createOrderRefundedItem = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createOrderRefundedItemRaw(requestParameters)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Preconditions :   - Order items can be removed (If refund is needed, deletion will be forbidden)   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
      * Delete order item
      */
     ManageOrderItemApi.prototype.deleteOrderItemRaw = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, token, tokenString, _a, response, response_2;
+            var queryParameters, headerParameters, token, tokenString, _a, response, response_3;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -212,9 +300,9 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
                         response = _b.sent();
                         return [2 /*return*/, new runtime_1.VoidApiResponse(response)];
                     case 6:
-                        response_2 = _b.sent();
-                        console.debug(response_2);
-                        throw response_2;
+                        response_3 = _b.sent();
+                        console.debug(response_3);
+                        throw response_3;
                     case 7: return [2 /*return*/];
                 }
             });
@@ -236,13 +324,86 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Allow to delete a refunded item
+     * Delete refunded item refundedItemId for order identified by orderReference
+     */
+    ManageOrderItemApi.prototype.deleteOrderRefundedItemRaw = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, _a, response, response_4;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (requestParameters.orderReference === null || requestParameters.orderReference === undefined) {
+                            throw new runtime_1.RequiredError('orderReference', 'Required parameter requestParameters.orderReference was null or undefined when calling deleteOrderRefundedItem.');
+                        }
+                        if (requestParameters.refundedItemId === null || requestParameters.refundedItemId === undefined) {
+                            throw new runtime_1.RequiredError('refundedItemId', 'Required parameter requestParameters.refundedItemId was null or undefined when calling deleteOrderRefundedItem.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (this.configuration && this.configuration.apiKey) {
+                            headerParameters["x-api-key"] = this.configuration.apiKey("x-api-key"); // apiKeyAuth authentication
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 4];
+                        token = this.configuration.accessToken;
+                        if (!(typeof token === 'function')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = token;
+                        _b.label = 3;
+                    case 3:
+                        tokenString = _a;
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.request({
+                                path: "/orders/{orderReference}/refunded-items/{refundedItemId}".replace("{".concat("orderReference", "}"), encodeURIComponent(String(requestParameters.orderReference))).replace("{".concat("refundedItemId", "}"), encodeURIComponent(String(requestParameters.refundedItemId))),
+                                method: 'DELETE',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            })];
+                    case 5:
+                        response = _b.sent();
+                        return [2 /*return*/, new runtime_1.VoidApiResponse(response)];
+                    case 6:
+                        response_4 = _b.sent();
+                        console.debug(response_4);
+                        throw response_4;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Allow to delete a refunded item
+     * Delete refunded item refundedItemId for order identified by orderReference
+     */
+    ManageOrderItemApi.prototype.deleteOrderRefundedItem = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.deleteOrderRefundedItemRaw(requestParameters)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Allow to delete a removed item
      * Delete removed item removedItemId for order identified by orderReference
      */
     ManageOrderItemApi.prototype.deleteOrderRemovedItemRaw = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, token, tokenString, _a, response, response_3;
+            var queryParameters, headerParameters, token, tokenString, _a, response, response_5;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -285,9 +446,9 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
                         response = _b.sent();
                         return [2 /*return*/, new runtime_1.VoidApiResponse(response)];
                     case 6:
-                        response_3 = _b.sent();
-                        console.debug(response_3);
-                        throw response_3;
+                        response_5 = _b.sent();
+                        console.debug(response_5);
+                        throw response_5;
                     case 7: return [2 /*return*/];
                 }
             });
@@ -310,12 +471,12 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed.   In case of refund: you can set the quantity at 0 Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
+     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed. Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
      * Update order item
      */
     ManageOrderItemApi.prototype.updateOrderItemRaw = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, token, tokenString, _a, response, contentType, response_4;
+            var queryParameters, headerParameters, token, tokenString, _a, response, contentType, response_6;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -374,16 +535,16 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
                         }
                         return [3 /*break*/, 7];
                     case 6:
-                        response_4 = _b.sent();
-                        console.debug(response_4);
-                        throw response_4;
+                        response_6 = _b.sent();
+                        console.debug(response_6);
+                        throw response_6;
                     case 7: return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed.   In case of refund: you can set the quantity at 0 Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
+     * Important note :   In case of remove: As a business concern, it\'s mandatory to use \"deleteOrderItem\" to free up the line in the order.     See OrderItemsOperations to check when \"deleteOrderItem\" can be called.     If you call this route with \'0\' quantity and \"deleteOrderItem\" must be called, you will receive 412 - Precondition failed. Restrictions :   - Order item new quantity should be less or equals the current one Preconditions :   - No invoice edited for this order   - No payment transaction linked to this order   - You are the seller of the order or you are administrator
      * Update order item
      */
     ManageOrderItemApi.prototype.updateOrderItem = function (requestParameters) {
@@ -400,13 +561,104 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than depending order item quantity.
+     * Update refunded item refundedItemId for order identified by orderReference
+     */
+    ManageOrderItemApi.prototype.updateOrderRefundedItemRaw = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, _a, response, contentType, response_7;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (requestParameters.orderReference === null || requestParameters.orderReference === undefined) {
+                            throw new runtime_1.RequiredError('orderReference', 'Required parameter requestParameters.orderReference was null or undefined when calling updateOrderRefundedItem.');
+                        }
+                        if (requestParameters.refundedItemId === null || requestParameters.refundedItemId === undefined) {
+                            throw new runtime_1.RequiredError('refundedItemId', 'Required parameter requestParameters.refundedItemId was null or undefined when calling updateOrderRefundedItem.');
+                        }
+                        if (requestParameters.orderRefundedItemUpdateParameters === null || requestParameters.orderRefundedItemUpdateParameters === undefined) {
+                            throw new runtime_1.RequiredError('orderRefundedItemUpdateParameters', 'Required parameter requestParameters.orderRefundedItemUpdateParameters was null or undefined when calling updateOrderRefundedItem.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (this.configuration && this.configuration.apiKey) {
+                            headerParameters["x-api-key"] = this.configuration.apiKey("x-api-key"); // apiKeyAuth authentication
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 4];
+                        token = this.configuration.accessToken;
+                        if (!(typeof token === 'function')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = token;
+                        _b.label = 3;
+                    case 3:
+                        tokenString = _a;
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.request({
+                                path: "/orders/{orderReference}/refunded-items/{refundedItemId}".replace("{".concat("orderReference", "}"), encodeURIComponent(String(requestParameters.orderReference))).replace("{".concat("refundedItemId", "}"), encodeURIComponent(String(requestParameters.refundedItemId))),
+                                method: 'PUT',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, models_1.OrderRefundedItemUpdateParametersToJSON)(requestParameters.orderRefundedItemUpdateParameters),
+                            })];
+                    case 5:
+                        response = _b.sent();
+                        contentType = response.headers.get("content-type");
+                        if (contentType && contentType.indexOf("application/json") !== -1) {
+                            return [2 /*return*/, new runtime_1.JSONApiResponse(response, function (jsonValue) { return (0, models_1.OrderRefundedItemFromJSON)(jsonValue); })];
+                        }
+                        else if (contentType && contentType.indexOf("text/plain") !== -1) {
+                            return [2 /*return*/, new runtime_1.TextApiResponse(response)];
+                        }
+                        else {
+                            // TODO : Better handling of others application types
+                            return [2 /*return*/, new runtime_1.BlobWithMetaApiResponse(response)];
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        response_7 = _b.sent();
+                        console.debug(response_7);
+                        throw response_7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Restrictions :   - Quantity requested cannot be greater than depending order item quantity.
+     * Update refunded item refundedItemId for order identified by orderReference
+     */
+    ManageOrderItemApi.prototype.updateOrderRefundedItem = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.updateOrderRefundedItemRaw(requestParameters)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Restictions :   Quantity requested cannot be greater than current removed item quantity.   Quantity should be greater than 0 Side Effects :   The difference between current quantity and requested quantity will be added to order item.
      * Update removed item removedItemId for order identified by orderReference
      */
     ManageOrderItemApi.prototype.updateOrderRemovedItemRaw = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, token, tokenString, _a, response, contentType, response_5;
+            var queryParameters, headerParameters, token, tokenString, _a, response, contentType, response_8;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -465,9 +717,9 @@ var ManageOrderItemApi = /** @class */ (function (_super) {
                         }
                         return [3 /*break*/, 7];
                     case 6:
-                        response_5 = _b.sent();
-                        console.debug(response_5);
-                        throw response_5;
+                        response_8 = _b.sent();
+                        console.debug(response_8);
+                        throw response_8;
                     case 7: return [2 /*return*/];
                 }
             });

package/order/src/models/Order.d.ts

@@ -158,6 +158,12 @@ export interface Order {
      * @memberof Order
      */
     prices: OrderPrices;
+    /**
+     *
+     * @type {OrderPrices}
+     * @memberof Order
+     */
+    refundedPrices?: OrderPrices;
     /**
      *
      * @type {HttpLink}

package/order/src/models/Order.js

@@ -57,6 +57,7 @@ function OrderFromJSONTyped(json, ignoreDiscriminator) {
         'maxShippingDate': (new Date(json['maxShippingDate'])),
         'maxParcelPerShipment': json['maxParcelPerShipment'],
         'prices': (0, OrderPrices_1.OrderPricesFromJSON)(json['prices']),
+        'refundedPrices': !(0, runtime_1.exists)(json, 'refundedPrices') ? undefined : (0, OrderPrices_1.OrderPricesFromJSON)(json['refundedPrices']),
         'items': (0, HttpLink_1.HttpLinkFromJSON)(json['items']),
         'addedItems': (0, HttpLink_1.HttpLinkFromJSON)(json['addedItems']),
         'removedItems': (0, HttpLink_1.HttpLinkFromJSON)(json['removedItems']),
@@ -101,6 +102,7 @@ function OrderToJSON(value) {
         'maxShippingDate': ((0, runtime_1.toDateISOString)(value.maxShippingDate)),
         'maxParcelPerShipment': value.maxParcelPerShipment,
         'prices': (0, OrderPrices_1.OrderPricesToJSON)(value.prices),
+        'refundedPrices': (0, OrderPrices_1.OrderPricesToJSON)(value.refundedPrices),
         'items': (0, HttpLink_1.HttpLinkToJSON)(value.items),
         'addedItems': (0, HttpLink_1.HttpLinkToJSON)(value.addedItems),
         'removedItems': (0, HttpLink_1.HttpLinkToJSON)(value.removedItems),

package/order/src/models/OrderItemRefundedCreationParameters.d.ts

@@ -0,0 +1,39 @@
+/**
+ * lcdp-monolith-service
+ * This is the REST API of LCDP orders
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: contact@lecomptoirdespharmacies.fr
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface OrderItemRefundedCreationParameters
+ */
+export interface OrderItemRefundedCreationParameters {
+    /**
+     * Reference of the sale offer
+     * @type {string}
+     * @memberof OrderItemRefundedCreationParameters
+     */
+    saleOfferReference: string;
+    /**
+     * Id of the distribution range
+     * @type {number}
+     * @memberof OrderItemRefundedCreationParameters
+     */
+    distributionRangeId?: number;
+    /**
+     * Quantity of the order item to refund
+     * @type {number}
+     * @memberof OrderItemRefundedCreationParameters
+     */
+    quantity: number;
+}
+export declare function OrderItemRefundedCreationParametersFromJSON(json: any): OrderItemRefundedCreationParameters;
+export declare function OrderItemRefundedCreationParametersFromJSONTyped(json: any, ignoreDiscriminator: boolean): OrderItemRefundedCreationParameters;
+export declare function OrderItemRefundedCreationParametersToJSON(value?: OrderItemRefundedCreationParameters | null): any;

package/order/src/models/OrderItemRefundedCreationParameters.js

@@ -0,0 +1,46 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * lcdp-monolith-service
+ * This is the REST API of LCDP orders
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: contact@lecomptoirdespharmacies.fr
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderItemRefundedCreationParametersToJSON = exports.OrderItemRefundedCreationParametersFromJSONTyped = exports.OrderItemRefundedCreationParametersFromJSON = void 0;
+var runtime_1 = require("../runtime");
+function OrderItemRefundedCreationParametersFromJSON(json) {
+    return OrderItemRefundedCreationParametersFromJSONTyped(json, false);
+}
+exports.OrderItemRefundedCreationParametersFromJSON = OrderItemRefundedCreationParametersFromJSON;
+function OrderItemRefundedCreationParametersFromJSONTyped(json, ignoreDiscriminator) {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        'saleOfferReference': json['saleOfferReference'],
+        'distributionRangeId': !(0, runtime_1.exists)(json, 'distributionRangeId') ? undefined : json['distributionRangeId'],
+        'quantity': json['quantity'],
+    };
+}
+exports.OrderItemRefundedCreationParametersFromJSONTyped = OrderItemRefundedCreationParametersFromJSONTyped;
+function OrderItemRefundedCreationParametersToJSON(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        'saleOfferReference': value.saleOfferReference,
+        'distributionRangeId': value.distributionRangeId,
+        'quantity': value.quantity,
+    };
+}
+exports.OrderItemRefundedCreationParametersToJSON = OrderItemRefundedCreationParametersToJSON;

package/order/src/models/OrderRefundedItemUpdateParameters.d.ts

@@ -0,0 +1,22 @@
+/**
+ * lcdp-monolith-service
+ * This is the REST API of LCDP orders
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: contact@lecomptoirdespharmacies.fr
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { OrderItemUpdateParameters } from './OrderItemUpdateParameters';
+/**
+ *
+ * @export
+ * @interface OrderRefundedItemUpdateParameters
+ */
+export interface OrderRefundedItemUpdateParameters extends OrderItemUpdateParameters {
+}
+export declare function OrderRefundedItemUpdateParametersFromJSON(json: any): OrderRefundedItemUpdateParameters;
+export declare function OrderRefundedItemUpdateParametersFromJSONTyped(json: any, ignoreDiscriminator: boolean): OrderRefundedItemUpdateParameters;
+export declare function OrderRefundedItemUpdateParametersToJSON(value?: OrderRefundedItemUpdateParameters | null): any;

package/order/src/models/OrderRefundedItemUpdateParameters.js

@@ -0,0 +1,28 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * lcdp-monolith-service
+ * This is the REST API of LCDP orders
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: contact@lecomptoirdespharmacies.fr
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderRefundedItemUpdateParametersToJSON = exports.OrderRefundedItemUpdateParametersFromJSONTyped = exports.OrderRefundedItemUpdateParametersFromJSON = void 0;
+function OrderRefundedItemUpdateParametersFromJSON(json) {
+    return OrderRefundedItemUpdateParametersFromJSONTyped(json, false);
+}
+exports.OrderRefundedItemUpdateParametersFromJSON = OrderRefundedItemUpdateParametersFromJSON;
+function OrderRefundedItemUpdateParametersFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+exports.OrderRefundedItemUpdateParametersFromJSONTyped = OrderRefundedItemUpdateParametersFromJSONTyped;
+function OrderRefundedItemUpdateParametersToJSON(value) {
+    return value;
+}
+exports.OrderRefundedItemUpdateParametersToJSON = OrderRefundedItemUpdateParametersToJSON;

package/order/src/models/index.d.ts

@@ -18,6 +18,7 @@ export * from './Order';
 export * from './OrderAddedItem';
 export * from './OrderItem';
 export * from './OrderItemPrices';
+export * from './OrderItemRefundedCreationParameters';
 export * from './OrderItemUpdateParameters';
 export * from './OrderItemWarning';
 export * from './OrderItemWarningAllOf';
@@ -25,6 +26,7 @@ export * from './OrderItemsOperation';
 export * from './OrderJournal';
 export * from './OrderPrices';
 export * from './OrderRefundedItem';
+export * from './OrderRefundedItemUpdateParameters';
 export * from './OrderRemovedItem';
 export * from './OrderRemovedItemUpdateParameters';
 export * from './OrderStatus';

package/order/src/models/index.js

@@ -34,6 +34,7 @@ __exportStar(require("./Order"), exports);
 __exportStar(require("./OrderAddedItem"), exports);
 __exportStar(require("./OrderItem"), exports);
 __exportStar(require("./OrderItemPrices"), exports);
+__exportStar(require("./OrderItemRefundedCreationParameters"), exports);
 __exportStar(require("./OrderItemUpdateParameters"), exports);
 __exportStar(require("./OrderItemWarning"), exports);
 __exportStar(require("./OrderItemWarningAllOf"), exports);
@@ -41,6 +42,7 @@ __exportStar(require("./OrderItemsOperation"), exports);
 __exportStar(require("./OrderJournal"), exports);
 __exportStar(require("./OrderPrices"), exports);
 __exportStar(require("./OrderRefundedItem"), exports);
+__exportStar(require("./OrderRefundedItemUpdateParameters"), exports);
 __exportStar(require("./OrderRemovedItem"), exports);
 __exportStar(require("./OrderRemovedItemUpdateParameters"), exports);
 __exportStar(require("./OrderStatus"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lcdp/api-react-rest-client",
-  "version": "2.6.8-develop.9061867467",
+  "version": "2.6.8-develop.9095887712",
   "scripts": {
     "build": "tsc"
   },