@medusajs/order 0.1.3-snapshot-20240718083016 → 0.1.3-snapshot-20240719133408

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

@@ -1,10 +1,33 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -15,26 +38,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@medusajs/types");
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-const joiner_config_1 = require("../joiner-config");
 const utils_2 = require("../utils");
-const transform_order_1 = require("../utils/transform-order");
-const generateMethodForModels = [
-    _models_1.Address,
-    _models_1.LineItem,
-    _models_1.LineItemAdjustment,
-    _models_1.LineItemTaxLine,
-    _models_1.ShippingMethod,
-    _models_1.ShippingMethodAdjustment,
-    _models_1.ShippingMethodTaxLine,
-    _models_1.Transaction,
-    _models_1.OrderChange,
-    _models_1.OrderChangeAction,
-    _models_1.OrderItem,
-    _models_1.OrderSummary,
-    _models_1.OrderShippingMethod,
-];
-class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.Order, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
-    constructor({ baseRepository, orderService, addressService, lineItemService, shippingMethodAdjustmentService, shippingMethodService, lineItemAdjustmentService, shippingMethodTaxLineService, lineItemTaxLineService, transactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingMethodService, }, moduleDeclaration) {
+const BundledActions = __importStar(require("./actions"));
+const generateMethodForModels = {
+    Order: _models_1.Order,
+    Address: _models_1.Address,
+    LineItem: _models_1.LineItem,
+    LineItemAdjustment: _models_1.LineItemAdjustment,
+    LineItemTaxLine: _models_1.LineItemTaxLine,
+    ShippingMethod: _models_1.ShippingMethod,
+    ShippingMethodAdjustment: _models_1.ShippingMethodAdjustment,
+    ShippingMethodTaxLine: _models_1.ShippingMethodTaxLine,
+    Transaction: _models_1.Transaction,
+    OrderChange: _models_1.OrderChange,
+    OrderChangeAction: _models_1.OrderChangeAction,
+    OrderItem: _models_1.OrderItem,
+    OrderSummary: _models_1.OrderSummary,
+    OrderShippingMethod: _models_1.OrderShippingMethod,
+    ReturnReason: _models_1.ReturnReason,
+    Return: _models_1.Return,
+    ReturnItem: _models_1.ReturnItem,
+    OrderClaim: _models_1.OrderClaim,
+    OrderExchange: _models_1.OrderExchange,
+};
+// TODO: rm template args here, keep it for later to not collide with carlos work at least as little as possible
+class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
+    constructor({ baseRepository, orderService, addressService, lineItemService, shippingMethodAdjustmentService, shippingMethodService, lineItemAdjustmentService, shippingMethodTaxLineService, lineItemTaxLineService, transactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingMethodService, returnReasonService, returnService, returnItemService, orderClaimService, orderExchangeService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
@@ -53,9 +82,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         this.orderItemService_ = orderItemService;
         this.orderSummaryService_ = orderSummaryService;
         this.orderShippingMethodService_ = orderShippingMethodService;
-    }
-    __joinerConfig() {
-        return joiner_config_1.joinerConfig;
+        this.returnReasonService_ = returnReasonService;
+        this.returnService_ = returnService;
+        this.returnItemService_ = returnItemService;
+        this.orderClaimService_ = orderClaimService;
+        this.orderExchangeService_ = orderExchangeService;
     }
     shouldIncludeTotals(config) {
         const totalFields = [
@@ -76,7 +107,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             "shipping_subtotal",
             "shipping_tax_total",
             "original_shipping_tax_total",
-            "original_shipping_tax_subtotal",
+            "original_shipping_subtotal",
             "original_shipping_total",
         ];
         const includeTotals = (config?.select ?? []).some((field) => totalFields.includes(field));
@@ -86,8 +117,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return includeTotals;
     }
     addRelationsToCalculateTotals(config, totalFields) {
-        config.relations ?? (config.relations = []);
-        config.select ?? (config.select = []);
+        config.relations ??= [];
+        config.select ??= [];
         const requiredFieldsForTotals = [
             "items",
             "items.tax_lines",
@@ -104,33 +135,144 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             return (!requiredFieldsForTotals.some((val) => val.startsWith(field)) && !totalFields.includes(field));
         });
     }
-    async retrieve(id, config, sharedContext) {
-        config ?? (config = {});
+    // @ts-expect-error
+    async retrieveOrder(id, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const order = await super.retrieveOrder(id, config, sharedContext);
+        const orderChange = await this.getActiveOrderChange_(order.id, false, sharedContext);
+        order.order_change = orderChange;
+        return (0, utils_2.formatOrder)(order, {
+            entity: _models_1.Order,
+            includeTotals,
+        });
+    }
+    // @ts-expect-error
+    async listOrders(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const orders = await super.listOrders(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(orders, {
+            entity: _models_1.Order,
+            includeTotals,
+        });
+    }
+    // @ts-expect-error
+    async listAndCountOrders(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const [orders, count] = await super.listAndCountOrders(filters, config, sharedContext);
+        return [
+            (0, utils_2.formatOrder)(orders, {
+                entity: _models_1.Order,
+                includeTotals,
+            }),
+            count,
+        ];
+    }
+    // @ts-ignore
+    async retrieveReturn(id, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrder = await super.retrieveReturn(id, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrder, {
+            entity: _models_1.Return,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listReturns(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrders = await super.listReturns(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrders, {
+            entity: _models_1.Return,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listAndCountReturns(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const [returnOrders, count] = await super.listAndCountReturns(filters, config, sharedContext);
+        return [
+            (0, utils_2.formatOrder)(returnOrders, {
+                entity: _models_1.Return,
+                includeTotals,
+            }),
+            count,
+        ];
+    }
+    // @ts-ignore
+    async retrieveOrderClaim(id, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrder = await super.retrieveOrderClaim(id, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrder, {
+            entity: _models_1.OrderClaim,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listOrderClaims(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const returnOrders = await super.listOrderClaims(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrders, {
+            entity: _models_1.OrderClaim,
+            includeTotals,
+        });
+    }
+    // @ts-ignore
+    async listAndCountOrderClaims(filters, config, sharedContext) {
+        config ??= {};
+        const includeTotals = this.shouldIncludeTotals(config);
+        const [returnOrders, count] = await super.listAndCountOrderClaims(filters, config, sharedContext);
+        return [
+            (0, utils_2.formatOrder)(returnOrders, {
+                entity: _models_1.OrderClaim,
+                includeTotals,
+            }),
+            count,
+        ];
+    }
+    // @ts-ignore
+    async retrieveOrderExchange(id, config, sharedContext) {
+        config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
-        const order = await super.retrieve(id, config, sharedContext);
-        return (0, transform_order_1.formatOrder)(order, { includeTotals });
+        const returnOrder = await super.retrieveOrderExchange(id, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrder, {
+            entity: _models_1.OrderExchange,
+            includeTotals,
+        });
     }
-    async list(filters, config, sharedContext) {
-        config ?? (config = {});
+    // @ts-ignore
+    async listOrderExchanges(filters, config, sharedContext) {
+        config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
-        const orders = await super.list(filters, config, sharedContext);
-        return (0, transform_order_1.formatOrder)(orders, {
+        const returnOrders = await super.listOrderExchanges(filters, config, sharedContext);
+        return (0, utils_2.formatOrder)(returnOrders, {
+            entity: _models_1.OrderExchange,
             includeTotals,
         });
     }
-    async listAndCount(filters, config, sharedContext) {
-        config ?? (config = {});
+    // @ts-ignore
+    async listAndCountOrderExchanges(filters, config, sharedContext) {
+        config ??= {};
         const includeTotals = this.shouldIncludeTotals(config);
-        const [orders, count] = await super.listAndCount(filters, config, sharedContext);
+        const [returnOrders, count] = await super.listAndCountOrderExchanges(filters, config, sharedContext);
         return [
-            (0, transform_order_1.formatOrder)(orders, { includeTotals }),
+            (0, utils_2.formatOrder)(returnOrders, {
+                entity: _models_1.OrderExchange,
+                includeTotals,
+            }),
             count,
         ];
     }
-    async create(data, sharedContext = {}) {
+    async createOrders(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const orders = await this.create_(input, sharedContext);
-        const result = await this.list({
+        const orders = await this.createOrders_(input, sharedContext);
+        const result = await this.listOrders({
             id: orders.map((p) => p.id),
         }, {
             relations: [
@@ -148,7 +290,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }, sharedContext);
         return (Array.isArray(data) ? result : result[0]);
     }
-    async create_(data, sharedContext = {}) {
+    async createOrders_(data, sharedContext = {}) {
         const lineItemsToCreate = [];
         const createdOrders = [];
         for (const { items, shipping_methods, ...order } of data) {
@@ -189,14 +331,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         }
         return createdOrders;
     }
-    async update(dataOrIdOrSelector, data, sharedContext = {}) {
-        const result = await this.update_(dataOrIdOrSelector, data, sharedContext);
+    async updateOrders(dataOrIdOrSelector, data, sharedContext = {}) {
+        const result = await this.updateOrders_(dataOrIdOrSelector, data, sharedContext);
         const serializedResult = await this.baseRepository_.serialize(result, {
             populate: true,
         });
         return (0, utils_1.isString)(dataOrIdOrSelector) ? serializedResult[0] : serializedResult;
     }
-    async update_(dataOrIdOrSelector, data, sharedContext = {}) {
+    async updateOrders_(dataOrIdOrSelector, data, sharedContext = {}) {
         let toUpdate = [];
         if ((0, utils_1.isString)(dataOrIdOrSelector)) {
             toUpdate = [
@@ -231,7 +373,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.list({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
+            const order = await this.listOrders({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
             const mapOrderVersion = order.reduce((acc, curr) => {
                 acc[curr.id] = curr.version;
                 return acc;
@@ -249,7 +391,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         });
     }
     async createLineItems_(orderId, items, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id", "version"] }, sharedContext);
+        const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
         const toUpdate = items.map((item) => {
             return {
                 ...item,
@@ -401,7 +543,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.list({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
+            const order = await this.listOrders({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
             const mapOrderVersion = order.reduce((acc, curr) => {
                 acc[curr.id] = curr.version;
                 return acc;
@@ -410,7 +552,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 return {
                     shipping_method: dt,
                     order_id: dt.order_id,
-                    version: mapOrderVersion[dt.order_id],
+                    return_id: dt.return_id,
+                    claim_id: dt.claim_id,
+                    exchange_id: dt.exchange_id,
+                    version: dt.version ?? mapOrderVersion[dt.order_id],
                 };
             });
             methods = await this.createShippingMethodsBulk_(orderShippingMethodData, sharedContext);
@@ -418,12 +563,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return await this.baseRepository_.serialize(methods, { populate: true });
     }
     async createShippingMethods_(orderId, data, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id", "version"] }, sharedContext);
-        const methods = data.map((method) => {
+        const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
+        const methods = data.map((methodData) => {
             return {
-                shipping_method: method,
+                shipping_method: methodData,
                 order_id: order.id,
-                version: method.version ?? order.version ?? 1,
+                return_id: methodData.return_id,
+                claim_id: methodData.claim_id,
+                exchange_id: methodData.exchange_id,
+                version: methodData.version ?? order.version ?? 1,
             };
         });
         return await this.createShippingMethodsBulk_(methods, sharedContext);
@@ -432,10 +580,38 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         const sm = await this.orderShippingMethodService_.create(data, sharedContext);
         return sm.map((s) => s.shipping_method);
     }
+    // @ts-ignore
+    async softDeleteShippingMethods(ids, config, sharedContext) {
+        const rel = await super.listOrderShippingMethods({
+            shipping_method_id: ids,
+        }, {
+            select: ["id"],
+        }, sharedContext);
+        const orderShippingMethodIds = rel.map((r) => r.id);
+        const [returned] = await (0, utils_1.promiseAll)([
+            super.softDeleteShippingMethods(ids, config, sharedContext),
+            super.softDeleteOrderShippingMethods(orderShippingMethodIds, config, sharedContext),
+        ]);
+        return returned;
+    }
+    // @ts-ignore
+    async restoreShippingMethods(transactionIds, config, sharedContext) {
+        const rel = await super.listOrderShippingMethods({
+            shipping_method_id: transactionIds,
+        }, {
+            select: ["id"],
+        }, sharedContext);
+        const orderShippingMethodIds = rel.map((r) => r.id);
+        const [returned] = await (0, utils_1.promiseAll)([
+            super.restoreShippingMethods(transactionIds, config, sharedContext),
+            super.restoreOrderShippingMethods(orderShippingMethodIds, config, sharedContext),
+        ]);
+        return returned;
+    }
     async createLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
+            const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
             const lineIds = order.items?.map((item) => item.id);
             for (const adj of adjustments || []) {
                 if (!lineIds?.includes(adj.item_id)) {
@@ -455,7 +631,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         });
     }
     async setLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
         const existingAdjustments = (order.items ?? [])
             .map((item) => item.adjustments ?? [])
             .flat()
@@ -479,7 +655,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         });
     }
     async setShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
         const existingAdjustments = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.adjustments ?? [])
             .flat()
@@ -505,7 +681,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
     async createShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
+            const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
             const methodIds = order.shipping_methods?.map((method) => method.id);
             for (const adj of adjustments || []) {
                 if (!methodIds?.includes(adj.shipping_method_id)) {
@@ -550,7 +726,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return serialized;
     }
     async setLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.items ?? [])
             .map((item) => item.tax_lines ?? [])
             .flat()
@@ -590,7 +766,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return serialized;
     }
     async setShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
-        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
+        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.tax_lines ?? [])
             .flat()
@@ -612,6 +788,42 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             populate: true,
         });
     }
+    async createReturns(data, sharedContext) {
+        const created = await this.createOrderRelatedEntity_(data, this.returnService_, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
+            populate: true,
+        });
+    }
+    async createOrderClaims(data, sharedContext) {
+        const created = await this.createOrderRelatedEntity_(data, this.orderClaimService_, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
+            populate: true,
+        });
+    }
+    async createOrderExchanges(data, sharedContext) {
+        const created = await this.createOrderRelatedEntity_(data, this.orderExchangeService_, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
+            populate: true,
+        });
+    }
+    async createOrderRelatedEntity_(data, service, sharedContext) {
+        const data_ = Array.isArray(data) ? data : [data];
+        const inputDataMap = data_.reduce((acc, curr) => {
+            acc[curr.order_id] = curr;
+            return acc;
+        }, {});
+        const orderIds = data_.map((d) => d.order_id);
+        const orders = await this.orderService_.list({ id: orderIds }, { select: ["id", "version"] }, sharedContext);
+        if (orders.length !== orderIds.length) {
+            const foundOrders = orders.map((o) => o.id);
+            const missing = orderIds.filter((id) => !foundOrders.includes(id));
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order could not be found: ${missing.join(", ")}`);
+        }
+        for (const order of orders) {
+            inputDataMap[order.id].order_version = order.version;
+        }
+        return await service.create(data_, sharedContext);
+    }
     async createOrderChange(data, sharedContext) {
         const changes = await this.createOrderChange_(data, sharedContext);
         return await this.baseRepository_.serialize(Array.isArray(data) ? changes : changes[0], {
@@ -622,21 +834,26 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         const dataArr = Array.isArray(data) ? data : [data];
         const orderIds = [];
         const dataMap = {};
+        const orderChanges = await this.listOrderChanges({
+            order_id: dataArr.map((data) => data.order_id),
+            status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
+        }, {}, sharedContext);
+        const orderChangesMap = new Map(orderChanges.map((item) => [item.order_id, item]));
         for (const change of dataArr) {
             orderIds.push(change.order_id);
             dataMap[change.order_id] = change;
         }
-        const orders = await this.list({
-            id: orderIds,
-        }, {
-            select: ["id", "version"],
-        }, sharedContext);
+        const orders = await this.orderService_.list({ id: orderIds }, { select: ["id", "version"] }, sharedContext);
         if (orders.length !== orderIds.length) {
             const foundOrders = orders.map((o) => o.id);
             const missing = orderIds.filter((id) => !foundOrders.includes(id));
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order could not be found: ${missing.join(", ")}`);
         }
         const input = orders.map((order) => {
+            const existingOrderChange = orderChangesMap.get(order.id);
+            if (existingOrderChange) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order (${order.id}) already has an existing active order change`);
+            }
             return {
                 ...dataMap[order.id],
                 version: order.version + 1,
@@ -644,6 +861,98 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         });
         return await this.orderChangeService_.create(input, sharedContext);
     }
+    async previewOrderChange(orderId, sharedContext) {
+        const order = await this.retrieveOrder(orderId, {
+            select: ["id", "version", "items.detail", "summary", "total"],
+            relations: [
+                "transactions",
+                "items",
+                "items.detail",
+                "shipping_methods",
+            ],
+        }, sharedContext);
+        if (!order.order_change) {
+            return order;
+        }
+        const orderChange = await super.retrieveOrderChange(order.order_change.id, { relations: ["actions"] }, sharedContext);
+        orderChange.actions = orderChange.actions.map((action) => {
+            return {
+                ...action,
+                version: orderChange.version,
+                order_id: orderChange.order_id,
+                return_id: orderChange.return_id,
+                claim_id: orderChange.claim_id,
+                exchange_id: orderChange.exchange_id,
+            };
+        });
+        const { itemsToUpsert, shippingMethodsToUpsert, calculatedOrders } = (0, utils_2.applyChangesToOrder)([order], { [order.id]: orderChange.actions }, { addActionReferenceToObject: true });
+        const calculated = calculatedOrders[order.id];
+        const addedItems = {};
+        const addedShippingMethods = {};
+        for (const item of calculated.order.items) {
+            const isExistingItem = item.id === item.detail?.item_id;
+            if (!isExistingItem) {
+                addedItems[item.id] = item;
+            }
+        }
+        for (const sm of calculated.order.shipping_methods) {
+            if (!(0, utils_1.isDefined)(sm.shipping_option_id)) {
+                addedShippingMethods[sm.id] = sm;
+            }
+        }
+        if (Object.keys(addedItems).length > 0) {
+            const addedItemDetails = await this.listLineItems({ id: Object.keys(addedItems) }, {
+                relations: ["adjustments", "tax_lines"],
+            }, sharedContext);
+            calculated.order.items.forEach((item, idx) => {
+                if (!addedItems[item.id]) {
+                    return;
+                }
+                const lineItem = addedItemDetails.find((d) => d.id === item.id);
+                const actions = item.actions;
+                delete item.actions;
+                const newItem = itemsToUpsert.find((d) => d.item_id === item.id);
+                calculated.order.items[idx] = {
+                    ...lineItem,
+                    actions,
+                    quantity: newItem.quantity,
+                    detail: {
+                        ...newItem,
+                        ...item,
+                    },
+                };
+            });
+        }
+        if (Object.keys(addedShippingMethods).length > 0) {
+            const addedShippingDetails = await this.listShippingMethods({ id: Object.keys(addedShippingMethods) }, {
+                relations: ["adjustments", "tax_lines"],
+            }, sharedContext);
+            calculated.order.shipping_methods.forEach((sm, idx) => {
+                if (!addedShippingMethods[sm.id]) {
+                    return;
+                }
+                const shippingMethod = addedShippingDetails.find((d) => d.id === sm.id);
+                const actions = sm.actions;
+                delete sm.actions;
+                const newItem = shippingMethodsToUpsert.find((d) => d.id === sm.id);
+                sm.shipping_method_id = sm.id;
+                delete sm.id;
+                calculated.order.shipping_methods[idx] = {
+                    ...shippingMethod,
+                    actions,
+                    detail: {
+                        ...sm,
+                        ...newItem,
+                    },
+                };
+            });
+        }
+        const calcOrder = calculated.order;
+        (0, utils_1.decorateCartTotals)(calcOrder);
+        calcOrder.summary = calculated.summary;
+        (0, utils_1.createRawPropertiesFromBigNumber)(calcOrder);
+        return calcOrder;
+    }
     async cancelOrderChange(orderChangeIdOrData, sharedContext) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
@@ -683,11 +992,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                     ...action,
                     version: change.version,
                     order_id: change.order_id,
+                    return_id: change.return_id,
+                    claim_id: change.claim_id,
+                    exchange_id: change.exchange_id,
                 };
             });
             return change.actions;
         });
-        await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
+        return await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
     }
     async declineOrderChange(orderChangeIdOrData, sharedContext) {
         const data = Array.isArray(orderChangeIdOrData)
@@ -708,7 +1020,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
     }
     async applyPendingOrderActions(orderId, sharedContext) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.list({ id: orderIds }, {
+        const orders = await this.orderService_.list({ id: orderIds }, {
             select: ["id", "version"],
         }, sharedContext);
         const changes = await this.orderChangeActionService_.list({
@@ -719,6 +1031,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             select: [
                 "id",
                 "order_id",
+                "return_id",
+                "exchange_id",
+                "claim_id",
                 "ordering",
                 "version",
                 "applied",
@@ -734,10 +1049,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 ordering: "ASC",
             },
         }, sharedContext);
-        await this.applyOrderChanges_(changes, sharedContext);
+        return await this.applyOrderChanges_(changes, sharedContext);
     }
     async revertLastVersion(orderId, sharedContext) {
-        const order = await super.retrieve(orderId, {
+        const order = await super.retrieveOrder(orderId, {
             select: ["id", "version"],
         }, sharedContext);
         if (order.version < 2) {
@@ -791,10 +1106,58 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 version: order.version - 1,
             },
         }, sharedContext);
+        // Returns
+        await this.returnService_.delete({
+            order_id: order.id,
+            order_version: currentVersion,
+        }, sharedContext);
+    }
+    async getActiveOrderChange_(orderId, includeActions, sharedContext) {
+        const options = {
+            select: [
+                "id",
+                "change_type",
+                "order_id",
+                "return_id",
+                "claim_id",
+                "exchange_id",
+                "version",
+                "requested_at",
+                "requested_by",
+                "status",
+                "description",
+                "internal_note",
+            ],
+            relations: [],
+            order: {},
+        };
+        if (includeActions) {
+            options.select.push("actions");
+            options.relations.push("actions");
+            options.order = {
+                actions: {
+                    ordering: "ASC",
+                },
+            };
+        }
+        const [orderChange] = await this.listOrderChanges({
+            order_id: orderId,
+            status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
+        }, options, sharedContext);
+        return orderChange;
     }
     async getAndValidateOrderChange_(orderChangeIds, includeActions, sharedContext) {
+        orderChangeIds = (0, utils_1.deduplicate)(orderChangeIds);
         const options = {
-            select: ["id", "order_id", "version", "status"],
+            select: [
+                "id",
+                "order_id",
+                "return_id",
+                "claim_id",
+                "exchange_id",
+                "version",
+                "status",
+            ],
             relations: [],
             order: {},
         };
@@ -832,9 +1195,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         const orderChangeMap = {};
         const orderChangeIds = dataArr
             .map((data, idx) => {
-            var _a;
             if (data.order_change_id) {
-                orderChangeMap[_a = data.order_change_id] ?? (orderChangeMap[_a] = []);
+                orderChangeMap[data.order_change_id] ??= [];
                 orderChangeMap[data.order_change_id].push(dataArr[idx]);
             }
             return data.order_change_id;
@@ -855,7 +1217,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
         return Array.isArray(data) ? actions : actions[0];
     }
     async applyOrderChanges_(changeActions, sharedContext) {
-        var _a;
         const actionsMap = {};
         const ordersIds = [];
         const usedActions = [];
@@ -864,7 +1225,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
                 continue;
             }
             ordersIds.push(action.order_id);
-            actionsMap[_a = action.order_id] ?? (actionsMap[_a] = []);
+            actionsMap[action.order_id] ??= [];
             actionsMap[action.order_id].push(action);
             usedActions.push({
                 selector: {
@@ -876,74 +1237,26 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             });
         }
         if (!ordersIds.length) {
-            return;
+            return {
+                items: [],
+                shippingMethods: [],
+            };
         }
-        const orders = await this.list({ id: (0, utils_1.deduplicate)(ordersIds) }, {
-            select: [
-                "id",
-                "version",
-                "items.detail",
+        let orders = await super.listOrders({ id: (0, utils_1.deduplicate)(ordersIds) }, {
+            select: ["id", "version", "items.detail", "summary", "total"],
+            relations: [
                 "transactions",
-                "summary",
-                "total",
+                "items",
+                "items.detail",
+                "shipping_methods",
             ],
-            relations: ["transactions", "items", "items.detail"],
         }, sharedContext);
-        const itemsToUpsert = [];
-        const shippingMethodsToInsert = [];
-        const summariesToUpsert = [];
-        const orderToUpdate = [];
-        for (const order of orders) {
-            const calculated = (0, utils_2.calculateOrderChange)({
-                order: order,
-                actions: actionsMap[order.id],
-                transactions: order.transactions,
-            });
-            (0, utils_1.createRawPropertiesFromBigNumber)(calculated);
-            const version = actionsMap[order.id][0].version;
-            for (const item of calculated.order.items) {
-                const orderItem = item.detail;
-                itemsToUpsert.push({
-                    id: orderItem.version === version ? orderItem.id : undefined,
-                    item_id: item.id,
-                    order_id: order.id,
-                    version,
-                    quantity: item.detail.quantity,
-                    fulfilled_quantity: item.detail.fulfilled_quantity,
-                    shipped_quantity: item.detail.shipped_quantity,
-                    return_requested_quantity: item.detail.return_requested_quantity,
-                    return_received_quantity: item.detail.return_received_quantity,
-                    return_dismissed_quantity: item.detail.return_dismissed_quantity,
-                    written_off_quantity: item.detail.written_off_quantity,
-                    metadata: item.detail.metadata,
-                });
-            }
-            const orderSummary = order.summary;
-            summariesToUpsert.push({
-                id: orderSummary.version === version ? orderSummary.id : undefined,
-                order_id: order.id,
-                version,
-                totals: calculated.summary,
-            });
-            if (version > order.version) {
-                for (const shippingMethod of order.shipping_methods ?? []) {
-                    const sm = {
-                        ...shippingMethod.detail,
-                        version,
-                    };
-                    delete sm.id;
-                    shippingMethodsToInsert.push(sm);
-                }
-                orderToUpdate.push({
-                    selector: {
-                        id: order.id,
-                    },
-                    data: {
-                        version,
-                    },
-                });
-            }
-        }
+        orders = (0, utils_2.formatOrder)(orders, {
+            entity: _models_1.Order,
+        });
+        const { itemsToUpsert, shippingMethodsToUpsert, summariesToUpsert, orderToUpdate, } = (0, utils_2.applyChangesToOrder)(orders, actionsMap, {
+            addActionReferenceToObject: true,
+        });
         await (0, utils_1.promiseAll)([
             orderToUpdate.length
                 ? this.orderService_.update(orderToUpdate, sharedContext)
@@ -957,153 +1270,378 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFa
             summariesToUpsert.length
                 ? this.orderSummaryService_.upsert(summariesToUpsert, sharedContext)
                 : null,
-            shippingMethodsToInsert.length
-                ? this.orderShippingMethodService_.create(shippingMethodsToInsert, sharedContext)
+            shippingMethodsToUpsert.length
+                ? this.orderShippingMethodService_.upsert(shippingMethodsToUpsert, sharedContext)
                 : null,
         ]);
+        return {
+            items: itemsToUpsert,
+            shippingMethods: shippingMethodsToUpsert,
+        };
     }
-    async registerFulfillment(data, sharedContext) {
-        const items = data.items.map((item) => {
-            return {
-                action: utils_2.ChangeActionType.FULFILL_ITEM,
-                internal_note: item.internal_note,
-                reference: data.reference,
-                reference_id: data.reference_id,
-                details: {
-                    reference_id: item.id,
-                    quantity: item.quantity,
-                    metadata: item.metadata,
-                },
-            };
+    async addTransactions(transactionData, sharedContext) {
+        const orders = await this.orderService_.list({
+            id: Array.isArray(transactionData)
+                ? transactionData.map((t) => t.order_id)
+                : transactionData.order_id,
+        }, {
+            select: ["id", "version"],
+        }, sharedContext);
+        const data = Array.isArray(transactionData)
+            ? transactionData
+            : [transactionData];
+        for (const order of orders) {
+            const trxs = data.filter((t) => t.order_id === order.id);
+            for (const trx of trxs) {
+                ;
+                trx.version = order.version;
+            }
+        }
+        const created = await this.transactionService_.create(data, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(created, false, sharedContext);
+        return await this.baseRepository_.serialize(!Array.isArray(transactionData) ? created[0] : created, {
+            populate: true,
         });
-        const change = await this.createOrderChange_({
-            order_id: data.order_id,
-            description: data.description,
-            internal_note: data.internal_note,
-            created_by: data.created_by,
-            metadata: data.metadata,
-            actions: items,
+    }
+    // @ts-ignore
+    async deleteTransactions(transactionIds, sharedContext) {
+        const data = Array.isArray(transactionIds)
+            ? transactionIds
+            : [transactionIds];
+        const transactions = await super.listTransactions({
+            id: data,
+        }, {
+            select: ["order_id", "version", "amount"],
         }, sharedContext);
-        await this.confirmOrderChange(change[0].id, sharedContext);
+        await this.transactionService_.delete(data, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
     }
-    async registerShipment(data, sharedContext) {
-        let shippingMethodId;
-        if (!(0, utils_1.isString)(data.shipping_method)) {
-            const methods = await this.createShippingMethods(data.order_id, data.shipping_method, sharedContext);
-            shippingMethodId = methods[0].id;
-        }
-        else {
-            shippingMethodId = data.shipping_method;
-        }
-        const method = await this.shippingMethodService_.retrieve(shippingMethodId, {
-            relations: ["tax_lines", "adjustments"],
+    // @ts-ignore
+    async softDeleteTransactions(transactionIds, config, sharedContext) {
+        const transactions = await super.listTransactions({
+            id: transactionIds,
+        }, {
+            select: ["order_id", "amount"],
         }, sharedContext);
-        const calculatedAmount = (0, utils_1.getShippingMethodsTotals)([method], {})[method.id];
-        const actions = data.items.map((item) => {
-            return {
-                action: utils_2.ChangeActionType.SHIP_ITEM,
-                internal_note: item.internal_note,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                details: {
-                    reference_id: item.id,
-                    quantity: item.quantity,
-                    metadata: item.metadata,
-                },
-            };
+        const returned = await super.softDeleteTransactions(transactionIds, config, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
+        return returned;
+    }
+    // @ts-ignore
+    async restoreTransactions(transactionIds, config, sharedContext) {
+        const transactions = await super.listTransactions({
+            id: transactionIds,
+        }, {
+            select: ["order_id", "amount"],
+            withDeleted: true,
+        }, sharedContext);
+        const returned = await super.restoreTransactions(transactionIds, config, sharedContext);
+        await this.updateOrderPaidRefundableAmount_(transactions, false, sharedContext);
+        return returned;
+    }
+    async updateOrderPaidRefundableAmount_(transactionData, isRemoved, sharedContext) {
+        const summaries = await super.listOrderSummaries({
+            order_id: transactionData.map((trx) => trx.order_id),
+        }, {}, sharedContext);
+        summaries.forEach((summary) => {
+            let trxs = transactionData.filter((trx) => trx.order_id === summary.order_id);
+            if (!trxs.length) {
+                return;
+            }
+            (0, utils_1.transformPropertiesToBigNumber)(trxs);
+            const op = isRemoved ? utils_1.MathBN.sub : utils_1.MathBN.add;
+            for (const trx of trxs) {
+                if (utils_1.MathBN.gt(trx.amount, 0)) {
+                    summary.totals.paid_total = new utils_1.BigNumber(op(summary.totals.paid_total, trx.amount));
+                }
+                else {
+                    summary.totals.refunded_total = new utils_1.BigNumber(op(summary.totals.refunded_total, utils_1.MathBN.abs(trx.amount)));
+                }
+            }
         });
-        if (shippingMethodId) {
-            actions.push({
-                action: utils_2.ChangeActionType.SHIPPING_ADD,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                amount: calculatedAmount.total,
-            });
+        (0, utils_1.createRawPropertiesFromBigNumber)(summaries);
+        await this.orderSummaryService_.update(summaries, sharedContext);
+    }
+    async archive(orderId, sharedContext) {
+        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
+        const orders = await this.listOrders({
+            id: orderIds,
+        }, {}, sharedContext);
+        const notAllowed = [];
+        for (const order of orders) {
+            if (![
+                utils_1.OrderStatus.COMPLETED,
+                utils_1.OrderStatus.CANCELED,
+                utils_1.OrderStatus.DRAFT,
+            ].includes(order.status)) {
+                notAllowed.push(order.id);
+            }
+            order.status = utils_1.OrderStatus.ARCHIVED;
+        }
+        if (notAllowed.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Orders ${notAllowed.join(", ")} are completed, canceled, or in draft and cannot be archived`);
         }
-        const change = await this.createOrderChange_({
-            order_id: data.order_id,
-            description: data.description,
-            internal_note: data.internal_note,
-            created_by: data.created_by,
-            metadata: data.metadata,
-            actions,
+        await this.orderService_.update({
+            id: orderIds,
+            status: utils_1.OrderStatus.ARCHIVED,
         }, sharedContext);
-        await this.confirmOrderChange(change[0].id, sharedContext);
+        return Array.isArray(orderId) ? orders : orders[0];
     }
-    async createReturn(data, sharedContext) {
-        let shippingMethodId;
-        if (!(0, utils_1.isString)(data.shipping_method)) {
-            const methods = await this.createShippingMethods(data.order_id, data.shipping_method, sharedContext);
-            shippingMethodId = methods[0].id;
+    async completeOrder(orderId, sharedContext) {
+        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
+        const orders = await this.listOrders({
+            id: orderIds,
+        }, {}, sharedContext);
+        const notAllowed = [];
+        for (const order of orders) {
+            if ([utils_1.OrderStatus.CANCELED].includes(order.status)) {
+                notAllowed.push(order.id);
+            }
+            order.status = utils_1.OrderStatus.COMPLETED;
         }
-        else {
-            shippingMethodId = data.shipping_method;
+        if (notAllowed.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Orders ${notAllowed.join(", ")} are canceled and cannot be completed`);
         }
-        const method = await this.shippingMethodService_.retrieve(shippingMethodId, {
-            relations: ["tax_lines", "adjustments"],
-        }, sharedContext);
-        const calculatedAmount = (0, utils_1.getShippingMethodsTotals)([method], {})[method.id];
-        const actions = data.items.map((item) => {
+        await this.orderService_.update(orderIds.map((id) => {
             return {
-                action: utils_2.ChangeActionType.RETURN_ITEM,
-                internal_note: item.internal_note,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                details: {
-                    reference_id: item.id,
-                    quantity: item.quantity,
-                    metadata: item.metadata,
-                },
+                id,
+                status: utils_1.OrderStatus.COMPLETED,
             };
-        });
-        if (shippingMethodId) {
-            actions.push({
-                action: utils_2.ChangeActionType.SHIPPING_ADD,
-                reference: data.reference,
-                reference_id: shippingMethodId,
-                amount: calculatedAmount.total,
-            });
+        }), sharedContext);
+        return Array.isArray(orderId) ? orders : orders[0];
+    }
+    async cancel(orderId, sharedContext) {
+        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
+        const orders = await this.listOrders({
+            id: orderIds,
+        }, {}, sharedContext);
+        const canceled_at = new Date();
+        for (const order of orders) {
+            order.status = utils_1.OrderStatus.CANCELED;
+            order.canceled_at = canceled_at;
         }
-        const change = await this.createOrderChange_({
-            order_id: data.order_id,
-            description: data.description,
-            internal_note: data.internal_note,
-            created_by: data.created_by,
-            metadata: data.metadata,
-            actions,
+        await this.orderService_.update(orderIds.map((id) => {
+            return {
+                id,
+                status: utils_1.OrderStatus.CANCELED,
+                canceled_at,
+            };
+        }), sharedContext);
+        return Array.isArray(orderId) ? orders : orders[0];
+    }
+    // ------------------- Bundled Order Actions
+    async createReturn(data, sharedContext) {
+        const ret = await BundledActions.createReturn.bind(this)(data, sharedContext);
+        return await this.retrieveReturn(ret.id, {
+            relations: [
+                "items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+            ],
+        }, sharedContext);
+    }
+    async receiveReturn(data, sharedContext) {
+        const ret = await this.receiveReturn_(data, sharedContext);
+        return await this.retrieveReturn(ret.id, {
+            relations: [
+                "items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+            ],
+        });
+    }
+    async receiveReturn_(data, sharedContext) {
+        return await BundledActions.receiveReturn.bind(this)(data, sharedContext);
+    }
+    async cancelReturn(data, sharedContext) {
+        const ret = await this.cancelReturn_(data, sharedContext);
+        return await this.retrieveReturn(ret.id, {
+            relations: [
+                "items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+            ],
+        });
+    }
+    async cancelReturn_(data, sharedContext) {
+        return await BundledActions.cancelReturn.bind(this)(data, sharedContext);
+    }
+    async createClaim(data, sharedContext) {
+        const ret = await this.createClaim_(data, sharedContext);
+        const claim = await this.retrieveOrderClaim(ret.id, {
+            relations: [
+                "additional_items",
+                "additional_items.item",
+                "claim_items",
+                "claim_items.item",
+                "return",
+                "return.items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+                "transactions",
+            ],
         }, sharedContext);
-        await this.confirmOrderChange(change[0].id, sharedContext);
+        return await this.baseRepository_.serialize(claim, {
+            populate: true,
+        });
+    }
+    async createClaim_(data, sharedContext) {
+        return await BundledActions.createClaim.bind(this)(data, sharedContext);
+    }
+    async cancelClaim(data, sharedContext) {
+        const ret = await this.cancelClaim_(data, sharedContext);
+        return await this.retrieveOrderClaim(ret.id, {
+            relations: ["items"],
+        });
+    }
+    async cancelClaim_(data, sharedContext) {
+        return await BundledActions.cancelClaim.bind(this)(data, sharedContext);
+    }
+    async createExchange(data, sharedContext) {
+        const ret = await this.createExchange_(data, sharedContext);
+        const claim = await this.retrieveOrderExchange(ret.id, {
+            relations: [
+                "additional_items",
+                "additional_items.item",
+                "return",
+                "return.items",
+                "shipping_methods",
+                "shipping_methods.tax_lines",
+                "shipping_methods.adjustments",
+                "transactions",
+            ],
+        }, sharedContext);
+        return await this.baseRepository_.serialize(claim, {
+            populate: true,
+        });
+    }
+    async createExchange_(data, sharedContext) {
+        return await BundledActions.createExchange.bind(this)(data, sharedContext);
+    }
+    async cancelExchange(data, sharedContext) {
+        const ret = await this.cancelExchange_(data, sharedContext);
+        return await this.retrieveOrderExchange(ret.id, {
+            relations: ["items"],
+        });
+    }
+    async cancelExchange_(data, sharedContext) {
+        return await BundledActions.cancelExchange.bind(this)(data, sharedContext);
+    }
+    async registerFulfillment(data, sharedContext) {
+        return await BundledActions.registerFulfillment.bind(this)(data, sharedContext);
+    }
+    async cancelFulfillment(data, sharedContext) {
+        return await BundledActions.cancelFulfillment.bind(this)(data, sharedContext);
+    }
+    async registerShipment(data, sharedContext) {
+        return await BundledActions.registerShipment.bind(this)(data, sharedContext);
     }
 }
 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);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "create", null);
+], OrderModuleService.prototype, "createOrders", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "create_", null);
+], OrderModuleService.prototype, "createOrders_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "update", null);
+], OrderModuleService.prototype, "updateOrders", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "update_", null);
+], OrderModuleService.prototype, "updateOrders_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1216,6 +1754,24 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createShippingMethodsBulk_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "softDeleteShippingMethods", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "restoreShippingMethods", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1272,44 +1828,84 @@ __decorate([
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "setShippingMethodTaxLines", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createReturns", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderClaims", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderExchanges", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createOrderRelatedEntity_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderChange", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createOrderChange_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "previewOrderChange", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "cancelOrderChange", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "confirmOrderChange", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "declineOrderChange", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "applyPendingOrderActions", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
@@ -1322,26 +1918,182 @@ __decorate([
 ], OrderModuleService.prototype, "revertLastChange_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __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.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addTransactions", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-ignore
+    ,
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "deleteTransactions", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "softDeleteTransactions", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "restoreTransactions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateOrderPaidRefundableAmount_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "registerFulfillment", null);
+], OrderModuleService.prototype, "archive", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "registerShipment", null);
+], OrderModuleService.prototype, "completeOrder", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __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)("baseRepository_"),
+    __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)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "receiveReturn", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "receiveReturn_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelReturn", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelReturn_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createClaim", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createClaim_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelClaim", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelClaim_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __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.InjectTransactionManager)("baseRepository_"),
+    __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)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelExchange", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelExchange_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "registerFulfillment", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "cancelFulfillment", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "registerShipment", null);
 //# sourceMappingURL=order-module-service.js.map