@medusajs/order 3.0.0-snapshot-20250410112222 → 3.0.0-snapshot-20251104011621

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

@@ -21,13 +21,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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);
 };
@@ -35,9 +45,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 +80,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 +98,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 +108,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 +156,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 +169,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 +217,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);
@@ -349,7 +369,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         const lineItemsToCreate = [];
         const creditLinesToCreate = [];
         const createdOrders = [];
-        for (const { items, shipping_methods, credit_lines, ...order } of data) {
+        for (const { items, shipping_methods, credit_lines, shipping_address, billing_address, ...order } of data) {
             const ord = order;
             const shippingMethods = shipping_methods?.map((sm) => {
                 return {
@@ -431,11 +451,33 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
     }
     // @ts-expect-error
+    async deleteOrders(orderIds, sharedContext = {}) {
+        const ids = Array.isArray(orderIds) ? orderIds : [orderIds];
+        const orders = await this.orderService_.list({ id: ids }, {
+            select: ["id", "shipping_address_id", "billing_address_id"],
+        }, sharedContext);
+        const orderAddressIds = orders
+            .map((order) => [order.shipping_address_id, order.billing_address_id])
+            .flat(1);
+        const orderChanges = await this.orderChangeService_.list({ order_id: ids }, { select: ["id"] }, sharedContext);
+        const orderChangeIds = orderChanges.map((orderChange) => orderChange.id);
+        const orderItems = await this.orderItemService_.list({ order_id: ids }, { select: ["id", "item_id"] }, sharedContext);
+        const lineItemIds = orderItems.map((orderItem) => orderItem.item_id);
+        const orderShipping = await this.orderShippingService_.list({ order_id: ids }, { select: ["shipping_method_id"] }, sharedContext);
+        const orderShippingMethodIds = orderShipping.map((orderShipping) => orderShipping.shipping_method_id);
+        await this.orderAddressService_.delete(orderAddressIds, sharedContext);
+        await this.orderChangeService_.delete(orderChangeIds, sharedContext);
+        // Delete order, order items, summary, shipping methods, transactions and credit lines
+        await super.deleteOrders(ids, sharedContext);
+        await (0, utils_1.promiseAll)([
+            this.orderLineItemService_.delete(lineItemIds, sharedContext),
+            this.orderShippingMethodService_.delete(orderShippingMethodIds, sharedContext),
+        ]);
+    }
+    // @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 = {}) {
@@ -474,7 +516,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;
@@ -487,9 +529,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);
@@ -527,9 +567,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
@@ -540,9 +578,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);
@@ -560,7 +596,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,
@@ -583,9 +619,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
@@ -596,9 +630,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);
@@ -607,7 +639,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,
@@ -628,7 +660,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;
@@ -645,7 +677,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);
@@ -666,7 +698,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,
         }, {
@@ -680,7 +715,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,
         }, {
@@ -695,6 +733,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);
@@ -712,17 +754,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 ?? [])
@@ -741,18 +786,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 ?? [])
@@ -772,12 +820,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);
@@ -798,16 +848,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];
@@ -819,21 +873,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 ?? [])
@@ -852,12 +909,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];
@@ -866,21 +929,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 ?? [])
@@ -899,32 +958,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;
@@ -942,17 +993,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);
@@ -979,7 +1028,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"],
@@ -997,7 +1046,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) {
@@ -1073,7 +1122,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             });
         }
     }
-    async cancelOrderChange(orderChangeIdOrData, sharedContext) {
+    async cancelOrderChange(orderChangeIdOrData, sharedContext = {}) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
             : [orderChangeIdOrData];
@@ -1090,7 +1139,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];
@@ -1111,7 +1164,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];
@@ -1128,11 +1184,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,
@@ -1151,10 +1211,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"],
@@ -1187,7 +1251,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);
@@ -1196,7 +1260,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);
@@ -1205,7 +1269,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
@@ -1254,6 +1318,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }, { select: ["id", "version"] }, sharedContext);
         const orderShippingIds = orderShippings.map((sh) => sh.id);
         updatePromises.push(this.orderShippingService_.softDelete(orderShippingIds, sharedContext));
+        // Order Credit Lines
+        const orderCreditLines = await this.orderCreditLineService_.list({
+            order_id: order.id,
+            version: currentVersion,
+        }, { select: ["id", "version"] }, sharedContext);
+        const orderCreditLineIds = orderCreditLines.map((cl) => cl.id);
+        updatePromises.push(this.orderCreditLineService_.softDelete(orderCreditLineIds, sharedContext));
         // Order
         updatePromises.push(this.orderService_.update({
             selector: {
@@ -1265,7 +1336,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
@@ -1303,6 +1374,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }, { select: ["id", "version"] }, sharedContext);
         const orderShippingIds = orderShippings.map((sh) => sh.id);
         updatePromises.push(this.orderShippingService_.softDelete(orderShippingIds, sharedContext));
+        // Order Credit Lines
+        const orderCreditLines = await this.orderCreditLineService_.list({
+            order_id: order.id,
+            version: currentVersion,
+        }, { select: ["id", "version"] }, sharedContext);
+        const orderCreditLineIds = orderCreditLines.map((cl) => cl.id);
+        updatePromises.push(this.orderCreditLineService_.softDelete(orderCreditLineIds, sharedContext));
         // Order
         updatePromises.push(this.orderService_.update({
             selector: {
@@ -1397,7 +1475,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
@@ -1420,10 +1503,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 = [];
@@ -1450,18 +1533,18 @@ 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);
-        const { itemsToUpsert, shippingMethodsToUpsert, summariesToUpsert, orderToUpdate, creditLinesToCreate, } = await (0, utils_2.applyChangesToOrder)(orders, actionsMap, {
+        const { itemsToUpsert, shippingMethodsToUpsert, summariesToUpsert, orderToUpdate, creditLinesToUpsert, } = await (0, utils_2.applyChangesToOrder)(orders, actionsMap, {
             addActionReferenceToObject: true,
             includeTaxLinesAndAdjustementsToPreview: async (...args) => {
                 args.push(sharedContext);
                 return await this.includeTaxLinesAndAdjustementsToPreview.apply(this, args);
             },
         });
-        const [_orderUpdate, _orderChangeActionUpdate, orderItems, _orderSummaryUpdate, orderShippingMethods, createdOrderCreditLines,] = await (0, utils_1.promiseAll)([
+        const [_orderUpdate, _orderChangeActionUpdate, orderItems, _orderSummaryUpdate, orderShippingMethods, orderCreditLines,] = await (0, utils_1.promiseAll)([
             orderToUpdate.length
                 ? this.orderService_.update(orderToUpdate, sharedContext)
                 : null,
@@ -1477,17 +1560,24 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             shippingMethodsToUpsert.length
                 ? this.orderShippingService_.upsert(shippingMethodsToUpsert, sharedContext)
                 : null,
-            creditLinesToCreate.length
-                ? this.orderCreditLineService_.create(creditLinesToCreate, sharedContext)
+            creditLinesToUpsert.length
+                ? this.orderCreditLineService_.upsert(creditLinesToUpsert, sharedContext)
                 : null,
         ]);
         return {
             items: orderItems ?? [],
             shipping_methods: orderShippingMethods ?? [],
-            credit_lines: createdOrderCreditLines ?? [],
+            credit_lines: orderCreditLines ?? [],
         };
     }
-    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)
@@ -1507,12 +1597,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];
@@ -1525,7 +1613,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,
         }, {
@@ -1536,7 +1628,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,
         }, {
@@ -1547,8 +1643,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);
@@ -1575,9 +1671,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 = [];
@@ -1600,11 +1700,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 = [];
@@ -1623,11 +1727,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();
@@ -1642,10 +1750,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: [
@@ -1656,9 +1768,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.id, {
+        const returned = await this.retrieveReturn(ret[0].id, {
             relations: [
                 "items",
                 "items.item",
@@ -1667,13 +1779,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",
@@ -1681,11 +1794,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: [
@@ -1701,23 +1815,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: [
@@ -1731,12 +1844,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
@@ -1751,34 +1866,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) {
@@ -1786,80 +1899,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);
 __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);
+], OrderModuleService.prototype, "listOrders_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1882,7 +1930,18 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderAddresses_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "deleteOrders", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1898,7 +1957,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)()),
@@ -1921,7 +1981,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)()),
@@ -1945,6 +2006,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]),
@@ -1965,7 +2027,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)()),
@@ -1988,7 +2051,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)()),
@@ -1997,7 +2061,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)()),
@@ -2006,7 +2078,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)()),
@@ -2016,6 +2096,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]),
@@ -2023,6 +2111,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]),
@@ -2030,6 +2126,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]),
@@ -2037,13 +2141,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)()),
@@ -2052,7 +2172,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)()),
@@ -2062,6 +2190,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]),
@@ -2069,13 +2205,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)()),
@@ -2085,20 +2237,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)()),
@@ -2107,7 +2276,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)()),
@@ -2116,7 +2286,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)()),
@@ -2126,12 +2297,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]),
@@ -2146,12 +2319,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]),
@@ -2159,6 +2334,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]),
@@ -2170,22 +2346,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]),
@@ -2193,6 +2402,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]),
@@ -2200,18 +2410,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]),
@@ -2219,19 +2432,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)()),
@@ -2240,7 +2470,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)()),
@@ -2249,7 +2480,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)()),
@@ -2259,12 +2498,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]),
@@ -2276,6 +2524,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)(),
@@ -2283,6 +2539,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)(),
@@ -2290,9 +2554,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]),
@@ -2307,6 +2587,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]),
@@ -2321,6 +2602,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]),
@@ -2335,6 +2617,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]),
@@ -2349,13 +2632,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)()),
@@ -2363,6 +2648,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)()),
@@ -2372,6 +2664,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]),
@@ -2386,6 +2679,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]),
@@ -2393,6 +2687,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]),
@@ -2400,6 +2695,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]),
@@ -2407,13 +2703,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),