@medusajs/order 0.1.3 → 1.0.0-rc-20241001083650

package/dist/services/order-module-service.js

@@ -1,10 +1,33 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -12,47 +35,63 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("@medusajs/types");
-const utils_1 = require("@medusajs/utils");
+const types_1 = require("@medusajs/framework/types");
+const utils_1 = require("@medusajs/framework/utils");
 const _models_1 = require("../models");
 const joiner_config_1 = require("../joiner-config");
 const utils_2 = require("../utils");
-const transform_order_1 = require("../utils/transform-order");
-const generateMethodForModels = [
-    _models_1.Address,
-    _models_1.LineItem,
-    _models_1.LineItemAdjustment,
-    _models_1.LineItemTaxLine,
-    _models_1.ShippingMethod,
-    _models_1.ShippingMethodAdjustment,
-    _models_1.ShippingMethodTaxLine,
-    _models_1.Transaction,
-    _models_1.OrderChange,
-    _models_1.OrderChangeAction,
-    _models_1.OrderItem,
-    _models_1.OrderSummary,
-    _models_1.OrderShippingMethod,
-];
-class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.Order, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
-    constructor({ baseRepository, orderService, addressService, lineItemService, shippingMethodAdjustmentService, shippingMethodService, lineItemAdjustmentService, shippingMethodTaxLineService, lineItemTaxLineService, transactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingMethodService, }, moduleDeclaration) {
+const BundledActions = __importStar(require("./actions"));
+const generateMethodForModels = {
+    Order: _models_1.Order,
+    OrderAddress: _models_1.OrderAddress,
+    OrderLineItem: _models_1.OrderLineItem,
+    OrderLineItemAdjustment: _models_1.OrderLineItemAdjustment,
+    OrderLineItemTaxLine: _models_1.OrderLineItemTaxLine,
+    OrderShippingMethod: _models_1.OrderShippingMethod,
+    OrderShippingMethodAdjustment: _models_1.OrderShippingMethodAdjustment,
+    OrderShippingMethodTaxLine: _models_1.OrderShippingMethodTaxLine,
+    OrderTransaction: _models_1.OrderTransaction,
+    OrderChange: _models_1.OrderChange,
+    OrderChangeAction: _models_1.OrderChangeAction,
+    OrderItem: _models_1.OrderItem,
+    OrderSummary: _models_1.OrderSummary,
+    OrderShipping: _models_1.OrderShipping,
+    ReturnReason: _models_1.ReturnReason,
+    Return: _models_1.Return,
+    ReturnItem: _models_1.ReturnItem,
+    OrderClaim: _models_1.OrderClaim,
+    OrderClaimItem: _models_1.OrderClaimItem,
+    OrderClaimItemImage: _models_1.OrderClaimItemImage,
+    OrderExchange: _models_1.OrderExchange,
+    OrderExchangeItem: _models_1.OrderExchangeItem,
+};
+// TODO: rm template args here, keep it for later to not collide with carlos work at least as little as possible
+class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
+    constructor({ baseRepository, orderService, orderAddressService, orderLineItemService, orderShippingMethodAdjustmentService, orderShippingMethodService, orderLineItemAdjustmentService, orderShippingMethodTaxLineService, orderLineItemTaxLineService, orderTransactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingService, returnReasonService, returnService, returnItemService, orderClaimService, orderExchangeService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
         this.baseRepository_ = baseRepository;
         this.orderService_ = orderService;
-        this.addressService_ = addressService;
-        this.lineItemService_ = lineItemService;
-        this.shippingMethodAdjustmentService_ = shippingMethodAdjustmentService;
-        this.shippingMethodService_ = shippingMethodService;
-        this.lineItemAdjustmentService_ = lineItemAdjustmentService;
-        this.shippingMethodTaxLineService_ = shippingMethodTaxLineService;
-        this.lineItemTaxLineService_ = lineItemTaxLineService;
-        this.transactionService_ = transactionService;
+        this.orderAddressService_ = orderAddressService;
+        this.orderLineItemService_ = orderLineItemService;
+        this.orderShippingMethodAdjustmentService_ =
+            orderShippingMethodAdjustmentService;
+        this.orderShippingMethodService_ = orderShippingMethodService;
+        this.orderLineItemAdjustmentService_ = orderLineItemAdjustmentService;
+        this.orderShippingMethodTaxLineService_ = orderShippingMethodTaxLineService;
+        this.orderLineItemTaxLineService_ = orderLineItemTaxLineService;
+        this.orderTransactionService_ = orderTransactionService;
         this.orderChangeService_ = orderChangeService;
         this.orderChangeActionService_ = orderChangeActionService;
         this.orderItemService_ = orderItemService;
         this.orderSummaryService_ = orderSummaryService;
-        this.orderShippingMethodService_ = orderShippingMethodService;
+        this.orderShippingService_ = orderShippingService;
+        this.returnReasonService_ = returnReasonService;
+        this.returnService_ = returnService;
+        this.returnItemService_ = returnItemService;
+        this.orderClaimService_ = orderClaimService;
+        this.orderExchangeService_ = orderExchangeService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
@@ -76,7 +115,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             "shipping_subtotal",
             "shipping_tax_total",
             "original_shipping_tax_total",
-            "original_shipping_tax_subtotal",
+            "original_shipping_subtotal",
             "original_shipping_total",
         ];
         const includeTotals = (config?.select ?? []).some((field) => totalFields.includes(field));
@@ -86,9 +125,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return includeTotals;
     }
     addRelationsToCalculateTotals(config, totalFields) {
-        config.relations ?? (config.relations = []);
-        config.select ?? (config.select = []);
-        const requiredFieldsForTotals = [
+        config.relations ??= [];
+        config.select ??= [];
+        const requiredRelationsForTotals = [
             "items",
             "items.tax_lines",
             "items.adjustments",
@@ -98,39 +137,150 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         ];
         config.relations = (0, utils_1.deduplicate)([
             ...config.relations,
-            ...requiredFieldsForTotals,
+            ...requiredRelationsForTotals,
         ]);
         config.select = config.select.filter((field) => {
-            return (!requiredFieldsForTotals.some((val) => val.startsWith(field)) && !totalFields.includes(field));
+            return (!requiredRelationsForTotals.some((val) => val.startsWith(field)) && !totalFields.includes(field));
+        });
+    }
+    // @ts-expect-error
+    async retrieveOrder(id, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const order = await super.retrieveOrder(id, config, sharedContext);
+        const orderChange = await this.getActiveOrderChange_(order.id, false, sharedContext);
+        order.order_change = orderChange;
+        return (0, utils_2.formatOrder)(order, {
+            entity: _models_1.Order,
+            includeTotals,
+        });
+    }
+    // @ts-expect-error
+    async listOrders(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const orders = await super.listOrders(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(orders, {
+            entity: _models_1.Order,
+            includeTotals,
+        });
+    }
+    // @ts-expect-error
+    async listAndCountOrders(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const [orders, count] = await super.listAndCountOrders(filters, config, sharedContext);
+        return [
+            (0, utils_2.formatOrder)(orders, {
+                entity: _models_1.Order,
+                includeTotals,
+            }),
+            count,
+        ];
+    }
+    // @ts-ignore
+    async retrieveReturn(id, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrder = await super.retrieveReturn(id, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrder, {
+            entity: _models_1.Return,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listReturns(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrders = await super.listReturns(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrders, {
+            entity: _models_1.Return,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listAndCountReturns(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const [returnOrders, count] = await super.listAndCountReturns(filters, config, sharedContext);
+        return [
+            (0, utils_2.formatOrder)(returnOrders, {
+                entity: _models_1.Return,
+                includeTotals,
+            }),
+            count,
+        ];
+    }
+    // @ts-ignore
+    async retrieveOrderClaim(id, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrder = await super.retrieveOrderClaim(id, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrder, {
+            entity: _models_1.OrderClaim,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listOrderClaims(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrders = await super.listOrderClaims(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrders, {
+            entity: _models_1.OrderClaim,
+            includeTotals,
         });
     }
-    async retrieve(id, config, sharedContext) {
-        config ?? (config = {});
+    // @ts-ignore
+    async listAndCountOrderClaims(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const [returnOrders, count] = await super.listAndCountOrderClaims(filters, config, sharedContext);
+        return [
+            (0, utils_2.formatOrder)(returnOrders, {
+                entity: _models_1.OrderClaim,
+                includeTotals,
+            }),
+            count,
+        ];
+    }
+    // @ts-ignore
+    async retrieveOrderExchange(id, config, sharedContext) {
+        config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
-        const order = await super.retrieve(id, config, sharedContext);
-        return (0, transform_order_1.formatOrder)(order, { includeTotals });
+        const returnOrder = await super.retrieveOrderExchange(id, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrder, {
+            entity: _models_1.OrderExchange,
+            includeTotals,
+        });
     }
-    async list(filters, config, sharedContext) {
-        config ?? (config = {});
+    // @ts-ignore
+    async listOrderExchanges(filters, config, sharedContext) {
+        config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
-        const orders = await super.list(filters, config, sharedContext);
-        return (0, transform_order_1.formatOrder)(orders, {
+        const returnOrders = await super.listOrderExchanges(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrders, {
+            entity: _models_1.OrderExchange,
             includeTotals,
         });
     }
-    async listAndCount(filters, config, sharedContext) {
-        config ?? (config = {});
+    // @ts-ignore
+    async listAndCountOrderExchanges(filters, config, sharedContext) {
+        config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
-        const [orders, count] = await super.listAndCount(filters, config, sharedContext);
+        const [returnOrders, count] = await super.listAndCountOrderExchanges(filters, config, sharedContext);
         return [
-            (0, transform_order_1.formatOrder)(orders, { includeTotals }),
+            (0, utils_2.formatOrder)(returnOrders, {
+                entity: _models_1.OrderExchange,
+                includeTotals,
+            }),
             count,
         ];
     }
-    async create(data, sharedContext = {}) {
+    async createOrders(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const orders = await this.create_(input, sharedContext);
-        const result = await this.list({
+        const orders = await this.createOrders_(input, sharedContext);
+        const result = await this.listOrders({
             id: orders.map((p) => p.id),
         }, {
             relations: [
@@ -148,7 +298,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }, sharedContext);
         return (Array.isArray(data) ? result : result[0]);
     }
-    async create_(data, sharedContext = {}) {
+    async createOrders_(data, sharedContext = {}) {
         const lineItemsToCreate = [];
         const createdOrders = [];
         for (const { items, shipping_methods, ...order } of data) {
@@ -161,6 +311,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             ord.shipping_methods = shippingMethods;
             const orderWithTotals = (0, utils_1.decorateCartTotals)({
                 ...ord,
+                shipping_methods,
                 items,
             });
             const calculated = (0, utils_2.calculateOrderChange)({
@@ -185,18 +336,18 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             }
         }
         if (lineItemsToCreate.length) {
-            await this.createLineItemsBulk_(lineItemsToCreate, sharedContext);
+            await this.createOrderLineItemsBulk_(lineItemsToCreate, sharedContext);
         }
         return createdOrders;
     }
-    async update(dataOrIdOrSelector, data, sharedContext = {}) {
-        const result = await this.update_(dataOrIdOrSelector, data, sharedContext);
+    async updateOrders(dataOrIdOrSelector, data, sharedContext = {}) {
+        const result = await this.updateOrders_(dataOrIdOrSelector, data, sharedContext);
         const serializedResult = await this.baseRepository_.serialize(result, {
             populate: true,
         });
         return (0, utils_1.isString)(dataOrIdOrSelector) ? serializedResult[0] : serializedResult;
     }
-    async update_(dataOrIdOrSelector, data, sharedContext = {}) {
+    async updateOrders_(dataOrIdOrSelector, data, sharedContext = {}) {
         let toUpdate = [];
         if ((0, utils_1.isString)(dataOrIdOrSelector)) {
             toUpdate = [
@@ -221,17 +372,17 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         const result = await this.orderService_.update(toUpdate, sharedContext);
         return result;
     }
-    async createLineItems(orderIdOrData, data, sharedContext = {}) {
+    async createOrderLineItems(orderIdOrData, data, sharedContext = {}) {
         let items = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            items = await this.createLineItems_(orderIdOrData, data, sharedContext);
+            items = await this.createOrderLineItems_(orderIdOrData, data, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.list({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
+            const order = await this.listOrders({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
             const mapOrderVersion = order.reduce((acc, curr) => {
                 acc[curr.id] = curr.version;
                 return acc;
@@ -242,14 +393,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                     version: mapOrderVersion[dt.order_id],
                 };
             });
-            items = await this.createLineItemsBulk_(lineItems, sharedContext);
+            items = await this.createOrderLineItemsBulk_(lineItems, sharedContext);
         }
         return await this.baseRepository_.serialize(items, {
             populate: true,
         });
     }
-    async createLineItems_(orderId, items, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id", "version"] }, sharedContext);
+    async createOrderLineItems_(orderId, items, sharedContext = {}) {
+        const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
         const toUpdate = items.map((item) => {
             return {
                 ...item,
@@ -257,11 +408,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 version: order.version,
             };
         });
-        return await this.createLineItemsBulk_(toUpdate, sharedContext);
+        return await this.createOrderLineItemsBulk_(toUpdate, sharedContext);
     }
-    async createLineItemsBulk_(data, sharedContext = {}) {
+    async createOrderLineItemsBulk_(data, sharedContext = {}) {
         const orderItemToCreate = [];
-        const lineItems = await this.lineItemService_.create(data, sharedContext);
+        const lineItems = await this.orderLineItemService_.create(data, sharedContext);
         for (let i = 0; i < lineItems.length; i++) {
             const item = lineItems[i];
             const toCreate = data[i];
@@ -279,10 +430,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }
         return lineItems;
     }
-    async updateLineItems(lineItemIdOrDataOrSelector, data, sharedContext = {}) {
+    async updateOrderLineItems(lineItemIdOrDataOrSelector, data, sharedContext = {}) {
         let items = [];
         if ((0, utils_1.isString)(lineItemIdOrDataOrSelector)) {
-            const item = await this.updateLineItem_(lineItemIdOrDataOrSelector, data, sharedContext);
+            const item = await this.updateOrderLineItem_(lineItemIdOrDataOrSelector, data, sharedContext);
             return await this.baseRepository_.serialize(item, {
                 populate: true,
             });
@@ -295,13 +446,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                     data: data,
                 },
             ];
-        items = await this.updateLineItemsWithSelector_(toUpdate, sharedContext);
+        items = await this.updateOrderLineItemsWithSelector_(toUpdate, sharedContext);
         return await this.baseRepository_.serialize(items, {
             populate: true,
         });
     }
-    async updateLineItem_(lineItemId, data, sharedContext = {}) {
-        const [item] = await this.lineItemService_.update([{ id: lineItemId, ...data }], sharedContext);
+    async updateOrderLineItem_(lineItemId, data, sharedContext = {}) {
+        const [item] = await this.orderLineItemService_.update([{ id: lineItemId, ...data }], sharedContext);
         if ("quantity" in data) {
             await this.updateOrderItemWithSelector_([
                 {
@@ -312,11 +463,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }
         return item;
     }
-    async updateLineItemsWithSelector_(updates, sharedContext = {}) {
+    async updateOrderLineItemsWithSelector_(updates, sharedContext = {}) {
         let toUpdate = [];
         const detailsToUpdate = [];
         for (const { selector, data } of updates) {
-            const items = await this.listLineItems({ ...selector }, {}, sharedContext);
+            const items = await this.listOrderLineItems({ ...selector }, {}, sharedContext);
             items.forEach((item) => {
                 toUpdate.push({
                     ...data,
@@ -333,7 +484,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         if (detailsToUpdate.length) {
             await this.updateOrderItemWithSelector_(detailsToUpdate, sharedContext);
         }
-        return await this.lineItemService_.update(toUpdate, sharedContext);
+        return await this.orderLineItemService_.update(toUpdate, sharedContext);
     }
     async updateOrderItem(orderItemIdOrDataOrSelector, data, sharedContext = {}) {
         let items = [];
@@ -373,35 +524,17 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }
         return await this.orderItemService_.update(toUpdate, sharedContext);
     }
-    async createAddresses(data, sharedContext = {}) {
-        const input = Array.isArray(data) ? data : [data];
-        const addresses = await this.createAddresses_(input, sharedContext);
-        const result = await this.listAddresses({ id: addresses.map((p) => p.id) }, {}, sharedContext);
-        return (Array.isArray(data) ? result : result[0]);
-    }
-    async createAddresses_(data, sharedContext = {}) {
-        return await this.addressService_.create(data, sharedContext);
-    }
-    async updateAddresses(data, sharedContext = {}) {
-        const input = Array.isArray(data) ? data : [data];
-        const addresses = await this.updateAddresses_(input, sharedContext);
-        const result = await this.listAddresses({ id: addresses.map((p) => p.id) }, {}, sharedContext);
-        return (Array.isArray(data) ? result : result[0]);
-    }
-    async updateAddresses_(data, sharedContext = {}) {
-        return await this.addressService_.update(data, sharedContext);
-    }
-    async createShippingMethods(orderIdOrData, data, sharedContext = {}) {
+    async createOrderShippingMethods(orderIdOrData, data, sharedContext = {}) {
         let methods;
         if ((0, utils_1.isString)(orderIdOrData)) {
-            methods = await this.createShippingMethods_(orderIdOrData, data, sharedContext);
+            methods = await this.createOrderShippingMethods_(orderIdOrData, data, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.list({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
+            const order = await this.listOrders({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
             const mapOrderVersion = order.reduce((acc, curr) => {
                 acc[curr.id] = curr.version;
                 return acc;
@@ -410,52 +543,86 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 return {
                     shipping_method: dt,
                     order_id: dt.order_id,
-                    version: mapOrderVersion[dt.order_id],
+                    return_id: dt.return_id,
+                    claim_id: dt.claim_id,
+                    exchange_id: dt.exchange_id,
+                    version: dt.version ?? mapOrderVersion[dt.order_id],
                 };
             });
-            methods = await this.createShippingMethodsBulk_(orderShippingMethodData, sharedContext);
+            methods = await this.createOrderShippingMethodsBulk_(orderShippingMethodData, sharedContext);
         }
         return await this.baseRepository_.serialize(methods, { populate: true });
     }
-    async createShippingMethods_(orderId, data, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id", "version"] }, sharedContext);
-        const methods = data.map((method) => {
+    async createOrderShippingMethods_(orderId, data, sharedContext = {}) {
+        const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
+        const methods = data.map((methodData) => {
             return {
-                shipping_method: method,
+                shipping_method: methodData,
                 order_id: order.id,
-                version: method.version ?? order.version ?? 1,
+                return_id: methodData.return_id,
+                claim_id: methodData.claim_id,
+                exchange_id: methodData.exchange_id,
+                version: methodData.version ?? order.version ?? 1,
             };
         });
-        return await this.createShippingMethodsBulk_(methods, sharedContext);
+        return await this.createOrderShippingMethodsBulk_(methods, sharedContext);
     }
-    async createShippingMethodsBulk_(data, sharedContext = {}) {
-        const sm = await this.orderShippingMethodService_.create(data, sharedContext);
+    async createOrderShippingMethodsBulk_(data, sharedContext = {}) {
+        const sm = await this.orderShippingService_.create(data, sharedContext);
         return sm.map((s) => s.shipping_method);
     }
-    async createLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+    // @ts-ignore
+    async softDeleteOrderShippingMethods(ids, config, sharedContext) {
+        const rel = await super.listOrderShippings({
+            shipping_method_id: ids,
+        }, {
+            select: ["id"],
+        }, sharedContext);
+        const orderShippingIds = rel.map((r) => r.id);
+        const [returned] = await (0, utils_1.promiseAll)([
+            super.softDeleteOrderShippingMethods(ids, config, sharedContext),
+            super.softDeleteOrderShippings(orderShippingIds, config, sharedContext),
+        ]);
+        return returned;
+    }
+    // @ts-ignore
+    async restoreOrderShippingMethods(ids, config, sharedContext) {
+        const rel = await super.listOrderShippings({
+            shipping_method_id: ids,
+        }, {
+            select: ["id"],
+        }, sharedContext);
+        const shippingIds = rel.map((r) => r.id);
+        const [returned] = await (0, utils_1.promiseAll)([
+            super.restoreOrderShippingMethods(ids, config, sharedContext),
+            super.restoreOrderShippings(shippingIds, config, sharedContext),
+        ]);
+        return returned;
+    }
+    async createOrderLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
+            const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
             const lineIds = order.items?.map((item) => item.id);
             for (const adj of adjustments || []) {
                 if (!lineIds?.includes(adj.item_id)) {
                     throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Line item with id ${adj.item_id} does not exist on order with id ${orderIdOrData}`);
                 }
             }
-            addedAdjustments = await this.lineItemAdjustmentService_.create(adjustments, sharedContext);
+            addedAdjustments = await this.orderLineItemAdjustmentService_.create(adjustments, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
-            addedAdjustments = await this.lineItemAdjustmentService_.create(data, sharedContext);
+            addedAdjustments = await this.orderLineItemAdjustmentService_.create(data, sharedContext);
         }
         return await this.baseRepository_.serialize(addedAdjustments, {
             populate: true,
         });
     }
-    async setLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
+    async setOrderLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
         const existingAdjustments = (order.items ?? [])
             .map((item) => item.adjustments ?? [])
             .flat()
@@ -471,15 +638,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             }
         });
         if (toDelete.length) {
-            await this.lineItemAdjustmentService_.delete(toDelete, sharedContext);
+            await this.orderLineItemAdjustmentService_.delete(toDelete, sharedContext);
         }
-        let result = await this.lineItemAdjustmentService_.upsert(adjustments, sharedContext);
+        let result = await this.orderLineItemAdjustmentService_.upsert(adjustments, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
-    async setShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
+    async setOrderShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
         const existingAdjustments = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.adjustments ?? [])
             .flat()
@@ -495,30 +662,32 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             }
         });
         if (toDelete.length) {
-            await this.shippingMethodAdjustmentService_.delete(toDelete, sharedContext);
+            await this.orderShippingMethodAdjustmentService_.delete(toDelete, sharedContext);
         }
-        const result = await this.shippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
+        const result = await this.orderShippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
-    async createShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+    async createOrderShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
+            const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
             const methodIds = order.shipping_methods?.map((method) => method.id);
             for (const adj of adjustments || []) {
                 if (!methodIds?.includes(adj.shipping_method_id)) {
                     throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Shipping method with id ${adj.shipping_method_id} does not exist on order with id ${orderIdOrData}`);
                 }
             }
-            addedAdjustments = await this.shippingMethodAdjustmentService_.create(adjustments, sharedContext);
+            addedAdjustments =
+                await this.orderShippingMethodAdjustmentService_.create(adjustments, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
-            addedAdjustments = await this.shippingMethodAdjustmentService_.create(data, sharedContext);
+            addedAdjustments =
+                await this.orderShippingMethodAdjustmentService_.create(data, sharedContext);
         }
         if ((0, utils_1.isObject)(orderIdOrData)) {
             return await this.baseRepository_.serialize(addedAdjustments[0], {
@@ -529,17 +698,17 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             populate: true,
         });
     }
-    async createLineItemTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+    async createOrderLineItemTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
         let addedTaxLines;
         if ((0, utils_1.isString)(orderIdOrData)) {
             const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
-            addedTaxLines = await this.lineItemTaxLineService_.create(lines, sharedContext);
+            addedTaxLines = await this.orderLineItemTaxLineService_.create(lines, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
-            addedTaxLines = await this.lineItemTaxLineService_.create(data, sharedContext);
+            addedTaxLines = await this.orderLineItemTaxLineService_.create(data, sharedContext);
         }
         const serialized = await this.baseRepository_.serialize(addedTaxLines, {
             populate: true,
@@ -549,8 +718,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }
         return serialized;
     }
-    async setLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
+    async setOrderLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.items ?? [])
             .map((item) => item.tax_lines ?? [])
             .flat()
@@ -565,21 +734,21 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             }
         });
         if (toDelete.length) {
-            await this.lineItemTaxLineService_.delete(toDelete, sharedContext);
+            await this.orderLineItemTaxLineService_.delete(toDelete, sharedContext);
         }
-        const result = await this.lineItemTaxLineService_.upsert(taxLines, sharedContext);
+        const result = await this.orderLineItemTaxLineService_.upsert(taxLines, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
-    async createShippingMethodTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+    async createOrderShippingMethodTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
         let addedTaxLines;
         if ((0, utils_1.isString)(orderIdOrData)) {
             const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
-            addedTaxLines = await this.shippingMethodTaxLineService_.create(lines, sharedContext);
+            addedTaxLines = await this.orderShippingMethodTaxLineService_.create(lines, sharedContext);
         }
         else {
-            addedTaxLines = await this.shippingMethodTaxLineService_.create(taxLines, sharedContext);
+            addedTaxLines = await this.orderShippingMethodTaxLineService_.create(taxLines, sharedContext);
         }
         const serialized = await this.baseRepository_.serialize(addedTaxLines[0], {
             populate: true,
@@ -589,8 +758,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }
         return serialized;
     }
-    async setShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
+    async setOrderShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.tax_lines ?? [])
             .flat()
@@ -605,13 +774,49 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             }
         });
         if (toDelete.length) {
-            await this.shippingMethodTaxLineService_.delete(toDelete, sharedContext);
+            await this.orderShippingMethodTaxLineService_.delete(toDelete, sharedContext);
         }
-        const result = await this.shippingMethodTaxLineService_.upsert(taxLines, sharedContext);
+        const result = await this.orderShippingMethodTaxLineService_.upsert(taxLines, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
+    async createReturns(data, sharedContext) {
+        const created = await this.createOrderRelatedEntity_(data, this.returnService_, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
+            populate: true,
+        });
+    }
+    async createOrderClaims(data, sharedContext) {
+        const created = await this.createOrderRelatedEntity_(data, this.orderClaimService_, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
+            populate: true,
+        });
+    }
+    async createOrderExchanges(data, sharedContext) {
+        const created = await this.createOrderRelatedEntity_(data, this.orderExchangeService_, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
+            populate: true,
+        });
+    }
+    async createOrderRelatedEntity_(data, service, sharedContext) {
+        const data_ = Array.isArray(data) ? data : [data];
+        const inputDataMap = data_.reduce((acc, curr) => {
+            acc[curr.order_id] = curr;
+            return acc;
+        }, {});
+        const orderIds = data_.map((d) => d.order_id);
+        const orders = await this.orderService_.list({ id: orderIds }, { select: ["id", "version"] }, sharedContext);
+        if (orders.length !== orderIds.length) {
+            const foundOrders = orders.map((o) => o.id);
+            const missing = orderIds.filter((id) => !foundOrders.includes(id));
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order could not be found: ${missing.join(", ")}`);
+        }
+        for (const order of orders) {
+            inputDataMap[order.id].order_version = order.version;
+        }
+        return await service.create(data_, sharedContext);
+    }
     async createOrderChange(data, sharedContext) {
         const changes = await this.createOrderChange_(data, sharedContext);
         return await this.baseRepository_.serialize(Array.isArray(data) ? changes : changes[0], {
@@ -622,21 +827,26 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         const dataArr = Array.isArray(data) ? data : [data];
         const orderIds = [];
         const dataMap = {};
+        const orderChanges = await this.listOrderChanges({
+            order_id: dataArr.map((data) => data.order_id),
+            status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
+        }, {}, sharedContext);
+        const orderChangesMap = new Map(orderChanges.map((item) => [item.order_id, item]));
         for (const change of dataArr) {
             orderIds.push(change.order_id);
             dataMap[change.order_id] = change;
         }
-        const orders = await this.list({
-            id: orderIds,
-        }, {
-            select: ["id", "version"],
-        }, sharedContext);
+        const orders = await this.orderService_.list({ id: orderIds }, { select: ["id", "version"] }, sharedContext);
         if (orders.length !== orderIds.length) {
             const foundOrders = orders.map((o) => o.id);
             const missing = orderIds.filter((id) => !foundOrders.includes(id));
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order could not be found: ${missing.join(", ")}`);
         }
         const input = orders.map((order) => {
+            const existingOrderChange = orderChangesMap.get(order.id);
+            if (existingOrderChange) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order (${order.id}) already has an existing active order change`);
+            }
             return {
                 ...dataMap[order.id],
                 version: order.version + 1,
@@ -644,6 +854,83 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         });
         return await this.orderChangeService_.create(input, sharedContext);
     }
+    async previewOrderChange(orderId, sharedContext) {
+        const order = await this.retrieveOrder(orderId, {
+            select: ["id", "version", "items.detail", "summary", "total"],
+            relations: ["transactions", "items", "shipping_methods"],
+        }, sharedContext);
+        if (!order.order_change) {
+            return order;
+        }
+        const orderChange = await super.retrieveOrderChange(order.order_change.id, { relations: ["actions"] }, sharedContext);
+        const { itemsToUpsert, shippingMethodsToUpsert, calculatedOrders } = (0, utils_2.applyChangesToOrder)([order], { [order.id]: orderChange.actions }, { addActionReferenceToObject: true });
+        const calculated = calculatedOrders[order.id];
+        const addedItems = {};
+        const addedShippingMethods = {};
+        for (const item of calculated.order.items) {
+            const isExistingItem = item.id === item.detail?.item_id;
+            if (!isExistingItem) {
+                addedItems[item.id] = item;
+            }
+        }
+        for (const sm of calculated.order.shipping_methods) {
+            if (!(0, utils_1.isDefined)(sm.shipping_option_id)) {
+                addedShippingMethods[sm.id] = sm;
+            }
+        }
+        if (Object.keys(addedItems).length > 0) {
+            const addedItemDetails = await this.listOrderLineItems({ id: Object.keys(addedItems) }, {
+                relations: ["adjustments", "tax_lines"],
+            }, sharedContext);
+            calculated.order.items.forEach((item, idx) => {
+                if (!addedItems[item.id]) {
+                    return;
+                }
+                const lineItem = addedItemDetails.find((d) => d.id === item.id);
+                const actions = item.actions;
+                delete item.actions;
+                const newItem = itemsToUpsert.find((d) => d.item_id === item.id);
+                calculated.order.items[idx] = {
+                    ...lineItem,
+                    actions,
+                    quantity: newItem.quantity,
+                    detail: {
+                        ...newItem,
+                        ...item,
+                    },
+                };
+            });
+        }
+        if (Object.keys(addedShippingMethods).length > 0) {
+            const addedShippingDetails = await this.listOrderShippingMethods({ id: Object.keys(addedShippingMethods) }, {
+                relations: ["adjustments", "tax_lines"],
+            }, sharedContext);
+            calculated.order.shipping_methods.forEach((sm, idx) => {
+                if (!addedShippingMethods[sm.id]) {
+                    return;
+                }
+                const shippingMethod = addedShippingDetails.find((d) => d.id === sm.id);
+                const actions = sm.actions;
+                delete sm.actions;
+                const newItem = shippingMethodsToUpsert.find((d) => d.id === sm.id);
+                sm.shipping_method_id = sm.id;
+                delete sm.id;
+                calculated.order.shipping_methods[idx] = {
+                    ...shippingMethod,
+                    actions,
+                    detail: {
+                        ...sm,
+                        ...newItem,
+                    },
+                };
+            });
+        }
+        const calcOrder = calculated.order;
+        (0, utils_1.decorateCartTotals)(calcOrder);
+        calcOrder.summary = calculated.summary;
+        (0, utils_1.createRawPropertiesFromBigNumber)(calcOrder);
+        return calcOrder;
+    }
     async cancelOrderChange(orderChangeIdOrData, sharedContext) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
@@ -678,16 +965,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         });
         await this.orderChangeService_.update(updates, sharedContext);
         const orderChanges = orderChange.map((change) => {
-            change.actions = change.actions.map((action) => {
-                return {
-                    ...action,
-                    version: change.version,
-                    order_id: change.order_id,
-                };
-            });
             return change.actions;
         });
-        await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
+        return await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
     }
     async declineOrderChange(orderChangeIdOrData, sharedContext) {
         const data = Array.isArray(orderChangeIdOrData)
@@ -708,7 +988,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
     }
     async applyPendingOrderActions(orderId, sharedContext) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.list({ id: orderIds }, {
+        const orders = await this.orderService_.list({ id: orderIds }, {
             select: ["id", "version"],
         }, sharedContext);
         const changes = await this.orderChangeActionService_.list({
@@ -719,6 +999,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             select: [
                 "id",
                 "order_id",
+                "return_id",
+                "exchange_id",
+                "claim_id",
                 "ordering",
                 "version",
                 "applied",
@@ -734,10 +1017,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 ordering: "ASC",
             },
         }, sharedContext);
-        await this.applyOrderChanges_(changes, sharedContext);
+        return await this.applyOrderChanges_(changes, sharedContext);
     }
     async revertLastVersion(orderId, sharedContext) {
-        const order = await super.retrieve(orderId, {
+        const order = await super.retrieveOrder(orderId, {
             select: ["id", "version"],
         }, sharedContext);
         if (order.version < 2) {
@@ -775,13 +1058,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }, { select: ["id", "version"] }, sharedContext);
         const orderItemIds = orderItems.map((summary) => summary.id);
         await this.orderItemService_.softDelete(orderItemIds, sharedContext);
-        // Shipping Methods
-        const orderShippingMethods = await this.orderShippingMethodService_.list({
+        // Order Shipping
+        const orderShippings = await this.orderShippingService_.list({
             order_id: order.id,
             version: currentVersion,
         }, { select: ["id", "version"] }, sharedContext);
-        const orderShippingMethodIds = orderShippingMethods.map((summary) => summary.id);
-        await this.orderShippingMethodService_.softDelete(orderShippingMethodIds, sharedContext);
+        const orderShippingIds = orderShippings.map((sh) => sh.id);
+        await this.orderShippingService_.softDelete(orderShippingIds, sharedContext);
         // Order
         await this.orderService_.update({
             selector: {
@@ -791,10 +1074,58 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 version: order.version - 1,
             },
         }, sharedContext);
+        // Returns
+        await this.returnService_.delete({
+            order_id: order.id,
+            order_version: currentVersion,
+        }, sharedContext);
+    }
+    async getActiveOrderChange_(orderId, includeActions, sharedContext) {
+        const options = {
+            select: [
+                "id",
+                "change_type",
+                "order_id",
+                "return_id",
+                "claim_id",
+                "exchange_id",
+                "version",
+                "requested_at",
+                "requested_by",
+                "status",
+                "description",
+                "internal_note",
+            ],
+            relations: [],
+            order: {},
+        };
+        if (includeActions) {
+            options.select.push("actions");
+            options.relations.push("actions");
+            options.order = {
+                actions: {
+                    ordering: "ASC",
+                },
+            };
+        }
+        const [orderChange] = await this.listOrderChanges({
+            order_id: orderId,
+            status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
+        }, options, sharedContext);
+        return orderChange;
     }
     async getAndValidateOrderChange_(orderChangeIds, includeActions, sharedContext) {
+        orderChangeIds = (0, utils_1.deduplicate)(orderChangeIds);
         const options = {
-            select: ["id", "order_id", "version", "status"],
+            select: [
+                "id",
+                "order_id",
+                "return_id",
+                "claim_id",
+                "exchange_id",
+                "version",
+                "status",
+            ],
             relations: [],
             order: {},
         };
@@ -832,9 +1163,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         const orderChangeMap = {};
         const orderChangeIds = dataArr
             .map((data, idx) => {
-            var _a;
             if (data.order_change_id) {
-                orderChangeMap[_a = data.order_change_id] ?? (orderChangeMap[_a] = []);
+                orderChangeMap[data.order_change_id] ??= [];
                 orderChangeMap[data.order_change_id].push(dataArr[idx]);
             }
             return data.order_change_id;
@@ -855,7 +1185,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return Array.isArray(data) ? actions : actions[0];
     }
     async applyOrderChanges_(changeActions, sharedContext) {
-        var _a;
         const actionsMap = {};
         const ordersIds = [];
         const usedActions = [];
@@ -864,7 +1193,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 continue;
             }
             ordersIds.push(action.order_id);
-            actionsMap[_a = action.order_id] ?? (actionsMap[_a] = []);
+            actionsMap[action.order_id] ??= [];
             actionsMap[action.order_id].push(action);
             usedActions.push({
                 selector: {
@@ -876,74 +1205,29 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             });
         }
         if (!ordersIds.length) {
-            return;
+            return {
+                items: [],
+                shippingMethods: [],
+            };
         }
-        const orders = await this.list({ id: (0, utils_1.deduplicate)(ordersIds) }, {
-            select: [
-                "id",
-                "version",
-                "items.detail",
+        let orders = await this.listOrders({ id: (0, utils_1.deduplicate)(ordersIds) }, {
+            select: ["id", "version", "items.detail", "summary", "total"],
+            relations: [
                 "transactions",
-                "summary",
-                "total",
+                "items",
+                "items.detail",
+                "shipping_methods",
             ],
-            relations: ["transactions", "items", "items.detail"],
-        }, sharedContext);
-        const itemsToUpsert = [];
-        const shippingMethodsToInsert = [];
-        const summariesToUpsert = [];
-        const orderToUpdate = [];
-        for (const order of orders) {
-            const calculated = (0, utils_2.calculateOrderChange)({
-                order: order,
-                actions: actionsMap[order.id],
-                transactions: order.transactions,
-            });
-            (0, utils_1.createRawPropertiesFromBigNumber)(calculated);
-            const version = actionsMap[order.id][0].version;
-            for (const item of calculated.order.items) {
-                const orderItem = item.detail;
-                itemsToUpsert.push({
-                    id: orderItem.version === version ? orderItem.id : undefined,
-                    item_id: item.id,
-                    order_id: order.id,
-                    version,
-                    quantity: item.detail.quantity,
-                    fulfilled_quantity: item.detail.fulfilled_quantity,
-                    shipped_quantity: item.detail.shipped_quantity,
-                    return_requested_quantity: item.detail.return_requested_quantity,
-                    return_received_quantity: item.detail.return_received_quantity,
-                    return_dismissed_quantity: item.detail.return_dismissed_quantity,
-                    written_off_quantity: item.detail.written_off_quantity,
-                    metadata: item.detail.metadata,
-                });
-            }
-            const orderSummary = order.summary;
-            summariesToUpsert.push({
-                id: orderSummary.version === version ? orderSummary.id : undefined,
-                order_id: order.id,
-                version,
-                totals: calculated.summary,
-            });
-            if (version > order.version) {
-                for (const shippingMethod of order.shipping_methods ?? []) {
-                    const sm = {
-                        ...shippingMethod.detail,
-                        version,
-                    };
-                    delete sm.id;
-                    shippingMethodsToInsert.push(sm);
-                }
-                orderToUpdate.push({
-                    selector: {
-                        id: order.id,
-                    },
-                    data: {
-                        version,
-                    },
-                });
-            }
         }
+        // sharedContext
+        // TODO: investigate issue while using sharedContext in receive return action
+        );
+        orders = (0, utils_2.formatOrder)(orders, {
+            entity: _models_1.Order,
+        });
+        const { itemsToUpsert, shippingMethodsToUpsert, summariesToUpsert, orderToUpdate, } = (0, utils_2.applyChangesToOrder)(orders, actionsMap, {
+            addActionReferenceToObject: true,
+        });
         await (0, utils_1.promiseAll)([
             orderToUpdate.length
                 ? this.orderService_.update(orderToUpdate, sharedContext)
@@ -957,391 +1241,847 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             summariesToUpsert.length
                 ? this.orderSummaryService_.upsert(summariesToUpsert, sharedContext)
                 : null,
-            shippingMethodsToInsert.length
-                ? this.orderShippingMethodService_.create(shippingMethodsToInsert, sharedContext)
+            shippingMethodsToUpsert.length
+                ? this.orderShippingService_.upsert(shippingMethodsToUpsert, sharedContext)
                 : null,
         ]);
+        return {
+            items: itemsToUpsert,
+            shippingMethods: shippingMethodsToUpsert,
+        };
     }
-    async registerFulfillment(data, sharedContext) {
-        const items = data.items.map((item) => {
-            return {
-                action: utils_2.ChangeActionType.FULFILL_ITEM,
-                internal_note: item.internal_note,
-                reference: data.reference,
-                reference_id: data.reference_id,
-                details: {
-                    reference_id: item.id,
-                    quantity: item.quantity,
-                    metadata: item.metadata,
-                },
-            };
+    async addOrderTransactions(transactionData, sharedContext) {
+        const orders = await this.orderService_.list({
+            id: Array.isArray(transactionData)
+                ? transactionData.map((t) => t.order_id)
+                : transactionData.order_id,
+        }, {
+            select: ["id", "version"],
+        }, sharedContext);
+        const data = Array.isArray(transactionData)
+            ? transactionData
+            : [transactionData];
+        for (const order of orders) {
+            const trxs = data.filter((t) => t.order_id === order.id);
+            for (const trx of trxs) {
+                ;
+                trx.version = order.version;
+            }
+        }
+        const created = await this.orderTransactionService_.create(data, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(created, false, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(transactionData) ? created[0] : created, {
+            populate: true,
         });
-        const change = await this.createOrderChange_({
-            order_id: data.order_id,
-            description: data.description,
-            internal_note: data.internal_note,
-            created_by: data.created_by,
-            metadata: data.metadata,
-            actions: items,
+    }
+    // @ts-ignore
+    async deleteOrderTransactions(transactionIds, sharedContext) {
+        const data = Array.isArray(transactionIds)
+            ? transactionIds
+            : [transactionIds];
+        const transactions = await super.listOrderTransactions({
+            id: data,
+        }, {
+            select: ["order_id", "version", "amount"],
         }, sharedContext);
-        await this.confirmOrderChange(change[0].id, sharedContext);
+        await this.orderTransactionService_.delete(data, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
     }
-    async registerShipment(data, sharedContext) {
-        let shippingMethodId;
-        if (!(0, utils_1.isString)(data.shipping_method)) {
-            const methods = await this.createShippingMethods(data.order_id, data.shipping_method, sharedContext);
-            shippingMethodId = methods[0].id;
-        }
-        else {
-            shippingMethodId = data.shipping_method;
-        }
-        const method = await this.shippingMethodService_.retrieve(shippingMethodId, {
-            relations: ["tax_lines", "adjustments"],
+    // @ts-ignore
+    async softDeleteOrderTransactions(transactionIds, config, sharedContext) {
+        const transactions = await super.listOrderTransactions({
+            id: transactionIds,
+        }, {
+            select: ["order_id", "amount"],
         }, sharedContext);
-        const calculatedAmount = (0, utils_1.getShippingMethodsTotals)([method], {})[method.id];
-        const actions = data.items.map((item) => {
-            return {
-                action: utils_2.ChangeActionType.SHIP_ITEM,
-                internal_note: item.internal_note,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                details: {
-                    reference_id: item.id,
-                    quantity: item.quantity,
-                    metadata: item.metadata,
-                },
-            };
+        const returned = await super.softDeleteOrderTransactions(transactionIds, config, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
+        return returned;
+    }
+    // @ts-ignore
+    async restoreOrderTransactions(transactionIds, config, sharedContext) {
+        const transactions = await super.listOrderTransactions({
+            id: transactionIds,
+        }, {
+            select: ["order_id", "amount"],
+            withDeleted: true,
+        }, sharedContext);
+        const returned = await super.restoreOrderTransactions(transactionIds, config, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(transactions, false, sharedContext);
+        return returned;
+    }
+    async updateOrderPaidRefundableAmount_(transactionData, isRemoved, sharedContext) {
+        const summaries = await super.listOrderSummaries({
+            order_id: transactionData.map((trx) => trx.order_id),
+        }, {}, sharedContext);
+        summaries.forEach((summary) => {
+            let trxs = transactionData.filter((trx) => trx.order_id === summary.order_id);
+            if (!trxs.length) {
+                return;
+            }
+            (0, utils_1.transformPropertiesToBigNumber)(trxs);
+            const op = isRemoved ? utils_1.MathBN.sub : utils_1.MathBN.add;
+            for (const trx of trxs) {
+                if (utils_1.MathBN.gt(trx.amount, 0)) {
+                    summary.totals.paid_total = new utils_1.BigNumber(op(summary.totals.paid_total, trx.amount));
+                }
+                else {
+                    summary.totals.refunded_total = new utils_1.BigNumber(op(summary.totals.refunded_total, utils_1.MathBN.abs(trx.amount)));
+                }
+                summary.totals.transaction_total = new utils_1.BigNumber(op(summary.totals.transaction_total, trx.amount));
+            }
+            summary.totals.pending_difference = new utils_1.BigNumber(utils_1.MathBN.sub(summary.totals.current_order_total, summary.totals.transaction_total));
         });
-        if (shippingMethodId) {
-            actions.push({
-                action: utils_2.ChangeActionType.SHIPPING_ADD,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                amount: calculatedAmount.total,
-            });
+        (0, utils_1.createRawPropertiesFromBigNumber)(summaries);
+        await this.orderSummaryService_.update(summaries, sharedContext);
+    }
+    async archive(orderId, sharedContext) {
+        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
+        const orders = await this.listOrders({
+            id: orderIds,
+        }, {}, sharedContext);
+        const notAllowed = [];
+        for (const order of orders) {
+            if (![
+                utils_1.OrderStatus.COMPLETED,
+                utils_1.OrderStatus.CANCELED,
+                utils_1.OrderStatus.DRAFT,
+            ].includes(order.status)) {
+                notAllowed.push(order.id);
+            }
+            order.status = utils_1.OrderStatus.ARCHIVED;
         }
-        const change = await this.createOrderChange_({
-            order_id: data.order_id,
-            description: data.description,
-            internal_note: data.internal_note,
-            created_by: data.created_by,
-            metadata: data.metadata,
-            actions,
+        if (notAllowed.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Orders ${notAllowed.join(", ")} are completed, canceled, or in draft and cannot be archived`);
+        }
+        await this.orderService_.update({
+            id: orderIds,
+            status: utils_1.OrderStatus.ARCHIVED,
         }, sharedContext);
-        await this.confirmOrderChange(change[0].id, sharedContext);
+        return Array.isArray(orderId) ? orders : orders[0];
     }
-    async createReturn(data, sharedContext) {
-        let shippingMethodId;
-        if (!(0, utils_1.isString)(data.shipping_method)) {
-            const methods = await this.createShippingMethods(data.order_id, data.shipping_method, sharedContext);
-            shippingMethodId = methods[0].id;
+    async completeOrder(orderId, sharedContext) {
+        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
+        const orders = await this.listOrders({
+            id: orderIds,
+        }, {}, sharedContext);
+        const notAllowed = [];
+        for (const order of orders) {
+            if ([utils_1.OrderStatus.CANCELED].includes(order.status)) {
+                notAllowed.push(order.id);
+            }
+            order.status = utils_1.OrderStatus.COMPLETED;
         }
-        else {
-            shippingMethodId = data.shipping_method;
+        if (notAllowed.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Orders ${notAllowed.join(", ")} are canceled and cannot be completed`);
         }
-        const method = await this.shippingMethodService_.retrieve(shippingMethodId, {
-            relations: ["tax_lines", "adjustments"],
-        }, sharedContext);
-        const calculatedAmount = (0, utils_1.getShippingMethodsTotals)([method], {})[method.id];
-        const actions = data.items.map((item) => {
+        await this.orderService_.update(orderIds.map((id) => {
             return {
-                action: utils_2.ChangeActionType.RETURN_ITEM,
-                internal_note: item.internal_note,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                details: {
-                    reference_id: item.id,
-                    quantity: item.quantity,
-                    metadata: item.metadata,
-                },
+                id,
+                status: utils_1.OrderStatus.COMPLETED,
             };
-        });
-        if (shippingMethodId) {
-            actions.push({
-                action: utils_2.ChangeActionType.SHIPPING_ADD,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                amount: calculatedAmount.total,
-            });
+        }), sharedContext);
+        return Array.isArray(orderId) ? orders : orders[0];
+    }
+    async cancel(orderId, sharedContext) {
+        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
+        const orders = await this.listOrders({
+            id: orderIds,
+        }, {}, sharedContext);
+        const canceled_at = new Date();
+        for (const order of orders) {
+            order.status = utils_1.OrderStatus.CANCELED;
+            order.canceled_at = canceled_at;
         }
-        const change = await this.createOrderChange_({
-            order_id: data.order_id,
-            description: data.description,
-            internal_note: data.internal_note,
-            created_by: data.created_by,
-            metadata: data.metadata,
-            actions,
+        await this.orderService_.update(orderIds.map((id) => {
+            return {
+                id,
+                status: utils_1.OrderStatus.CANCELED,
+                canceled_at,
+            };
+        }), sharedContext);
+        return Array.isArray(orderId) ? orders : orders[0];
+    }
+    // ------------------- Bundled Order Actions
+    async createReturn(data, sharedContext) {
+        const ret = await BundledActions.createReturn.bind(this)(data, sharedContext);
+        return await this.retrieveReturn(ret.id, {
+            relations: [
+                "items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+            ],
         }, sharedContext);
-        await this.confirmOrderChange(change[0].id, sharedContext);
     }
-}
-exports.default = OrderModuleService;
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "create", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "create_", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "update", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "update_", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createLineItems", null);
+    async receiveReturn(data, sharedContext) {
+        const ret = await this.receiveReturn_(data, sharedContext);
+        return await this.retrieveReturn(ret.id, {
+            relations: [
+                "items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+            ],
+        });
+    }
+    async receiveReturn_(data, sharedContext) {
+        return await BundledActions.receiveReturn.bind(this)(data, sharedContext);
+    }
+    async cancelReturn(data, sharedContext) {
+        const ret = await this.cancelReturn_(data, sharedContext);
+        return await this.retrieveReturn(ret.id, {
+            relations: [
+                "items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+            ],
+        });
+    }
+    async cancelReturn_(data, sharedContext) {
+        return await BundledActions.cancelReturn.bind(this)(data, sharedContext);
+    }
+    async createClaim(data, sharedContext) {
+        const ret = await this.createClaim_(data, sharedContext);
+        const claim = await this.retrieveOrderClaim(ret.id, {
+            relations: [
+                "additional_items",
+                "additional_items.item",
+                "claim_items",
+                "claim_items.item",
+                "return",
+                "return.items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+                "transactions",
+            ],
+        }, sharedContext);
+        return await this.baseRepository_.serialize(claim, {
+            populate: true,
+        });
+    }
+    async createClaim_(data, sharedContext) {
+        return await BundledActions.createClaim.bind(this)(data, sharedContext);
+    }
+    async cancelClaim(data, sharedContext) {
+        const ret = await this.cancelClaim_(data, sharedContext);
+        return await this.retrieveOrderClaim(ret.id, {
+            relations: ["additional_items", "claim_items", "return", "return.items"],
+        });
+    }
+    async cancelClaim_(data, sharedContext) {
+        return await BundledActions.cancelClaim.bind(this)(data, sharedContext);
+    }
+    async createExchange(data, sharedContext) {
+        const ret = await this.createExchange_(data, sharedContext);
+        const claim = await this.retrieveOrderExchange(ret.id, {
+            relations: [
+                "additional_items",
+                "additional_items.item",
+                "return",
+                "return.items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+                "transactions",
+            ],
+        }, sharedContext);
+        return await this.baseRepository_.serialize(claim, {
+            populate: true,
+        });
+    }
+    async updateReturnReasons(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            // Check if the return reason exists in the first place
+            await this.returnReasonService_.retrieve(idOrSelector, {}, sharedContext);
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const reasons = await this.returnReasonService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = reasons.map((reason) => ({
+                id: reason.id,
+                ...data,
+            }));
+        }
+        const reasons = await this.returnReasonService_.update(normalizedInput, sharedContext);
+        const updatedReturnReasons = await this.baseRepository_.serialize(reasons);
+        return (0, utils_1.isString)(idOrSelector)
+            ? updatedReturnReasons[0]
+            : updatedReturnReasons;
+    }
+    async createExchange_(data, sharedContext) {
+        return await BundledActions.createExchange.bind(this)(data, sharedContext);
+    }
+    async cancelExchange(data, sharedContext) {
+        const ret = await this.cancelExchange_(data, sharedContext);
+        return await this.retrieveOrderExchange(ret.id, {
+            relations: ["additional_items", "return", "return.items"],
+        });
+    }
+    async cancelExchange_(data, sharedContext) {
+        return await BundledActions.cancelExchange.bind(this)(data, sharedContext);
+    }
+    async registerFulfillment(data, sharedContext) {
+        return await BundledActions.registerFulfillment.bind(this)(data, sharedContext);
+    }
+    async cancelFulfillment(data, sharedContext) {
+        return await BundledActions.cancelFulfillment.bind(this)(data, sharedContext);
+    }
+    async registerShipment(data, sharedContext) {
+        return await BundledActions.registerShipment.bind(this)(data, sharedContext);
+    }
+    async registerDelivery(data, sharedContext) {
+        return await BundledActions.registerDelivery.bind(this)(data, sharedContext);
+    }
+}
+exports.default = OrderModuleService;
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:paramtypes", [String, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createLineItems_", null);
+], OrderModuleService.prototype, "retrieveOrder", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createLineItemsBulk_", null);
+], OrderModuleService.prototype, "listOrders", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateLineItems", null);
+], OrderModuleService.prototype, "listAndCountOrders", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateLineItem_", null);
+], OrderModuleService.prototype, "retrieveReturn", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateLineItemsWithSelector_", null);
+], OrderModuleService.prototype, "listReturns", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateOrderItem", null);
+], OrderModuleService.prototype, "listAndCountReturns", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateOrderItem_", null);
+], OrderModuleService.prototype, "retrieveOrderClaim", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateOrderItemWithSelector_", null);
+], OrderModuleService.prototype, "listOrderClaims", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "listAndCountOrderClaims", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "retrieveOrderExchange", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "listOrderExchanges", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "listAndCountOrderExchanges", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createAddresses", null);
+], OrderModuleService.prototype, "createOrders", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createAddresses_", null);
+], OrderModuleService.prototype, "createOrders_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrders", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrders_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderLineItems", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderLineItems_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderLineItemsBulk_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrderLineItems", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrderLineItem_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrderLineItemsWithSelector_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrderItem", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateAddresses", null);
+], OrderModuleService.prototype, "updateOrderItem_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateAddresses_", null);
+], OrderModuleService.prototype, "updateOrderItemWithSelector_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createShippingMethods", null);
+], OrderModuleService.prototype, "createOrderShippingMethods", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createShippingMethods_", null);
+], OrderModuleService.prototype, "createOrderShippingMethods_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createShippingMethodsBulk_", null);
+], OrderModuleService.prototype, "createOrderShippingMethodsBulk_", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "softDeleteOrderShippingMethods", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "restoreOrderShippingMethods", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createLineItemAdjustments", null);
+], OrderModuleService.prototype, "createOrderLineItemAdjustments", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "setLineItemAdjustments", null);
+], OrderModuleService.prototype, "setOrderLineItemAdjustments", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "setShippingMethodAdjustments", null);
+], OrderModuleService.prototype, "setOrderShippingMethodAdjustments", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createShippingMethodAdjustments", null);
+], OrderModuleService.prototype, "createOrderShippingMethodAdjustments", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createLineItemTaxLines", null);
+], OrderModuleService.prototype, "createOrderLineItemTaxLines", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "setLineItemTaxLines", null);
+], OrderModuleService.prototype, "setOrderLineItemTaxLines", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createShippingMethodTaxLines", null);
+], OrderModuleService.prototype, "createOrderShippingMethodTaxLines", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "setShippingMethodTaxLines", null);
+], OrderModuleService.prototype, "setOrderShippingMethodTaxLines", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createReturns", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderClaims", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderExchanges", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderRelatedEntity_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderChange", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderChange_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "previewOrderChange", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "cancelOrderChange", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "confirmOrderChange", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "declineOrderChange", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "applyPendingOrderActions", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "revertLastVersion", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "revertLastChange_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "addOrderAction", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "applyOrderChanges_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addOrderTransactions", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "deleteOrderTransactions", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "softDeleteOrderTransactions", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "restoreOrderTransactions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrderPaidRefundableAmount_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "archive", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "completeOrder", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancel", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createReturn", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "receiveReturn", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "receiveReturn_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelReturn", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelReturn_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createClaim", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createClaim_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelClaim", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelClaim_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createExchange", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateReturnReasons", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createExchange_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelExchange", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelExchange_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "registerFulfillment", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelFulfillment", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "registerShipment", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createReturn", null);
+], OrderModuleService.prototype, "registerDelivery", null);
 //# sourceMappingURL=order-module-service.js.map