@medusajs/order 2.11.0-snapshot-20250829134337 → 2.11.0-snapshot-20251016104801

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

@@ -35,9 +35,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@medusajs/framework/mikro-orm/core");
 const types_1 = require("@medusajs/framework/types");
 const utils_1 = require("@medusajs/framework/utils");
-const core_1 = require("@mikro-orm/core");
 const _models_1 = require("../models");
 const joiner_config_1 = require("../joiner-config");
 const utils_2 = require("../utils");
@@ -70,11 +70,15 @@ const generateMethodForModels = {
 {
     const MikroORMEntity = (0, utils_1.toMikroORMEntity)(_models_1.OrderChangeAction);
     MikroORMEntity.prototype["onInit_OrderChangeAction"] = function () {
-        this.version ??= this.order_change?.version ?? null;
-        this.order_id ??= this.order_change?.order_id ?? null;
-        this.claim_id ??= this.order_change?.claim_id ?? null;
-        this.exchange_id ??= this.order_change?.exchange_id ?? null;
-        if (!this.claim_id && !this.exchange_id) {
+        if (this.order_change) {
+            this.version ??= this.order_change.version ?? null;
+            this.order_id ??= this.order_change.order_id ?? null;
+            this.claim_id ??= this.order_change.claim_id ?? null;
+            this.exchange_id ??= this.order_change.exchange_id ?? null;
+        }
+        if (!this.claim_id &&
+            !this.exchange_id &&
+            (this.return || this.order_change)) {
             this.return_id = this.return?.id ?? this.order_change?.return_id ?? null;
         }
     };
@@ -84,12 +88,9 @@ const generateMethodForModels = {
 {
     const MikroORMEntity = (0, utils_1.toMikroORMEntity)(_models_1.OrderShipping);
     MikroORMEntity.prototype["onInit_OrderShipping"] = function () {
-        this.version ??= this.order?.version ?? null;
-        this.order ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.Order), this.order?.id ?? null);
-        this.return ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.Return), this.return?.id ?? null);
-        this.claim ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.OrderClaim), this.claim?.id ?? null);
-        this.exchange ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.OrderExchange), this.exchange?.id ?? null);
-        this.shipping_method ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.OrderShippingMethod), this.shipping_method?.id ?? null);
+        if (this.order) {
+            this.version ??= this.order.version ?? null;
+        }
     };
     (0, core_1.OnInit)()(MikroORMEntity.prototype, "onInit_OrderShipping");
     (0, core_1.BeforeCreate)()(MikroORMEntity.prototype, "onInit_OrderShipping");
@@ -97,9 +98,9 @@ const generateMethodForModels = {
 {
     const MikroORMEntity = (0, utils_1.toMikroORMEntity)(_models_1.OrderItem);
     MikroORMEntity.prototype["onInit_OrderItem"] = function () {
-        this.version ??= this.order?.version ?? null;
-        this.order ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.Order), this.order?.id ?? null);
-        this.item ??= (0, core_1.rel)((0, utils_1.toMikroORMEntity)(_models_1.OrderLineItem), this.item?.id ?? null);
+        if (this.order) {
+            this.version ??= this.order.version ?? null;
+        }
     };
     (0, core_1.OnInit)()(MikroORMEntity.prototype, "onInit_OrderItem");
     (0, core_1.BeforeCreate)()(MikroORMEntity.prototype, "onInit_OrderItem");
@@ -145,6 +146,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             "discount_tax_total",
             "original_total",
             "original_tax_total",
+            "pending_difference",
             "item_total",
             "item_subtotal",
             "item_tax_total",
@@ -157,9 +159,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             "original_shipping_tax_total",
             "original_shipping_subtotal",
             "original_shipping_total",
+            "original_total",
+            "original_subtotal",
+            "original_tax_total",
             "credit_line_total",
             "credit_line_tax_total",
             "credit_line_subtotal",
+            "refundable_amount",
         ];
         const includeTotals = (config?.select ?? []).some((field) => totalFields.includes(field));
         if (includeTotals) {
@@ -201,6 +207,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     }
     // @ts-expect-error
     async listOrders(filters, config, sharedContext) {
+        const orders = await this.listOrders_(filters, config, sharedContext);
+        return this.baseRepository_.serialize(orders);
+    }
+    async listOrders_(filters, config, sharedContext) {
         config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
         const orders = await super.listOrders(filters, config, sharedContext);
@@ -457,9 +467,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     // @ts-expect-error
     async updateOrders(dataOrIdOrSelector, data, sharedContext = {}) {
         const result = await this.updateOrders_(dataOrIdOrSelector, data, sharedContext);
-        const serializedResult = await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        const serializedResult = await this.baseRepository_.serialize(result);
         return (0, utils_1.isString)(dataOrIdOrSelector) ? serializedResult[0] : serializedResult;
     }
     async updateOrders_(dataOrIdOrSelector, data, sharedContext = {}) {
@@ -498,7 +506,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.listOrders({ 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;
@@ -511,9 +519,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             });
             items = await this.createOrderLineItemsBulk_(lineItems, sharedContext);
         }
-        return await this.baseRepository_.serialize(items, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(items);
     }
     async createOrderLineItems_(orderId, items, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
@@ -551,9 +557,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         let items = [];
         if ((0, utils_1.isString)(lineItemIdOrDataOrSelector)) {
             const item = await this.updateOrderLineItem_(lineItemIdOrDataOrSelector, data, sharedContext);
-            return await this.baseRepository_.serialize(item, {
-                populate: true,
-            });
+            return await this.baseRepository_.serialize(item);
         }
         const toUpdate = Array.isArray(lineItemIdOrDataOrSelector)
             ? lineItemIdOrDataOrSelector
@@ -564,9 +568,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 },
             ];
         items = await this.updateOrderLineItemsWithSelector_(toUpdate, sharedContext);
-        return await this.baseRepository_.serialize(items, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(items);
     }
     async updateOrderLineItem_(lineItemId, data, sharedContext = {}) {
         const [item] = await this.orderLineItemService_.update([{ id: lineItemId, ...data }], sharedContext);
@@ -584,7 +586,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         let toUpdate = [];
         const detailsToUpdate = [];
         for (const { selector, data } of updates) {
-            const items = await this.listOrderLineItems({ ...selector }, {}, sharedContext);
+            const items = await this.orderLineItemService_.list({ ...selector }, {}, sharedContext);
             items.forEach((item) => {
                 toUpdate.push({
                     ...data,
@@ -607,9 +609,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         let items = [];
         if ((0, utils_1.isString)(orderItemIdOrDataOrSelector)) {
             const item = await this.updateOrderItem_(orderItemIdOrDataOrSelector, data, sharedContext);
-            return await this.baseRepository_.serialize(item, {
-                populate: true,
-            });
+            return await this.baseRepository_.serialize(item);
         }
         const toUpdate = Array.isArray(orderItemIdOrDataOrSelector)
             ? orderItemIdOrDataOrSelector
@@ -620,9 +620,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 },
             ];
         items = await this.updateOrderItemWithSelector_(toUpdate, sharedContext);
-        return await this.baseRepository_.serialize(items, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(items);
     }
     async updateOrderItem_(orderItemId, data, sharedContext = {}) {
         const [detail] = await this.orderItemService_.update([{ id: orderItemId, ...data }], sharedContext);
@@ -631,7 +629,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     async updateOrderItemWithSelector_(updates, sharedContext = {}) {
         let toUpdate = [];
         for (const { selector, data } of updates) {
-            const details = await this.listOrderItems({ ...selector }, {}, sharedContext);
+            const details = await this.orderItemService_.list({ ...selector }, {}, sharedContext);
             details.forEach((detail) => {
                 toUpdate.push({
                     ...data,
@@ -652,7 +650,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.listOrders({ 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;
@@ -669,7 +667,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             });
             methods = await this.createOrderShippingMethodsBulk_(orderShippingMethodData, sharedContext);
         }
-        return await this.baseRepository_.serialize(methods, { populate: true });
+        return await this.baseRepository_.serialize(methods);
     }
     async createOrderShippingMethods_(orderId, data, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
@@ -690,7 +688,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return sm.map((s) => s.shipping_method);
     }
     // @ts-ignore
-    async softDeleteOrderShippingMethods(ids, config, sharedContext) {
+    async softDeleteOrderShippingMethods(ids, config, sharedContext = {}) {
+        return await this.softDeleteOrderShippingMethods_(ids, config, sharedContext);
+    }
+    async softDeleteOrderShippingMethods_(ids, config, sharedContext = {}) {
         const rel = await super.listOrderShippings({
             shipping_method_id: ids,
         }, {
@@ -704,7 +705,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return returned;
     }
     // @ts-ignore
-    async restoreOrderShippingMethods(ids, config, sharedContext) {
+    async restoreOrderShippingMethods(ids, config, sharedContext = {}) {
+        return await this.restoreOrderShippingMethods_(ids, config, sharedContext);
+    }
+    async restoreOrderShippingMethods_(ids, config, sharedContext = {}) {
         const rel = await super.listOrderShippings({
             shipping_method_id: ids,
         }, {
@@ -719,6 +723,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     }
     // @ts-expect-error
     async createOrderLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+        const addedAdjustments = await this.createOrderLineItemAdjustments_(orderIdOrData, adjustments, sharedContext);
+        return await this.baseRepository_.serialize(addedAdjustments);
+    }
+    async createOrderLineItemAdjustments_(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
             const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
@@ -736,17 +744,20 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 : [orderIdOrData];
             addedAdjustments = await this.orderLineItemAdjustmentService_.create(data, sharedContext);
         }
-        return await this.baseRepository_.serialize(addedAdjustments, {
-            populate: true,
-        });
+        return addedAdjustments;
     }
     async upsertOrderLineItemAdjustments(adjustments, sharedContext = {}) {
-        let result = await this.orderLineItemAdjustmentService_.upsert(adjustments, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        let result = await this.upsertOrderLineItemAdjustments_(adjustments, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    async upsertOrderLineItemAdjustments_(adjustments, sharedContext = {}) {
+        return await this.orderLineItemAdjustmentService_.upsert(adjustments, sharedContext);
     }
     async setOrderLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
+        const result = await this.setOrderLineItemAdjustments_(orderId, adjustments, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    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 ?? [])
@@ -765,18 +776,21 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         if (toDelete.length) {
             await this.orderLineItemAdjustmentService_.delete(toDelete, sharedContext);
         }
-        let result = await this.orderLineItemAdjustmentService_.upsert(adjustments, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        const result = await this.orderLineItemAdjustmentService_.upsert(adjustments, sharedContext);
+        return result;
     }
     async upsertOrderShippingMethodAdjustments(adjustments, sharedContext = {}) {
-        const result = await this.orderShippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        const result = await this.upsertOrderShippingMethodAdjustments_(adjustments, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    async upsertOrderShippingMethodAdjustments_(adjustments, sharedContext = {}) {
+        return await this.orderShippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
     }
     async setOrderShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
+        const result = await this.setOrderShippingMethodAdjustments_(orderId, adjustments, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    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 ?? [])
@@ -796,12 +810,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             await this.orderShippingMethodAdjustmentService_.delete(toDelete, sharedContext);
         }
         const result = await this.orderShippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        return result;
     }
     // @ts-expect-error
     async createOrderShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+        const addedAdjustments = await this.createOrderShippingMethodAdjustments_(orderIdOrData, adjustments, sharedContext);
+        return await this.baseRepository_.serialize(addedAdjustments);
+    }
+    async createOrderShippingMethodAdjustments_(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
             const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
@@ -822,16 +838,20 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 await this.orderShippingMethodAdjustmentService_.create(data, sharedContext);
         }
         if ((0, utils_1.isObject)(orderIdOrData)) {
-            return await this.baseRepository_.serialize(addedAdjustments[0], {
-                populate: true,
-            });
+            return addedAdjustments[0];
         }
-        return await this.baseRepository_.serialize(addedAdjustments, {
-            populate: true,
-        });
+        return addedAdjustments;
     }
     // @ts-expect-error
     async createOrderLineItemTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+        const addedTaxLines = await this.createOrderLineItemTaxLines_(orderIdOrData, taxLines, sharedContext);
+        const serialized = await this.baseRepository_.serialize(addedTaxLines);
+        if ((0, utils_1.isObject)(orderIdOrData)) {
+            return serialized[0];
+        }
+        return serialized;
+    }
+    async createOrderLineItemTaxLines_(orderIdOrData, taxLines, sharedContext = {}) {
         let addedTaxLines;
         if ((0, utils_1.isString)(orderIdOrData)) {
             const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
@@ -843,21 +863,24 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 : [orderIdOrData];
             addedTaxLines = await this.orderLineItemTaxLineService_.create(data, sharedContext);
         }
-        const serialized = await this.baseRepository_.serialize(addedTaxLines, {
-            populate: true,
-        });
         if ((0, utils_1.isObject)(orderIdOrData)) {
-            return serialized[0];
+            return addedTaxLines[0];
         }
-        return serialized;
+        return addedTaxLines;
     }
     async upsertOrderLineItemTaxLines(taxLines, sharedContext = {}) {
+        const result = await this.upsertOrderLineItemTaxLines_(taxLines, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    async upsertOrderLineItemTaxLines_(taxLines, sharedContext = {}) {
         const result = await this.orderLineItemTaxLineService_.upsert(taxLines, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        return result;
     }
     async setOrderLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
+        const result = await this.setOrderLineItemTaxLines_(orderId, taxLines, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    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 ?? [])
@@ -876,12 +899,18 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             await this.orderLineItemTaxLineService_.delete(toDelete, sharedContext);
         }
         const result = await this.orderLineItemTaxLineService_.upsert(taxLines, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        return result;
     }
     // @ts-expect-error
     async createOrderShippingMethodTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+        const addedTaxLines = await this.createOrderShippingMethodTaxLines_(orderIdOrData, taxLines, sharedContext);
+        const serialized = await this.baseRepository_.serialize(addedTaxLines);
+        if ((0, utils_1.isObject)(orderIdOrData)) {
+            return serialized[0];
+        }
+        return serialized;
+    }
+    async createOrderShippingMethodTaxLines_(orderIdOrData, taxLines, sharedContext = {}) {
         let addedTaxLines;
         if ((0, utils_1.isString)(orderIdOrData)) {
             const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
@@ -890,21 +919,17 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         else {
             addedTaxLines = await this.orderShippingMethodTaxLineService_.create(taxLines, sharedContext);
         }
-        const serialized = await this.baseRepository_.serialize(addedTaxLines[0], {
-            populate: true,
-        });
-        if ((0, utils_1.isObject)(orderIdOrData)) {
-            return serialized[0];
-        }
-        return serialized;
+        return addedTaxLines;
     }
     async upsertOrderShippingMethodTaxLines(taxLines, sharedContext = {}) {
         const result = await this.orderShippingMethodTaxLineService_.upsert(taxLines, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(result);
     }
     async setOrderShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
+        const result = await this.setOrderShippingMethodTaxLines_(orderId, taxLines, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    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 ?? [])
@@ -923,32 +948,24 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             await this.orderShippingMethodTaxLineService_.delete(toDelete, sharedContext);
         }
         const result = await this.orderShippingMethodTaxLineService_.upsert(taxLines, sharedContext);
-        return await this.baseRepository_.serialize(result, {
-            populate: true,
-        });
+        return result;
     }
     // @ts-expect-error
-    async createReturns(data, sharedContext) {
+    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,
-        });
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created);
     }
     // @ts-expect-error
-    async createOrderClaims(data, sharedContext) {
+    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,
-        });
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created);
     }
     // @ts-expect-error
-    async createOrderExchanges(data, sharedContext) {
+    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,
-        });
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created);
     }
-    async createOrderRelatedEntity_(data, service, sharedContext) {
+    async createOrderRelatedEntity_(data, service, sharedContext = {}) {
         const data_ = Array.isArray(data) ? data : [data];
         const inputDataMap = data_.reduce((acc, curr) => {
             acc[curr.order_id] = curr;
@@ -966,17 +983,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return await service.create(data_, sharedContext);
     }
-    async createOrderChange(data, sharedContext) {
+    async createOrderChange(data, sharedContext = {}) {
         const changes = await this.createOrderChange_(data, sharedContext);
-        return await this.baseRepository_.serialize(Array.isArray(data) ? changes : changes[0], {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(Array.isArray(data) ? changes : changes[0]);
     }
-    async createOrderChange_(data, sharedContext) {
+    async createOrderChange_(data, sharedContext = {}) {
         const dataArr = Array.isArray(data) ? data : [data];
         const orderIds = [];
         const dataMap = {};
-        const orderChanges = await this.listOrderChanges({
+        const orderChanges = await this.orderChangeService_.list({
             order_id: dataArr.map((data) => data.order_id),
             status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
         }, {}, sharedContext);
@@ -1003,7 +1018,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
         return await this.orderChangeService_.create(input, sharedContext);
     }
-    async previewOrderChange(orderId, sharedContext) {
+    async previewOrderChange(orderId, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, {
             select: ["id", "version", "items.detail", "summary", "total"],
             relations: ["transactions", "credit_lines"],
@@ -1021,7 +1036,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         (0, utils_1.createRawPropertiesFromBigNumber)(calcOrder);
         return calcOrder;
     }
-    async includeTaxLinesAndAdjustementsToPreview(order, itemsToUpsert, shippingMethodsToUpsert, sharedContext) {
+    async includeTaxLinesAndAdjustementsToPreview(order, itemsToUpsert, shippingMethodsToUpsert, sharedContext = {}) {
         const addedItems = {};
         const addedShippingMethods = {};
         for (const item of order.items) {
@@ -1097,7 +1112,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             });
         }
     }
-    async cancelOrderChange(orderChangeIdOrData, sharedContext) {
+    async cancelOrderChange(orderChangeIdOrData, sharedContext = {}) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
             : [orderChangeIdOrData];
@@ -1114,7 +1129,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
         await this.orderChangeService_.update(updates, sharedContext);
     }
-    async confirmOrderChange(orderChangeIdOrData, sharedContext) {
+    async confirmOrderChange(orderChangeIdOrData, sharedContext = {}) {
+        const result = await this.confirmOrderChange_(orderChangeIdOrData, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    async confirmOrderChange_(orderChangeIdOrData, sharedContext = {}) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
             : [orderChangeIdOrData];
@@ -1135,7 +1154,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
         return await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
     }
-    async declineOrderChange(orderChangeIdOrData, sharedContext) {
+    async declineOrderChange(orderChangeIdOrData, sharedContext = {}) {
+        await this.declineOrderChange_(orderChangeIdOrData, sharedContext);
+    }
+    async declineOrderChange_(orderChangeIdOrData, sharedContext = {}) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
             : [orderChangeIdOrData];
@@ -1152,11 +1174,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
         await this.orderChangeService_.update(updates, sharedContext);
     }
-    async registerOrderChange(data, sharedContext) {
+    async registerOrderChange(data, sharedContext = {}) {
+        const result = await this.registerOrderChange_(data, sharedContext);
+        return await this.baseRepository_.serialize(result);
+    }
+    async registerOrderChange_(data, sharedContext = {}) {
         const inputData = Array.isArray(data) ? data : [data];
         const orders = await this.orderService_.list({ id: inputData.map((d) => d.order_id) }, { select: ["id", "version"] }, sharedContext);
         const orderVersionsMap = new Map(orders.map((o) => [o.id, o.version]));
-        const changes = (await this.orderChangeService_.create(inputData.map((d) => ({
+        const changes = await this.orderChangeService_.create(inputData.map((d) => ({
             order_id: d.order_id,
             change_type: d.change_type,
             internal_note: d.internal_note,
@@ -1175,10 +1201,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     applied: true,
                 },
             ],
-        })), sharedContext));
-        return Array.isArray(data) ? changes : changes[0];
+        })), sharedContext);
+        return changes;
+    }
+    async applyPendingOrderActions(orderId, sharedContext = {}) {
+        const result = await this.applyPendingOrderActions_(orderId, sharedContext);
+        return await this.baseRepository_.serialize(result);
     }
-    async applyPendingOrderActions(orderId, sharedContext) {
+    async applyPendingOrderActions_(orderId, sharedContext = {}) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
         const orders = await this.orderService_.list({ id: orderIds }, {
             select: ["id", "version"],
@@ -1211,7 +1241,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }, sharedContext);
         return await this.applyOrderChanges_(changes, sharedContext);
     }
-    async revertLastVersion(orderId, sharedContext) {
+    async revertLastVersion(orderId, sharedContext = {}) {
         const order = await super.retrieveOrder(orderId, {
             select: ["id", "version"],
         }, sharedContext);
@@ -1220,7 +1250,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return await this.revertLastChange_(order, sharedContext);
     }
-    async undoLastChange(orderId, lastOrderChange, sharedContext) {
+    async undoLastChange(orderId, lastOrderChange, sharedContext = {}) {
         const order = await super.retrieveOrder(orderId, {
             select: ["id", "version"],
         }, sharedContext);
@@ -1229,7 +1259,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return await this.undoLastChange_(order, lastOrderChange, sharedContext);
     }
-    async undoLastChange_(order, lastOrderChange, sharedContext) {
+    async undoLastChange_(order, lastOrderChange, sharedContext = {}) {
         const currentVersion = order.version;
         const updatePromises = [];
         // Order Changes
@@ -1289,7 +1319,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }, sharedContext));
         await (0, utils_1.promiseAll)(updatePromises);
     }
-    async revertLastChange_(order, sharedContext) {
+    async revertLastChange_(order, sharedContext = {}) {
         const currentVersion = order.version;
         const updatePromises = [];
         // Order Changes
@@ -1421,7 +1451,12 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return orderChanges;
     }
-    async addOrderAction(data, sharedContext) {
+    async addOrderAction(data, sharedContext = {}) {
+        const actions = await this.addOrderAction_(data, sharedContext);
+        const serializedActions = await this.baseRepository_.serialize(actions);
+        return Array.isArray(data) ? serializedActions : serializedActions[0];
+    }
+    async addOrderAction_(data, sharedContext = {}) {
         let dataArr = Array.isArray(data) ? data : [data];
         const orderChangeMap = {};
         const orderChangeIds = dataArr
@@ -1444,10 +1479,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 });
             }
         }
-        const actions = (await this.orderChangeActionService_.create(dataArr, sharedContext));
-        return Array.isArray(data) ? actions : actions[0];
+        const actions = await this.orderChangeActionService_.create(dataArr, sharedContext);
+        return actions;
     }
-    async applyOrderChanges_(changeActions, sharedContext) {
+    async applyOrderChanges_(changeActions, sharedContext = {}) {
         const actionsMap = {};
         const ordersIds = [];
         const usedActions = [];
@@ -1474,7 +1509,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 credit_lines: [],
             };
         }
-        let orders = await this.listOrders({ id: (0, utils_1.deduplicate)(ordersIds) }, {
+        let orders = await this.listOrders_({ id: (0, utils_1.deduplicate)(ordersIds) }, {
             select: ["id", "version", "items.detail", "summary", "total"],
             relations: ["transactions", "credit_lines"],
         }, sharedContext);
@@ -1511,7 +1546,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             credit_lines: createdOrderCreditLines ?? [],
         };
     }
-    async addOrderTransactions(transactionData, sharedContext) {
+    async addOrderTransactions(transactionData, sharedContext = {}) {
+        const created = await this.addOrderTransactions_(transactionData, sharedContext);
+        const serializedTransactions = await this.baseRepository_.serialize(created);
+        return Array.isArray(transactionData)
+            ? serializedTransactions
+            : serializedTransactions[0];
+    }
+    async addOrderTransactions_(transactionData, sharedContext = {}) {
         const orders = await this.orderService_.list({
             id: Array.isArray(transactionData)
                 ? transactionData.map((t) => t.order_id)
@@ -1531,12 +1573,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         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,
-        });
+        return created;
     }
     // @ts-ignore
-    async deleteOrderTransactions(transactionIds, sharedContext) {
+    async deleteOrderTransactions(transactionIds, sharedContext = {}) {
         const data = Array.isArray(transactionIds)
             ? transactionIds
             : [transactionIds];
@@ -1549,7 +1589,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
     }
     // @ts-ignore
-    async softDeleteOrderTransactions(transactionIds, config, sharedContext) {
+    async softDeleteOrderTransactions(transactionIds, config, sharedContext = {}) {
+        const returned = await this.softDeleteOrderTransactions_(transactionIds, config, sharedContext);
+        return returned;
+    }
+    async softDeleteOrderTransactions_(transactionIds, config, sharedContext = {}) {
         const transactions = await super.listOrderTransactions({
             id: transactionIds,
         }, {
@@ -1560,7 +1604,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return returned;
     }
     // @ts-ignore
-    async restoreOrderTransactions(transactionIds, config, sharedContext) {
+    async restoreOrderTransactions(transactionIds, config, sharedContext = {}) {
+        const returned = await this.restoreOrderTransactions_(transactionIds, config, sharedContext);
+        return returned;
+    }
+    async restoreOrderTransactions_(transactionIds, config, sharedContext = {}) {
         const transactions = await super.listOrderTransactions({
             id: transactionIds,
         }, {
@@ -1571,8 +1619,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         await this.updateOrderPaidRefundableAmount_(transactions, false, sharedContext);
         return returned;
     }
-    async updateOrderPaidRefundableAmount_(transactionData, isRemoved, sharedContext) {
-        const summaries = await super.listOrderSummaries({
+    async updateOrderPaidRefundableAmount_(transactionData, isRemoved, sharedContext = {}) {
+        const summaries = await this.listOrderSummaries({
             order_id: transactionData.map((trx) => trx.order_id),
             version: transactionData[0].version,
         }, {}, sharedContext);
@@ -1599,9 +1647,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         (0, utils_1.createRawPropertiesFromBigNumber)(summaries);
         await this.orderSummaryService_.update(summaries, sharedContext);
     }
-    async archive(orderId, sharedContext) {
+    async archive(orderId, sharedContext = {}) {
+        const orders = await this.archive_(orderId, sharedContext);
+        return await this.baseRepository_.serialize(Array.isArray(orderId) ? orders : orders[0]);
+    }
+    async archive_(orderId, sharedContext = {}) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.listOrders({
+        const orders = await this.listOrders_({
             id: orderIds,
         }, {}, sharedContext);
         const notAllowed = [];
@@ -1624,11 +1676,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 status: utils_1.OrderStatus.ARCHIVED,
             };
         }), sharedContext);
-        return Array.isArray(orderId) ? orders : orders[0];
+        return orders;
     }
-    async completeOrder(orderId, sharedContext) {
+    async completeOrder(orderId, sharedContext = {}) {
+        const orders = await this.completeOrder_(orderId, sharedContext);
+        return await this.baseRepository_.serialize(Array.isArray(orderId) ? orders : orders[0]);
+    }
+    async completeOrder_(orderId, sharedContext = {}) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.listOrders({
+        const orders = await this.listOrders_({
             id: orderIds,
         }, {}, sharedContext);
         const notAllowed = [];
@@ -1647,11 +1703,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 status: utils_1.OrderStatus.COMPLETED,
             };
         }), sharedContext);
-        return Array.isArray(orderId) ? orders : orders[0];
+        return orders;
+    }
+    async cancel(orderId, sharedContext = {}) {
+        const orders = await this.cancel_(orderId, sharedContext);
+        return await this.baseRepository_.serialize(Array.isArray(orderId) ? orders : orders[0]);
     }
-    async cancel(orderId, sharedContext) {
+    async cancel_(orderId, sharedContext = {}) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.listOrders({
+        const orders = await this.listOrders_({
             id: orderIds,
         }, {}, sharedContext);
         const canceled_at = new Date();
@@ -1666,10 +1726,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 canceled_at,
             };
         }), sharedContext);
-        return Array.isArray(orderId) ? orders : orders[0];
+        return orders;
     }
     // ------------------- Bundled Order Actions
-    async createReturn(data, sharedContext) {
+    async createReturn(data, sharedContext = {}) {
+        const ret = await this.createReturn_(data, sharedContext);
+        return await this.baseRepository_.serialize(ret);
+    }
+    async createReturn_(data, sharedContext = {}) {
         const ret = await BundledActions.createReturn.bind(this)(data, sharedContext);
         return await this.retrieveReturn(ret.id, {
             relations: [
@@ -1680,9 +1744,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             ],
         }, sharedContext);
     }
-    async receiveReturn(data, sharedContext) {
+    async receiveReturn(data, sharedContext = {}) {
         const ret = await this.receiveReturn_(data, sharedContext);
-        return await this.retrieveReturn(ret[0].id, {
+        const returned = await this.retrieveReturn(ret[0].id, {
             relations: [
                 "items",
                 "items.item",
@@ -1691,13 +1755,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 "shipping_methods.adjustments",
             ],
         });
+        return await this.baseRepository_.serialize(returned);
     }
-    async receiveReturn_(data, sharedContext) {
+    async receiveReturn_(data, sharedContext = {}) {
         return await BundledActions.receiveReturn.bind(this)(data, sharedContext);
     }
-    async cancelReturn(data, sharedContext) {
+    async cancelReturn(data, sharedContext = {}) {
         const ret = await this.cancelReturn_(data, sharedContext);
-        return await this.retrieveReturn(ret.id, {
+        const returned = await this.retrieveReturn(ret.id, {
             relations: [
                 "items",
                 "shipping_methods",
@@ -1705,11 +1770,12 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 "shipping_methods.adjustments",
             ],
         });
+        return await this.baseRepository_.serialize(returned);
     }
-    async cancelReturn_(data, sharedContext) {
+    async cancelReturn_(data, sharedContext = {}) {
         return await BundledActions.cancelReturn.bind(this)(data, sharedContext);
     }
-    async createClaim(data, sharedContext) {
+    async createClaim(data, sharedContext = {}) {
         const ret = await this.createClaim_(data, sharedContext);
         const claim = await this.retrieveOrderClaim(ret.id, {
             relations: [
@@ -1725,23 +1791,22 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 "transactions",
             ],
         }, sharedContext);
-        return await this.baseRepository_.serialize(claim, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(claim);
     }
-    async createClaim_(data, sharedContext) {
+    async createClaim_(data, sharedContext = {}) {
         return await BundledActions.createClaim.bind(this)(data, sharedContext);
     }
-    async cancelClaim(data, sharedContext) {
+    async cancelClaim(data, sharedContext = {}) {
         const ret = await this.cancelClaim_(data, sharedContext);
-        return await this.retrieveOrderClaim(ret.id, {
+        const claim = await this.retrieveOrderClaim(ret.id, {
             relations: ["additional_items", "claim_items", "return", "return.items"],
         });
+        return await this.baseRepository_.serialize(claim);
     }
-    async cancelClaim_(data, sharedContext) {
+    async cancelClaim_(data, sharedContext = {}) {
         return await BundledActions.cancelClaim.bind(this)(data, sharedContext);
     }
-    async createExchange(data, sharedContext) {
+    async createExchange(data, sharedContext = {}) {
         const ret = await this.createExchange_(data, sharedContext);
         const exchange = await this.retrieveOrderExchange(ret.id, {
             relations: [
@@ -1755,12 +1820,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 "transactions",
             ],
         }, sharedContext);
-        return await this.baseRepository_.serialize(exchange, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(exchange);
     }
     // @ts-expect-error
     async updateReturnReasons(idOrSelector, data, sharedContext = {}) {
+        const reasons = await this.updateReturnReasons_(idOrSelector, data, sharedContext);
+        return await this.baseRepository_.serialize((0, utils_1.isString)(idOrSelector) ? reasons[0] : reasons);
+    }
+    async updateReturnReasons_(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             // Check if the return reason exists in the first place
@@ -1775,34 +1842,32 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }));
         }
         const reasons = await this.returnReasonService_.update(normalizedInput, sharedContext);
-        const updatedReturnReasons = await this.baseRepository_.serialize(reasons);
-        return (0, utils_1.isString)(idOrSelector)
-            ? updatedReturnReasons[0]
-            : updatedReturnReasons;
+        return reasons;
     }
-    async createExchange_(data, sharedContext) {
+    async createExchange_(data, sharedContext = {}) {
         return await BundledActions.createExchange.bind(this)(data, sharedContext);
     }
-    async cancelExchange(data, sharedContext) {
+    async cancelExchange(data, sharedContext = {}) {
         const ret = await this.cancelExchange_(data, sharedContext);
-        return await this.retrieveOrderExchange(ret.id, {
+        const exchange = await this.retrieveOrderExchange(ret.id, {
             relations: ["additional_items", "return", "return.items"],
         });
+        return await this.baseRepository_.serialize(exchange);
     }
-    async cancelExchange_(data, sharedContext) {
+    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 registerFulfillment(data, sharedContext = {}) {
+        await BundledActions.registerFulfillment.bind(this)(data, sharedContext);
     }
-    async cancelFulfillment(data, sharedContext) {
-        return await BundledActions.cancelFulfillment.bind(this)(data, sharedContext);
+    async cancelFulfillment(data, sharedContext = {}) {
+        await BundledActions.cancelFulfillment.bind(this)(data, sharedContext);
     }
-    async registerShipment(data, sharedContext) {
-        return await BundledActions.registerShipment.bind(this)(data, sharedContext);
+    async registerShipment(data, sharedContext = {}) {
+        await BundledActions.registerShipment.bind(this)(data, sharedContext);
     }
-    async registerDelivery(data, sharedContext) {
-        return await BundledActions.registerDelivery.bind(this)(data, sharedContext);
+    async registerDelivery(data, sharedContext = {}) {
+        await BundledActions.registerDelivery.bind(this)(data, sharedContext);
     }
     // @ts-expect-error
     async createReturnItems(data, sharedContext) {
@@ -1810,80 +1875,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     }
 }
 exports.default = OrderModuleService;
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveOrder", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listOrders", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listAndCountOrders", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveReturn", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listReturns", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listAndCountReturns", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveOrderClaim", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], 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);
+], OrderModuleService.prototype, "listOrders_", 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)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1906,7 +1906,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderAddresses_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1915,7 +1916,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "deleteOrders", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1931,7 +1933,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "updateOrders_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1954,7 +1957,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderLineItemsBulk_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1978,6 +1982,7 @@ __decorate([
 ], OrderModuleService.prototype, "updateOrderLineItemsWithSelector_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
@@ -1998,7 +2003,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "updateOrderItemWithSelector_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2021,7 +2027,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderShippingMethodsBulk_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2030,7 +2037,15 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "softDeleteOrderShippingMethods", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (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, "softDeleteOrderShippingMethods_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2039,7 +2054,15 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "restoreOrderShippingMethods", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (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, "restoreOrderShippingMethods_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2049,6 +2072,14 @@ __decorate([
 ], OrderModuleService.prototype, "createOrderLineItemAdjustments", null);
 __decorate([
     (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, "createOrderLineItemAdjustments_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
@@ -2056,6 +2087,14 @@ __decorate([
 ], OrderModuleService.prototype, "upsertOrderLineItemAdjustments", 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, "upsertOrderLineItemAdjustments_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
@@ -2063,6 +2102,14 @@ __decorate([
 ], OrderModuleService.prototype, "setOrderLineItemAdjustments", 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, "setOrderLineItemAdjustments_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
@@ -2070,13 +2117,29 @@ __decorate([
 ], OrderModuleService.prototype, "upsertOrderShippingMethodAdjustments", 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, "upsertOrderShippingMethodAdjustments_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "setOrderShippingMethodAdjustments", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (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, "setOrderShippingMethodAdjustments_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2085,7 +2148,15 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderShippingMethodAdjustments", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (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, "createOrderShippingMethodAdjustments_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2095,6 +2166,14 @@ __decorate([
 ], OrderModuleService.prototype, "createOrderLineItemTaxLines", 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, "createOrderLineItemTaxLines_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
@@ -2102,13 +2181,29 @@ __decorate([
 ], OrderModuleService.prototype, "upsertOrderLineItemTaxLines", 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, "upsertOrderLineItemTaxLines_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "setOrderLineItemTaxLines", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (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, "setOrderLineItemTaxLines_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2118,20 +2213,37 @@ __decorate([
 ], OrderModuleService.prototype, "createOrderShippingMethodTaxLines", 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, "createOrderShippingMethodTaxLines_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "upsertOrderShippingMethodTaxLines", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "setOrderShippingMethodTaxLines", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (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, "setOrderShippingMethodTaxLines_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -2140,7 +2252,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createReturns", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -2149,7 +2262,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderClaims", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -2159,12 +2273,14 @@ __decorate([
 ], OrderModuleService.prototype, "createOrderExchanges", 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, "createOrderRelatedEntity_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2179,12 +2295,14 @@ __decorate([
 ], OrderModuleService.prototype, "createOrderChange_", null);
 __decorate([
     (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, "previewOrderChange", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2192,6 +2310,7 @@ __decorate([
 ], OrderModuleService.prototype, "cancelOrderChange", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2203,22 +2322,55 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "confirmOrderChange_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __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.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)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "registerOrderChange", 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, "registerOrderChange_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __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.InjectTransactionManager)(),
+    __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)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
@@ -2226,6 +2378,7 @@ __decorate([
 ], OrderModuleService.prototype, "revertLastVersion", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object, Object]),
@@ -2233,18 +2386,21 @@ __decorate([
 ], OrderModuleService.prototype, "undoLastChange", 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, "undoLastChange_", 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, "revertLastChange_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2252,19 +2408,36 @@ __decorate([
 ], OrderModuleService.prototype, "addOrderAction", 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, "addOrderAction_", 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, "applyOrderChanges_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __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)()
+    (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, "addOrderTransactions_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -2273,7 +2446,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "deleteOrderTransactions", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2282,7 +2456,15 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "softDeleteOrderTransactions", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (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, "softDeleteOrderTransactions_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2292,12 +2474,21 @@ __decorate([
 ], OrderModuleService.prototype, "restoreOrderTransactions", 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, "restoreOrderTransactions_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Boolean, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "updateOrderPaidRefundableAmount_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2309,6 +2500,14 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "archive_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __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)(),
@@ -2316,6 +2515,14 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "completeOrder_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __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)(),
@@ -2323,9 +2530,25 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancel_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __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.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)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2340,6 +2563,7 @@ __decorate([
 ], OrderModuleService.prototype, "receiveReturn_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2354,6 +2578,7 @@ __decorate([
 ], OrderModuleService.prototype, "cancelReturn_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2368,6 +2593,7 @@ __decorate([
 ], OrderModuleService.prototype, "createClaim_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2382,13 +2608,15 @@ __decorate([
 ], OrderModuleService.prototype, "cancelClaim_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __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)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -2396,6 +2624,13 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "updateReturnReasons", 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, "updateReturnReasons_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
@@ -2405,6 +2640,7 @@ __decorate([
 ], OrderModuleService.prototype, "createExchange_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2419,6 +2655,7 @@ __decorate([
 ], OrderModuleService.prototype, "cancelExchange_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2426,6 +2663,7 @@ __decorate([
 ], OrderModuleService.prototype, "registerFulfillment", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2433,6 +2671,7 @@ __decorate([
 ], OrderModuleService.prototype, "cancelFulfillment", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -2440,13 +2679,15 @@ __decorate([
 ], OrderModuleService.prototype, "registerShipment", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "registerDelivery", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __metadata("design:type", Function),