order-management 0.0.24 → 0.0.26

package/.medusa/server/src/workflows/steps/swap/create-medusa-exchange-step.js

@@ -4,8 +4,9 @@ exports.createMedusaExchangeStep = void 0;
 const utils_1 = require("@medusajs/framework/utils");
 const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
 const swap_1 = require("../../../modules/swap");
+const order_exchange_data_1 = require("../../../helpers/order-exchange-data");
 exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medusa-exchange", async (input, { container }) => {
-    const { swap_id, return_id, outbound_shipping_method_id, send_notification, new_items: inputNewItems } = input;
+    const { swap_id, return_id, outbound_shipping_method_id, shipping_option_id, send_notification, new_items: inputNewItems } = input;
     if (!swap_id) {
         throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "swap_id is required");
     }
@@ -22,6 +23,25 @@ exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medus
             swap,
         });
     }
+    // Get order_id from swap - required for exchange creation
+    const orderId = swapData.order_id;
+    if (!orderId) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Swap must have order_id to create exchange");
+    }
+    // CRITICAL: Ensure order shipping methods have names before creating exchange
+    // Medusa's createExchange copies shipping methods from the order, and they must have names
+    // This prevents the error: "Value for OrderShippingMethod.name is required, 'undefined' found"
+    try {
+        const shippingMethodsFixed = await (0, order_exchange_data_1.ensureOrderShippingMethodsHaveNames)(orderId, container);
+        if (!shippingMethodsFixed) {
+            console.warn(`[Create Medusa Exchange] Failed to ensure shipping methods have names for order ${orderId}. Exchange creation may fail if shipping methods don't have names.`);
+        }
+    }
+    catch (preCheckError) {
+        // Log but don't fail - we'll catch the actual error during exchange creation
+        const errorMessage = preCheckError instanceof Error ? preCheckError.message : String(preCheckError);
+        console.warn(`[Create Medusa Exchange] Error checking shipping methods before exchange creation: ${errorMessage}. Will attempt exchange creation anyway.`);
+    }
     // Use new_items from input if provided, otherwise use from swap model
     let newItems = [];
     if (inputNewItems && inputNewItems.length > 0) {
@@ -38,10 +58,60 @@ exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medus
     if (newItems.length === 0) {
         throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Swap must have new items to create exchange");
     }
+    // CRITICAL: Log order shipping methods before exchange creation
+    // This helps diagnose issues when Medusa's createExchange fails to copy shipping_option_id
+    try {
+        const remoteQuery = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+        const orderQuery = (0, utils_1.remoteQueryObjectFromString)({
+            entryPoint: "order",
+            fields: [
+                "id",
+                "shipping_methods.id",
+                "shipping_methods.name",
+                "shipping_methods.shipping_option_id",
+            ],
+            filters: {
+                id: [orderId],
+            },
+        });
+        const orders = await remoteQuery(orderQuery);
+        const orderArray = Array.isArray(orders) ? orders : orders ? [orders] : [];
+        const order = orderArray[0];
+        if (order?.shipping_methods && order.shipping_methods.length > 0) {
+            console.log(`[Create Medusa Exchange] Order ${orderId} shipping methods before exchange creation:`);
+            for (const method of order.shipping_methods) {
+                const hasName = Boolean(method.name && method.name.trim() !== "");
+                const hasShippingOptionId = Boolean(method.shipping_option_id && method.shipping_option_id.trim() !== "");
+                console.log(`  - Shipping method ${method.id}: ` +
+                    `name=${hasName ? `"${method.name}"` : "MISSING"}, ` +
+                    `shipping_option_id=${hasShippingOptionId ? method.shipping_option_id : "MISSING"}`);
+            }
+            // Check if all shipping methods have shipping_option_id
+            const methodsWithoutShippingOptionId = order.shipping_methods.filter((method) => !method.shipping_option_id || method.shipping_option_id.trim() === "");
+            if (methodsWithoutShippingOptionId.length === 0) {
+                console.log(`[Create Medusa Exchange] All shipping methods for order ${orderId} have shipping_option_id. ` +
+                    `However, Medusa's createExchange may still fail to copy shipping_option_id when creating exchange shipping methods. ` +
+                    `This is a known Medusa bug.`);
+            }
+            else {
+                console.warn(`[Create Medusa Exchange] Order ${orderId} has ${methodsWithoutShippingOptionId.length} shipping method(s) without shipping_option_id. ` +
+                    `Exchange creation will likely fail.`);
+            }
+        }
+        else {
+            console.log(`[Create Medusa Exchange] Order ${orderId} has no shipping methods. Exchange creation should proceed without shipping method issues.`);
+        }
+    }
+    catch (queryError) {
+        // Log but don't fail - we'll catch the actual error during exchange creation
+        const errorMessage = queryError instanceof Error ? queryError.message : String(queryError);
+        console.warn(`[Create Medusa Exchange] Error querying order shipping methods before exchange creation: ${errorMessage}. Will attempt exchange creation anyway.`);
+    }
     // Try to resolve Medusa's exchange workflow first (preferred method)
     // This ensures exchange follows Medusa's native workflow with automatic fulfillment creation
-    let exchangeId;
+    let exchangeId = "";
     let creationMethod = "service";
+    let exchangeCreated = false;
     try {
         // Try to resolve exchange workflow from container
         // Common workflow names: "createExchangeWorkflow", "exchange.create", etc.
@@ -78,6 +148,7 @@ exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medus
                 const { result } = await workflowInstance.run({
                     input: {
                         return_id,
+                        order_id: orderId,
                         items: newItems,
                     },
                 });
@@ -101,27 +172,374 @@ exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medus
         const errorMessage = workflowError instanceof Error ? workflowError.message : String(workflowError);
         console.log(`[Create Medusa Exchange] Workflow resolution/execution failed, falling back to service call: ${errorMessage}`);
         // Fallback to direct service call if workflow not available
+        // WORKAROUND: Try exchangeService first, which might allow passing shipping methods data
+        // This is a workaround for Medusa v2 bug where createExchange doesn't copy shipping_option_id
         try {
-            const orderService = container.resolve("order");
-            if (!orderService) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Order service is not available");
-            }
-            if (orderService.createExchange) {
-                const exchange = await orderService.createExchange({
-                    return_id,
-                    items: newItems,
+            // First, try to get order's shipping methods with shipping_option_id for potential patching
+            let orderShippingMethods = [];
+            try {
+                const remoteQuery = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+                const orderQuery = (0, utils_1.remoteQueryObjectFromString)({
+                    entryPoint: "order",
+                    fields: [
+                        "id",
+                        "shipping_methods.id",
+                        "shipping_methods.name",
+                        "shipping_methods.shipping_option_id",
+                    ],
+                    filters: {
+                        id: [orderId],
+                    },
                 });
-                exchangeId = exchange.id;
-                creationMethod = "service";
+                const orders = await remoteQuery(orderQuery);
+                const orderArray = Array.isArray(orders) ? orders : orders ? [orders] : [];
+                const order = orderArray[0];
+                if (order?.shipping_methods) {
+                    orderShippingMethods = order.shipping_methods;
+                    console.log(`[Create Medusa Exchange] Retrieved ${orderShippingMethods.length} shipping method(s) from order ${orderId} for potential patching`);
+                }
             }
-            else {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNKNOWN_MODULES, `Exchange creation is not available. Workflow error: ${errorMessage}. Order service createExchange method also not found.`);
+            catch (queryError) {
+                console.warn(`[Create Medusa Exchange] Failed to query order shipping methods for patching: ${queryError instanceof Error ? queryError.message : String(queryError)}`);
+            }
+            // CRITICAL: If shipping_option_id is provided, we need to create exchange WITHOUT shipping methods
+            // Then manually add the shipping method after creation to avoid Medusa's bug
+            // Try exchangeService first (might allow passing empty shipping methods)
+            exchangeCreated = false;
+            try {
+                const exchangeService = container.resolve("exchange");
+                if (exchangeService?.createExchange) {
+                    const exchangeData = {
+                        return_id,
+                        order_id: orderId,
+                        items: newItems,
+                    };
+                    // If shipping_option_id is provided, try to pass the shipping method with the correct shipping_option_id
+                    // This might prevent Medusa from copying from order
+                    if (shipping_option_id) {
+                        // Fetch shipping option name first
+                        const remoteQueryForOption = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+                        const shippingOptionQuery = (0, utils_1.remoteQueryObjectFromString)({
+                            entryPoint: "shipping_option",
+                            fields: ["id", "name"],
+                            filters: {
+                                id: [shipping_option_id],
+                            },
+                        });
+                        const shippingOptions = await remoteQueryForOption(shippingOptionQuery);
+                        const optionsArray = Array.isArray(shippingOptions)
+                            ? shippingOptions
+                            : shippingOptions
+                                ? [shippingOptions]
+                                : [];
+                        const shippingOption = optionsArray[0];
+                        if (shippingOption) {
+                            // Try passing the shipping method with correct shipping_option_id
+                            exchangeData.shipping_methods = [{
+                                    shipping_option_id: shipping_option_id,
+                                    name: shippingOption.name || "Shipping",
+                                }];
+                            console.log(`[Create Medusa Exchange] shipping_option_id provided (${shipping_option_id}), creating exchange with shipping method: ${shippingOption.name}`);
+                        }
+                        else {
+                            // Fallback to empty array if shipping option not found
+                            exchangeData.shipping_methods = [];
+                            console.log(`[Create Medusa Exchange] shipping_option_id provided (${shipping_option_id}) but shipping option not found, using empty shipping_methods`);
+                        }
+                    }
+                    else if (orderShippingMethods.length > 0) {
+                        // Only use order shipping methods if shipping_option_id not provided
+                        exchangeData.shipping_methods = orderShippingMethods.map((sm) => ({
+                            shipping_option_id: sm.shipping_option_id,
+                            name: sm.name,
+                        }));
+                        console.log(`[Create Medusa Exchange] Attempting to patch exchange creation with shipping methods containing shipping_option_id`);
+                    }
+                    const exchange = await exchangeService.createExchange(exchangeData);
+                    exchangeId = exchange.id;
+                    creationMethod = "service";
+                    exchangeCreated = true;
+                    console.log(`[Create Medusa Exchange] Successfully created exchange ${exchangeId} using exchangeService`);
+                }
+            }
+            catch (exchangeServiceError) {
+                // Exchange service not available or failed, check if it's the shipping method error
+                const errorMsg = exchangeServiceError instanceof Error ? exchangeServiceError.message : String(exchangeServiceError);
+                // If it's the shipping method error and we have shipping_option_id, try to recover
+                if ((errorMsg.includes("OrderShippingMethod.name is required") ||
+                    errorMsg.includes("name is required") ||
+                    errorMsg.includes("'undefined' found") ||
+                    errorMsg.includes("shipping_option_id: null")) &&
+                    shipping_option_id) {
+                    console.log(`[Create Medusa Exchange] Exchange service failed with shipping method error, attempting recovery with shipping_option_id ${shipping_option_id}...`);
+                    // Don't fall through to orderService - let the outer catch handle recovery
+                    throw exchangeServiceError;
+                }
+                console.log(`[Create Medusa Exchange] Exchange service not available or failed: ${errorMsg}. Falling back to orderService.`);
+            }
+            // If exchangeService didn't work, try orderService
+            // BUT: If shipping_option_id is provided, orderService will also fail with the same bug
+            // So we should skip orderService and go straight to error recovery
+            if (!exchangeCreated) {
+                if (shipping_option_id) {
+                    console.log(`[Create Medusa Exchange] shipping_option_id provided but exchangeService failed. ` +
+                        `Skipping orderService (will have same bug) and going to error recovery...`);
+                    // Throw an error to trigger the outer catch block for recovery
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Exchange service failed. Will attempt recovery with shipping_option_id.");
+                }
+                const orderService = container.resolve("order");
+                if (!orderService) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Order service is not available");
+                }
+                if (orderService.createExchange) {
+                    const exchange = await orderService.createExchange({
+                        return_id,
+                        order_id: orderId,
+                        items: newItems,
+                    });
+                    exchangeId = exchange.id;
+                    creationMethod = "service";
+                }
+                else {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNKNOWN_MODULES, `Exchange creation is not available. Workflow error: ${errorMessage}. Order service createExchange method also not found.`);
+                }
             }
         }
         catch (serviceError) {
-            // If service call also fails, throw with both errors
+            // If service call also fails, check if it's a shipping method name error
             const serviceErrorMessage = serviceError instanceof Error ? serviceError.message : String(serviceError);
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNKNOWN_MODULES, `Failed to create exchange via workflow and service: Workflow error: ${errorMessage}, Service error: ${serviceErrorMessage}`);
+            // Check if error is related to missing shipping method name
+            // This error occurs when Medusa's createExchange creates shipping methods with shipping_option_id: null
+            // If we have shipping_option_id, try to find and fix the partially created exchange
+            if ((serviceErrorMessage.includes("OrderShippingMethod.name is required") ||
+                serviceErrorMessage.includes("name is required") ||
+                serviceErrorMessage.includes("'undefined' found") ||
+                serviceErrorMessage.includes("shipping_option_id: null")) &&
+                shipping_option_id) {
+                console.log(`[Create Medusa Exchange] Exchange creation failed due to shipping method bug, but shipping_option_id provided (${shipping_option_id}). ` +
+                    `Attempting to find and fix partially created exchange for return_id: ${return_id}...`);
+                try {
+                    // Try to find the exchange that might have been created
+                    const remoteQuery = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+                    // Try multiple queries to find the exchange
+                    let foundExchange = null;
+                    // Query 1: By return_id
+                    try {
+                        const exchangeQuery = (0, utils_1.remoteQueryObjectFromString)({
+                            entryPoint: "exchange",
+                            fields: ["id", "return_id"],
+                            filters: {
+                                return_id: [return_id],
+                            },
+                        });
+                        const exchanges = await remoteQuery(exchangeQuery);
+                        const exchangeArray = Array.isArray(exchanges) ? exchanges : exchanges ? [exchanges] : [];
+                        foundExchange = exchangeArray[0];
+                        if (foundExchange?.id) {
+                            console.log(`[Create Medusa Exchange] Found exchange ${foundExchange.id} by return_id ${return_id}`);
+                        }
+                        else {
+                            console.log(`[Create Medusa Exchange] No exchange found by return_id ${return_id}, trying by order_id...`);
+                            // Query 2: By order_id (might be created but not linked to return yet)
+                            const exchangeByOrderQuery = (0, utils_1.remoteQueryObjectFromString)({
+                                entryPoint: "exchange",
+                                fields: ["id", "order_id", "return_id"],
+                                filters: {
+                                    order_id: [orderId],
+                                },
+                            });
+                            const exchangesByOrder = await remoteQuery(exchangeByOrderQuery);
+                            const orderExchangeArray = Array.isArray(exchangesByOrder)
+                                ? exchangesByOrder
+                                : exchangesByOrder
+                                    ? [exchangesByOrder]
+                                    : [];
+                            // Find the most recent exchange for this order (likely the one just created)
+                            foundExchange = orderExchangeArray[orderExchangeArray.length - 1];
+                            if (foundExchange?.id) {
+                                console.log(`[Create Medusa Exchange] Found exchange ${foundExchange.id} by order_id ${orderId}`);
+                            }
+                        }
+                    }
+                    catch (queryError) {
+                        console.error(`[Create Medusa Exchange] Error querying for exchange: ${queryError instanceof Error ? queryError.message : String(queryError)}`);
+                    }
+                    if (foundExchange?.id) {
+                        console.log(`[Create Medusa Exchange] Found partially created exchange ${foundExchange.id}, attempting to fix shipping methods...`);
+                        exchangeId = foundExchange.id;
+                        // Query exchange to get its shipping methods
+                        const exchangeDetailQuery = (0, utils_1.remoteQueryObjectFromString)({
+                            entryPoint: "exchange",
+                            fields: [
+                                "id",
+                                "shipping_methods.id",
+                                "shipping_methods.shipping_option_id",
+                            ],
+                            filters: {
+                                id: [exchangeId],
+                            },
+                        });
+                        const exchangeDetails = await remoteQuery(exchangeDetailQuery);
+                        const exchangeDetailArray = Array.isArray(exchangeDetails)
+                            ? exchangeDetails
+                            : exchangeDetails
+                                ? [exchangeDetails]
+                                : [];
+                        const exchangeDetail = exchangeDetailArray[0];
+                        // Try to remove bad shipping methods (with null shipping_option_id)
+                        if (exchangeDetail?.shipping_methods) {
+                            const badMethods = exchangeDetail.shipping_methods.filter((sm) => !sm.shipping_option_id || sm.shipping_option_id.trim() === "");
+                            if (badMethods.length > 0) {
+                                console.log(`[Create Medusa Exchange] Found ${badMethods.length} shipping method(s) with null shipping_option_id, attempting to remove them...`);
+                                const exchangeService = container.resolve("exchange");
+                                if (exchangeService?.removeShippingMethod) {
+                                    for (const badMethod of badMethods) {
+                                        try {
+                                            await exchangeService.removeShippingMethod({
+                                                exchange_id: exchangeId,
+                                                shipping_method_id: badMethod.id,
+                                            });
+                                            console.log(`[Create Medusa Exchange] Removed bad shipping method ${badMethod.id} from exchange ${exchangeId}`);
+                                        }
+                                        catch (removeError) {
+                                            console.warn(`[Create Medusa Exchange] Failed to remove shipping method ${badMethod.id}: ${removeError instanceof Error ? removeError.message : String(removeError)}`);
+                                        }
+                                    }
+                                }
+                                else {
+                                    console.warn(`[Create Medusa Exchange] Exchange service removeShippingMethod not available. Bad shipping methods may remain.`);
+                                }
+                            }
+                        }
+                        // Now try to add the correct shipping method
+                        const remoteQueryForOption = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+                        const shippingOptionQuery = (0, utils_1.remoteQueryObjectFromString)({
+                            entryPoint: "shipping_option",
+                            fields: ["id", "name"],
+                            filters: {
+                                id: [shipping_option_id],
+                            },
+                        });
+                        const shippingOptions = await remoteQueryForOption(shippingOptionQuery);
+                        const optionsArray = Array.isArray(shippingOptions)
+                            ? shippingOptions
+                            : shippingOptions
+                                ? [shippingOptions]
+                                : [];
+                        const shippingOption = optionsArray[0];
+                        if (shippingOption) {
+                            const exchangeService = container.resolve("exchange");
+                            if (exchangeService?.addShippingMethod) {
+                                await exchangeService.addShippingMethod({
+                                    exchange_id: exchangeId,
+                                    shipping_option_id: shipping_option_id,
+                                    name: shippingOption.name || "Shipping",
+                                    data: {},
+                                });
+                                console.log(`[Create Medusa Exchange] Successfully fixed exchange ${exchangeId} by adding shipping method with shipping_option_id ${shipping_option_id}`);
+                                creationMethod = "service_fixed";
+                                exchangeCreated = true;
+                            }
+                            else {
+                                console.warn(`[Create Medusa Exchange] Exchange service addShippingMethod not available. Cannot add correct shipping method.`);
+                            }
+                        }
+                        else {
+                            console.warn(`[Create Medusa Exchange] Shipping option ${shipping_option_id} not found. Cannot add shipping method.`);
+                        }
+                    }
+                    else {
+                        console.warn(`[Create Medusa Exchange] Could not find exchange for return_id ${return_id}. Exchange may not have been created.`);
+                    }
+                }
+                catch (fixError) {
+                    const fixErrorMsg = fixError instanceof Error ? fixError.message : String(fixError);
+                    console.error(`[Create Medusa Exchange] Failed to fix partially created exchange: ${fixErrorMsg}`);
+                }
+            }
+            // If we still don't have an exchange, throw the error
+            if (!exchangeCreated) {
+                if (serviceErrorMessage.includes("OrderShippingMethod.name is required") ||
+                    serviceErrorMessage.includes("name is required") ||
+                    serviceErrorMessage.includes("'undefined' found") ||
+                    serviceErrorMessage.includes("shipping_option_id: null")) {
+                    // Provide a more helpful error message explaining this is a Medusa bug
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to create exchange: Medusa's createExchange is creating shipping methods with shipping_option_id: null, ` +
+                        `which causes the name to be undefined. This is a known Medusa bug where createExchange doesn't properly copy ` +
+                        `shipping_option_id from the order's shipping methods when creating exchange shipping methods. ` +
+                        `The order's shipping methods have shipping_option_id, but Medusa isn't copying it. ` +
+                        `Order ID: ${orderId}. ` +
+                        `Original error: ${serviceErrorMessage}`);
+                }
+                // For other errors, throw with both workflow and service errors
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNKNOWN_MODULES, `Failed to create exchange via workflow and service: Workflow error: ${errorMessage}, Service error: ${serviceErrorMessage}`);
+            }
+        }
+    }
+    // Ensure exchangeId was set (should always be set if we reach here, but TypeScript needs this check)
+    if (!exchangeId || exchangeId.trim() === "") {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNKNOWN_MODULES, `Failed to create exchange: Exchange ID was not set after creation attempt. This should not happen.`);
+    }
+    // CRITICAL: If shipping_option_id is provided (selected by admin), manually add shipping method
+    // This works around Medusa's bug where createExchange doesn't copy shipping_option_id properly
+    // Only add if we didn't already fix it during error handling above
+    if (shipping_option_id && creationMethod !== "service_fixed") {
+        try {
+            const remoteQuery = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+            // Fetch shipping option details to get the name
+            const shippingOptionQuery = (0, utils_1.remoteQueryObjectFromString)({
+                entryPoint: "shipping_option",
+                fields: [
+                    "id",
+                    "name",
+                ],
+                filters: {
+                    id: [shipping_option_id],
+                },
+            });
+            const shippingOptions = await remoteQuery(shippingOptionQuery);
+            const optionsArray = Array.isArray(shippingOptions)
+                ? shippingOptions
+                : shippingOptions
+                    ? [shippingOptions]
+                    : [];
+            const shippingOption = optionsArray[0];
+            if (!shippingOption) {
+                console.warn(`[Create Medusa Exchange] Shipping option ${shipping_option_id} not found. Skipping manual shipping method addition.`);
+            }
+            else {
+                // Try to add shipping method using exchangeService
+                const exchangeService = container.resolve("exchange");
+                if (exchangeService?.addShippingMethod) {
+                    try {
+                        // Attempt to add shipping method with shipping_option_id
+                        // This should properly set the shipping_option_id and name
+                        await exchangeService.addShippingMethod({
+                            exchange_id: exchangeId,
+                            shipping_option_id: shipping_option_id,
+                            name: shippingOption.name || "Shipping",
+                            data: {},
+                        });
+                        console.log(`[Create Medusa Exchange] Successfully added shipping method with shipping_option_id "${shipping_option_id}" (name: "${shippingOption.name || "Shipping"}") to exchange ${exchangeId}`);
+                    }
+                    catch (addError) {
+                        // Log but don't fail - exchange was created successfully
+                        const errorMessage = addError instanceof Error ? addError.message : String(addError);
+                        console.warn(`[Create Medusa Exchange] Failed to add shipping method with shipping_option_id ${shipping_option_id} to exchange ${exchangeId}: ${errorMessage}. ` +
+                            `Exchange was created but shipping method may need to be added manually via admin UI.`);
+                    }
+                }
+                else {
+                    console.warn(`[Create Medusa Exchange] Exchange service addShippingMethod method not available. ` +
+                        `Shipping method with shipping_option_id ${shipping_option_id} should be added manually via admin UI.`);
+                }
+            }
+        }
+        catch (error) {
+            // Log but don't fail - exchange was created successfully
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`[Create Medusa Exchange] Error adding shipping method with shipping_option_id ${shipping_option_id}: ${errorMessage}. ` +
+                `Exchange was created but shipping method may need to be added manually via admin UI.`);
         }
     }
     // Use swap's outbound_shipping_method_id as fallback if not provided in input
@@ -132,18 +550,44 @@ exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medus
     // depending on Medusa v2 API structure
     if (finalOutboundShippingMethodId) {
         try {
-            const exchangeService = container.resolve("exchange");
-            if (exchangeService?.addShippingMethod) {
-                await exchangeService.addShippingMethod({
-                    exchange_id: exchangeId,
-                    shipping_method_id: finalOutboundShippingMethodId,
-                });
+            // Fetch shipping method details (including name) from the order
+            // The name field is required for OrderShippingMethod entity
+            const shippingMethodData = await (0, order_exchange_data_1.getShippingMethodFromOrder)(orderId, finalOutboundShippingMethodId, container);
+            if (!shippingMethodData) {
+                console.warn(`[Create Medusa Exchange] Shipping method ${finalOutboundShippingMethodId} not found in order ${orderId}. Skipping shipping method addition.`);
+            }
+            else if (!shippingMethodData.name) {
+                console.warn(`[Create Medusa Exchange] Shipping method ${finalOutboundShippingMethodId} has no name field. Skipping shipping method addition to avoid validation error.`);
+            }
+            else {
+                // Shipping method found with name - proceed with addition
+                const exchangeService = container.resolve("exchange");
+                if (exchangeService?.addShippingMethod) {
+                    try {
+                        await exchangeService.addShippingMethod({
+                            exchange_id: exchangeId,
+                            shipping_method_id: finalOutboundShippingMethodId,
+                            name: shippingMethodData.name,
+                        });
+                        console.log(`[Create Medusa Exchange] Successfully added shipping method "${shippingMethodData.name}" (${finalOutboundShippingMethodId}) to exchange ${exchangeId}`);
+                    }
+                    catch (addError) {
+                        // Log but don't fail if shipping method addition fails
+                        // Shipping method can be added manually via admin UI if needed
+                        const errorMessage = addError instanceof Error ? addError.message : String(addError);
+                        console.warn(`[Create Medusa Exchange] Failed to add outbound shipping method ${finalOutboundShippingMethodId} to exchange ${exchangeId}: ${errorMessage}`);
+                    }
+                }
+                else {
+                    console.warn("[Create Medusa Exchange] Exchange service addShippingMethod method not available. Shipping method can be added manually via admin UI.");
+                }
             }
         }
         catch (error) {
-            // Log but don't fail if shipping method addition fails
+            // Log but don't fail if shipping method lookup or addition fails
             // Shipping method can be added manually via admin UI if needed
-            console.warn("[Create Medusa Exchange] Failed to add outbound shipping method:", error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`[Create Medusa Exchange] Error processing shipping method ${finalOutboundShippingMethodId}: ${errorMessage}. Shipping method can be added manually via admin UI.`);
         }
     }
     // Send notification if requested
@@ -217,4 +661,4 @@ exports.createMedusaExchangeStep = (0, workflows_sdk_1.createStep)("create-medus
         swap: finalSwap || swap,
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-medusa-exchange-step.js","sourceRoot":"","sources":["../../../../../../src/workflows/steps/swap/create-medusa-exchange-step.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-medusa-exchange-step.js","sourceRoot":"","sources":["../../../../../../src/workflows/steps/swap/create-medusa-exchange-step.ts"],"names":[],"mappings":";;;AAAA,qDAA+G;AAC/G,qEAA4E;AAE5E,gDAAmD;AAGnD,8EAAsH;AAgBzG,QAAA,wBAAwB,GAAG,IAAA,0BAAU,EAChD,wBAAwB,EACxB,KAAK,EACH,KAAoC,EACpC,EAAE,SAAS,EAAE,EAC0C,EAAE;IACzD,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,KAAK,CAAA;IAElI,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,qBAAqB,CACtB,CAAA;IACH,CAAC;IAED,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,0CAA0C,CAC3C,CAAA;IACH,CAAC;IAED,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CAAc,kBAAW,CAAC,CAAA;IAC/D,MAAM,IAAI,GAAG,MAAM,WAAW,CAAC,YAAY,CAAC,OAAO,CAAC,CAAA;IACpD,MAAM,QAAQ,GAAG,IAKN,CAAA;IAEX,IAAK,QAAqC,CAAC,WAAW,EAAE,CAAC;QACvD,2BAA2B;QAC3B,OAAO,IAAI,4BAAY,CAAiC;YACtD,WAAW,EAAG,QAAqC,CAAC,WAAW,IAAI,EAAE;YACrE,IAAI;SACL,CAAC,CAAA;IACJ,CAAC;IAED,0DAA0D;IAC1D,MAAM,OAAO,GAAI,QAAkC,CAAC,QAAQ,CAAA;IAC5D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,4CAA4C,CAC7C,CAAA;IACH,CAAC;IAED,8EAA8E;IAC9E,2FAA2F;IAC3F,+FAA+F;IAC/F,IAAI,CAAC;QACH,MAAM,oBAAoB,GAAG,MAAM,IAAA,yDAAmC,EAAC,OAAO,EAAE,SAAS,CAAC,CAAA;QAC1F,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC1B,OAAO,CAAC,IAAI,CACV,mFAAmF,OAAO,oEAAoE,CAC/J,CAAA;QACH,CAAC;IACH,CAAC;IAAC,OAAO,aAAa,EAAE,CAAC;QACvB,6EAA6E;QAC7E,MAAM,YAAY,GAAG,aAAa,YAAY,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAA;QACnG,OAAO,CAAC,IAAI,CACV,sFAAsF,YAAY,0CAA0C,CAC7I,CAAA;IACH,CAAC;IAED,sEAAsE;IACtE,IAAI,QAAQ,GAAoD,EAAE,CAAA;IAElE,IAAI,aAAa,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9C,4CAA4C;QAC5C,QAAQ,GAAG,aAAa,CAAA;IAC1B,CAAC;SAAM,CAAC;QACN,4BAA4B;QAC5B,MAAM,YAAY,GAAI,QAA4E,CAAC,SAAS,IAAI,EAAE,CAAA;QAClH,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;YAChC,QAAQ,GAAG,YAAY,CAAA;QACzB,CAAC;IACH,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,6CAA6C,CAC9C,CAAA;IACH,CAAC;IAED,gEAAgE;IAChE,2FAA2F;IAC3F,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CACnC,iCAAyB,CAAC,YAAY,CACvC,CAAA;QAED,MAAM,UAAU,GAAG,IAAA,mCAA2B,EAAC;YAC7C,UAAU,EAAE,OAAO;YACnB,MAAM,EAAE;gBACN,IAAI;gBACJ,qBAAqB;gBACrB,uBAAuB;gBACvB,qCAAqC;aACtC;YACD,OAAO,EAAE;gBACP,EAAE,EAAE,CAAC,OAAO,CAAC;aACd;SACF,CAAC,CAAA;QAEF,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,CAAA;QAC5C,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAC1E,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAMlB,CAAA;QAER,IAAI,KAAK,EAAE,gBAAgB,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjE,OAAO,CAAC,GAAG,CACT,kCAAkC,OAAO,6CAA6C,CACvF,CAAA;YACD,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,gBAAgB,EAAE,CAAC;gBAC5C,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;gBACjE,MAAM,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,IAAI,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;gBACzG,OAAO,CAAC,GAAG,CACT,uBAAuB,MAAM,CAAC,EAAE,IAAI;oBACpC,QAAQ,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,SAAS,IAAI;oBACpD,sBAAsB,mBAAmB,CAAC,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,EAAE,CACpF,CAAA;YACH,CAAC;YAED,wDAAwD;YACxD,MAAM,8BAA8B,GAAG,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAClE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,IAAI,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,CAClF,CAAA;YAED,IAAI,8BAA8B,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAChD,OAAO,CAAC,GAAG,CACT,2DAA2D,OAAO,4BAA4B;oBAC9F,sHAAsH;oBACtH,6BAA6B,CAC9B,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,IAAI,CACV,kCAAkC,OAAO,QAAQ,8BAA8B,CAAC,MAAM,kDAAkD;oBACxI,qCAAqC,CACtC,CAAA;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CACT,kCAAkC,OAAO,4FAA4F,CACtI,CAAA;QACH,CAAC;IACH,CAAC;IAAC,OAAO,UAAU,EAAE,CAAC;QACpB,6EAA6E;QAC7E,MAAM,YAAY,GAAG,UAAU,YAAY,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAC1F,OAAO,CAAC,IAAI,CACV,4FAA4F,YAAY,0CAA0C,CACnJ,CAAA;IACH,CAAC;IAED,qEAAqE;IACrE,6FAA6F;IAC7F,IAAI,UAAU,GAAW,EAAE,CAAA;IAC3B,IAAI,cAAc,GAA6C,SAAS,CAAA;IACxE,IAAI,eAAe,GAAG,KAAK,CAAA;IAE3B,IAAI,CAAC;QACH,kDAAkD;QAClD,2EAA2E;QAC3E,gGAAgG;QAChG,MAAM,qBAAqB,GAAG;YAC5B,wBAAwB;YACxB,iBAAiB;YACjB,gBAAgB;SACjB,CAAA;QAYD,IAAI,gBAAgB,GAA4B,IAAI,CAAA;QAEpD,KAAK,MAAM,YAAY,IAAI,qBAAqB,EAAE,CAAC;YACjD,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,CAAU,YAAY,CAAC,CAAA;gBACzD,IAAI,QAAQ,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;oBAC/C,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAA;oBACpC,IACE,QAAQ;wBACR,OAAO,QAAQ,KAAK,QAAQ;wBAC5B,KAAK,IAAI,QAAQ;wBACjB,OAAQ,QAA8B,CAAC,GAAG,KAAK,UAAU,EACzD,CAAC;wBACD,gBAAgB,GAAG,QAA4B,CAAA;wBAC/C,MAAK;oBACP,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,8DAA8D;gBAC9D,SAAQ;YACV,CAAC;QACH,CAAC;QAED,IAAI,gBAAgB,EAAE,CAAC;YACrB,+EAA+E;YAC/E,mDAAmD;YACnD,IAAI,CAAC;gBACH,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC,GAAG,CAAC;oBAC5C,KAAK,EAAE;wBACL,SAAS;wBACT,QAAQ,EAAE,OAAO;wBACjB,KAAK,EAAE,QAAQ;qBAChB;iBACF,CAAC,CAAA;gBAEF,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;oBACvD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAA;gBAC3E,CAAC;gBAED,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;gBAC/B,cAAc,GAAG,UAAU,CAAA;YAC7B,CAAC;YAAC,OAAO,cAAc,EAAE,CAAC;gBACxB,mEAAmE;gBACnE,MAAM,cAAc,CAAA;YACtB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAA;QAChD,CAAC;IACH,CAAC;IAAC,OAAO,aAAa,EAAE,CAAC;QACvB,kEAAkE;QAClE,MAAM,YAAY,GAAG,aAAa,YAAY,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAA;QACnG,OAAO,CAAC,GAAG,CACT,gGAAgG,YAAY,EAAE,CAC/G,CAAA;QAED,4DAA4D;QAC5D,yFAAyF;QACzF,8FAA8F;QAC9F,IAAI,CAAC;YACH,4FAA4F;YAC5F,IAAI,oBAAoB,GAAsE,EAAE,CAAA;YAChG,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CACnC,iCAAyB,CAAC,YAAY,CACvC,CAAA;gBACD,MAAM,UAAU,GAAG,IAAA,mCAA2B,EAAC;oBAC7C,UAAU,EAAE,OAAO;oBACnB,MAAM,EAAE;wBACN,IAAI;wBACJ,qBAAqB;wBACrB,uBAAuB;wBACvB,qCAAqC;qBACtC;oBACD,OAAO,EAAE;wBACP,EAAE,EAAE,CAAC,OAAO,CAAC;qBACd;iBACF,CAAC,CAAA;gBACF,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,CAAA;gBAC5C,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;gBAC1E,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAMlB,CAAA;gBACR,IAAI,KAAK,EAAE,gBAAgB,EAAE,CAAC;oBAC5B,oBAAoB,GAAG,KAAK,CAAC,gBAAgB,CAAA;oBAC7C,OAAO,CAAC,GAAG,CACT,sCAAsC,oBAAoB,CAAC,MAAM,kCAAkC,OAAO,yBAAyB,CACpI,CAAA;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,UAAU,EAAE,CAAC;gBACpB,OAAO,CAAC,IAAI,CACV,iFAAiF,UAAU,YAAY,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CACzJ,CAAA;YACH,CAAC;YAED,mGAAmG;YACnG,6EAA6E;YAC7E,yEAAyE;YACzE,eAAe,GAAG,KAAK,CAAA;YACvB,IAAI,CAAC;gBACH,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,CAOtC,UAAU,CAAC,CAAA;gBAEd,IAAI,eAAe,EAAE,cAAc,EAAE,CAAC;oBACpC,MAAM,YAAY,GAKd;wBACF,SAAS;wBACT,QAAQ,EAAE,OAAO;wBACjB,KAAK,EAAE,QAAQ;qBAChB,CAAA;oBAED,yGAAyG;oBACzG,oDAAoD;oBACpD,IAAI,kBAAkB,EAAE,CAAC;wBACvB,mCAAmC;wBACnC,MAAM,oBAAoB,GAAG,SAAS,CAAC,OAAO,CAC5C,iCAAyB,CAAC,YAAY,CACvC,CAAA;wBACD,MAAM,mBAAmB,GAAG,IAAA,mCAA2B,EAAC;4BACtD,UAAU,EAAE,iBAAiB;4BAC7B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC;4BACtB,OAAO,EAAE;gCACP,EAAE,EAAE,CAAC,kBAAkB,CAAC;6BACzB;yBACF,CAAC,CAAA;wBAEF,MAAM,eAAe,GAAG,MAAM,oBAAoB,CAAC,mBAAmB,CAAC,CAAA;wBACvE,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC;4BACjD,CAAC,CAAC,eAAe;4BACjB,CAAC,CAAC,eAAe;gCACjB,CAAC,CAAC,CAAC,eAAe,CAAC;gCACnB,CAAC,CAAC,EAAE,CAAA;wBACN,MAAM,cAAc,GAAG,YAAY,CAAC,CAAC,CAA8C,CAAA;wBAEnF,IAAI,cAAc,EAAE,CAAC;4BACnB,kEAAkE;4BAClE,YAAY,CAAC,gBAAgB,GAAG,CAAC;oCAC/B,kBAAkB,EAAE,kBAAkB;oCACtC,IAAI,EAAE,cAAc,CAAC,IAAI,IAAI,UAAU;iCACxC,CAAC,CAAA;4BACF,OAAO,CAAC,GAAG,CACT,yDAAyD,kBAAkB,8CAA8C,cAAc,CAAC,IAAI,EAAE,CAC/I,CAAA;wBACH,CAAC;6BAAM,CAAC;4BACN,uDAAuD;4BACvD,YAAY,CAAC,gBAAgB,GAAG,EAAE,CAAA;4BAClC,OAAO,CAAC,GAAG,CACT,yDAAyD,kBAAkB,+DAA+D,CAC3I,CAAA;wBACH,CAAC;oBACH,CAAC;yBAAM,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC3C,qEAAqE;wBACrE,YAAY,CAAC,gBAAgB,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;4BAChE,kBAAkB,EAAE,EAAE,CAAC,kBAAkB;4BACzC,IAAI,EAAE,EAAE,CAAC,IAAI;yBACd,CAAC,CAAC,CAAA;wBACH,OAAO,CAAC,GAAG,CACT,oHAAoH,CACrH,CAAA;oBACH,CAAC;oBAED,MAAM,QAAQ,GAAG,MAAM,eAAe,CAAC,cAAc,CAAC,YAAY,CAAC,CAAA;oBACnE,UAAU,GAAG,QAAQ,CAAC,EAAE,CAAA;oBACxB,cAAc,GAAG,SAAS,CAAA;oBAC1B,eAAe,GAAG,IAAI,CAAA;oBACtB,OAAO,CAAC,GAAG,CACT,0DAA0D,UAAU,wBAAwB,CAC7F,CAAA;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,oBAAoB,EAAE,CAAC;gBAC9B,oFAAoF;gBACpF,MAAM,QAAQ,GAAG,oBAAoB,YAAY,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAA;gBAEpH,mFAAmF;gBACnF,IACE,CAAC,QAAQ,CAAC,QAAQ,CAAC,sCAAsC,CAAC;oBAC1D,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,CAAC;oBACrC,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC;oBACtC,QAAQ,CAAC,QAAQ,CAAC,0BAA0B,CAAC,CAAC;oBAC9C,kBAAkB,EAClB,CAAC;oBACD,OAAO,CAAC,GAAG,CACT,4HAA4H,kBAAkB,KAAK,CACpJ,CAAA;oBACD,2EAA2E;oBAC3E,MAAM,oBAAoB,CAAA;gBAC5B,CAAC;gBAED,OAAO,CAAC,GAAG,CACT,sEAAsE,QAAQ,iCAAiC,CAChH,CAAA;YACH,CAAC;YAED,mDAAmD;YACnD,wFAAwF;YACxF,mEAAmE;YACnE,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,IAAI,kBAAkB,EAAE,CAAC;oBACvB,OAAO,CAAC,GAAG,CACT,mFAAmF;wBACnF,2EAA2E,CAC5E,CAAA;oBACD,+DAA+D;oBAC/D,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,yEAAyE,CAC1E,CAAA;gBACH,CAAC;gBAED,MAAM,YAAY,GAAG,SAAS,CAAC,OAAO,CAMnC,OAAO,CAAC,CAAA;gBAEX,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,gCAAgC,CACjC,CAAA;gBACH,CAAC;gBAED,IAAI,YAAY,CAAC,cAAc,EAAE,CAAC;oBAChC,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,cAAc,CAAC;wBACjD,SAAS;wBACT,QAAQ,EAAE,OAAO;wBACjB,KAAK,EAAE,QAAQ;qBAChB,CAAC,CAAA;oBAEF,UAAU,GAAG,QAAQ,CAAC,EAAE,CAAA;oBACxB,cAAc,GAAG,SAAS,CAAA;gBAC5B,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,eAAe,EACjC,uDAAuD,YAAY,uDAAuD,CAC3H,CAAA;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,YAAY,EAAE,CAAC;YACtB,yEAAyE;YACzE,MAAM,mBAAmB,GAAG,YAAY,YAAY,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;YAEvG,4DAA4D;YAC5D,wGAAwG;YACxG,oFAAoF;YACpF,IACE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,sCAAsC,CAAC;gBACrE,mBAAmB,CAAC,QAAQ,CAAC,kBAAkB,CAAC;gBAChD,mBAAmB,CAAC,QAAQ,CAAC,mBAAmB,CAAC;gBACjD,mBAAmB,CAAC,QAAQ,CAAC,0BAA0B,CAAC,CAAC;gBACzD,kBAAkB,EAClB,CAAC;gBACD,OAAO,CAAC,GAAG,CACT,kHAAkH,kBAAkB,KAAK;oBACzI,wEAAwE,SAAS,KAAK,CACvF,CAAA;gBAED,IAAI,CAAC;oBACH,wDAAwD;oBACxD,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CACnC,iCAAyB,CAAC,YAAY,CACvC,CAAA;oBAED,4CAA4C;oBAC5C,IAAI,aAAa,GAA2B,IAAI,CAAA;oBAEhD,wBAAwB;oBACxB,IAAI,CAAC;wBACH,MAAM,aAAa,GAAG,IAAA,mCAA2B,EAAC;4BAChD,UAAU,EAAE,UAAU;4BACtB,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC;4BAC3B,OAAO,EAAE;gCACP,SAAS,EAAE,CAAC,SAAS,CAAC;6BACvB;yBACF,CAAC,CAAA;wBAEF,MAAM,SAAS,GAAG,MAAM,WAAW,CAAC,aAAa,CAAC,CAAA;wBAClD,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;wBACzF,aAAa,GAAG,aAAa,CAAC,CAAC,CAA2B,CAAA;wBAE1D,IAAI,aAAa,EAAE,EAAE,EAAE,CAAC;4BACtB,OAAO,CAAC,GAAG,CACT,2CAA2C,aAAa,CAAC,EAAE,iBAAiB,SAAS,EAAE,CACxF,CAAA;wBACH,CAAC;6BAAM,CAAC;4BACN,OAAO,CAAC,GAAG,CACT,2DAA2D,SAAS,yBAAyB,CAC9F,CAAA;4BAED,uEAAuE;4BACvE,MAAM,oBAAoB,GAAG,IAAA,mCAA2B,EAAC;gCACvD,UAAU,EAAE,UAAU;gCACtB,MAAM,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,CAAC;gCACvC,OAAO,EAAE;oCACP,QAAQ,EAAE,CAAC,OAAO,CAAC;iCACpB;6BACF,CAAC,CAAA;4BAEF,MAAM,gBAAgB,GAAG,MAAM,WAAW,CAAC,oBAAoB,CAAC,CAAA;4BAChE,MAAM,kBAAkB,GAAG,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC;gCACxD,CAAC,CAAC,gBAAgB;gCAClB,CAAC,CAAC,gBAAgB;oCAClB,CAAC,CAAC,CAAC,gBAAgB,CAAC;oCACpB,CAAC,CAAC,EAAE,CAAA;4BAEN,6EAA6E;4BAC7E,aAAa,GAAG,kBAAkB,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAA2B,CAAA;4BAE3F,IAAI,aAAa,EAAE,EAAE,EAAE,CAAC;gCACtB,OAAO,CAAC,GAAG,CACT,2CAA2C,aAAa,CAAC,EAAE,gBAAgB,OAAO,EAAE,CACrF,CAAA;4BACH,CAAC;wBACH,CAAC;oBACH,CAAC;oBAAC,OAAO,UAAU,EAAE,CAAC;wBACpB,OAAO,CAAC,KAAK,CACX,yDAAyD,UAAU,YAAY,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CACjI,CAAA;oBACH,CAAC;oBAED,IAAI,aAAa,EAAE,EAAE,EAAE,CAAC;wBACtB,OAAO,CAAC,GAAG,CACT,6DAA6D,aAAa,CAAC,EAAE,yCAAyC,CACvH,CAAA;wBACD,UAAU,GAAG,aAAa,CAAC,EAAE,CAAA;wBAE7B,6CAA6C;wBAC7C,MAAM,mBAAmB,GAAG,IAAA,mCAA2B,EAAC;4BACtD,UAAU,EAAE,UAAU;4BACtB,MAAM,EAAE;gCACN,IAAI;gCACJ,qBAAqB;gCACrB,qCAAqC;6BACtC;4BACD,OAAO,EAAE;gCACP,EAAE,EAAE,CAAC,UAAU,CAAC;6BACjB;yBACF,CAAC,CAAA;wBAEF,MAAM,eAAe,GAAG,MAAM,WAAW,CAAC,mBAAmB,CAAC,CAAA;wBAC9D,MAAM,mBAAmB,GAAG,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC;4BACxD,CAAC,CAAC,eAAe;4BACjB,CAAC,CAAC,eAAe;gCACjB,CAAC,CAAC,CAAC,eAAe,CAAC;gCACnB,CAAC,CAAC,EAAE,CAAA;wBACN,MAAM,cAAc,GAAG,mBAAmB,CAAC,CAAC,CAEpC,CAAA;wBAER,oEAAoE;wBACpE,IAAI,cAAc,EAAE,gBAAgB,EAAE,CAAC;4BACrC,MAAM,UAAU,GAAG,cAAc,CAAC,gBAAgB,CAAC,MAAM,CACvD,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,kBAAkB,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,CACtE,CAAA;4BAED,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gCAC1B,OAAO,CAAC,GAAG,CACT,kCAAkC,UAAU,CAAC,MAAM,gFAAgF,CACpI,CAAA;gCAED,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,CAKtC,UAAU,CAAC,CAAA;gCAEd,IAAI,eAAe,EAAE,oBAAoB,EAAE,CAAC;oCAC1C,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;wCACnC,IAAI,CAAC;4CACH,MAAM,eAAe,CAAC,oBAAoB,CAAC;gDACzC,WAAW,EAAE,UAAU;gDACvB,kBAAkB,EAAE,SAAS,CAAC,EAAE;6CACjC,CAAC,CAAA;4CACF,OAAO,CAAC,GAAG,CACT,wDAAwD,SAAS,CAAC,EAAE,kBAAkB,UAAU,EAAE,CACnG,CAAA;wCACH,CAAC;wCAAC,OAAO,WAAW,EAAE,CAAC;4CACrB,OAAO,CAAC,IAAI,CACV,6DAA6D,SAAS,CAAC,EAAE,KAAK,WAAW,YAAY,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CACzJ,CAAA;wCACH,CAAC;oCACH,CAAC;gCACH,CAAC;qCAAM,CAAC;oCACN,OAAO,CAAC,IAAI,CACV,gHAAgH,CACjH,CAAA;gCACH,CAAC;4BACH,CAAC;wBACH,CAAC;wBAED,6CAA6C;wBAC7C,MAAM,oBAAoB,GAAG,SAAS,CAAC,OAAO,CAC5C,iCAAyB,CAAC,YAAY,CACvC,CAAA;wBACD,MAAM,mBAAmB,GAAG,IAAA,mCAA2B,EAAC;4BACtD,UAAU,EAAE,iBAAiB;4BAC7B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC;4BACtB,OAAO,EAAE;gCACP,EAAE,EAAE,CAAC,kBAAkB,CAAC;6BACzB;yBACF,CAAC,CAAA;wBAEF,MAAM,eAAe,GAAG,MAAM,oBAAoB,CAAC,mBAAmB,CAAC,CAAA;wBACvE,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC;4BACjD,CAAC,CAAC,eAAe;4BACjB,CAAC,CAAC,eAAe;gCACjB,CAAC,CAAC,CAAC,eAAe,CAAC;gCACnB,CAAC,CAAC,EAAE,CAAA;wBACN,MAAM,cAAc,GAAG,YAAY,CAAC,CAAC,CAA8C,CAAA;wBAEnF,IAAI,cAAc,EAAE,CAAC;4BACnB,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,CAOtC,UAAU,CAAC,CAAA;4BAEd,IAAI,eAAe,EAAE,iBAAiB,EAAE,CAAC;gCACvC,MAAM,eAAe,CAAC,iBAAiB,CAAC;oCACtC,WAAW,EAAE,UAAU;oCACvB,kBAAkB,EAAE,kBAAkB;oCACtC,IAAI,EAAE,cAAc,CAAC,IAAI,IAAI,UAAU;oCACvC,IAAI,EAAE,EAAE;iCACT,CAAC,CAAA;gCACF,OAAO,CAAC,GAAG,CACT,wDAAwD,UAAU,sDAAsD,kBAAkB,EAAE,CAC7I,CAAA;gCACD,cAAc,GAAG,eAAe,CAAA;gCAChC,eAAe,GAAG,IAAI,CAAA;4BACxB,CAAC;iCAAM,CAAC;gCACN,OAAO,CAAC,IAAI,CACV,gHAAgH,CACjH,CAAA;4BACH,CAAC;wBACH,CAAC;6BAAM,CAAC;4BACN,OAAO,CAAC,IAAI,CACV,4CAA4C,kBAAkB,yCAAyC,CACxG,CAAA;wBACH,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,IAAI,CACV,kEAAkE,SAAS,uCAAuC,CACnH,CAAA;oBACH,CAAC;gBACH,CAAC;gBAAC,OAAO,QAAQ,EAAE,CAAC;oBAClB,MAAM,WAAW,GAAG,QAAQ,YAAY,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;oBACnF,OAAO,CAAC,KAAK,CACX,sEAAsE,WAAW,EAAE,CACpF,CAAA;gBACH,CAAC;YACH,CAAC;YAED,sDAAsD;YACtD,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,IACE,mBAAmB,CAAC,QAAQ,CAAC,sCAAsC,CAAC;oBACpE,mBAAmB,CAAC,QAAQ,CAAC,kBAAkB,CAAC;oBAChD,mBAAmB,CAAC,QAAQ,CAAC,mBAAmB,CAAC;oBACjD,mBAAmB,CAAC,QAAQ,CAAC,0BAA0B,CAAC,EACxD,CAAC;oBACD,uEAAuE;oBACvE,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,YAAY,EAC9B,iHAAiH;wBACjH,+GAA+G;wBAC/G,gGAAgG;wBAChG,qFAAqF;wBACrF,aAAa,OAAO,IAAI;wBACxB,mBAAmB,mBAAmB,EAAE,CACzC,CAAA;gBACH,CAAC;gBAED,gEAAgE;gBAChE,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,eAAe,EACjC,uEAAuE,YAAY,oBAAoB,mBAAmB,EAAE,CAC7H,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,qGAAqG;IACrG,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC5C,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,eAAe,EACjC,oGAAoG,CACrG,CAAA;IACH,CAAC;IAED,gGAAgG;IAChG,+FAA+F;IAC/F,mEAAmE;IACnE,IAAI,kBAAkB,IAAI,cAAc,KAAK,eAAe,EAAE,CAAC;QAC7D,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CACnC,iCAAyB,CAAC,YAAY,CACvC,CAAA;YAED,gDAAgD;YAChD,MAAM,mBAAmB,GAAG,IAAA,mCAA2B,EAAC;gBACtD,UAAU,EAAE,iBAAiB;gBAC7B,MAAM,EAAE;oBACN,IAAI;oBACJ,MAAM;iBACP;gBACD,OAAO,EAAE;oBACP,EAAE,EAAE,CAAC,kBAAkB,CAAC;iBACzB;aACF,CAAC,CAAA;YAEF,MAAM,eAAe,GAAG,MAAM,WAAW,CAAC,mBAAmB,CAAC,CAAA;YAC9D,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC;gBACjD,CAAC,CAAC,eAAe;gBACjB,CAAC,CAAC,eAAe;oBACjB,CAAC,CAAC,CAAC,eAAe,CAAC;oBACnB,CAAC,CAAC,EAAE,CAAA;YACN,MAAM,cAAc,GAAG,YAAY,CAAC,CAAC,CAA8C,CAAA;YAEnF,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,OAAO,CAAC,IAAI,CACV,4CAA4C,kBAAkB,uDAAuD,CACtH,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,mDAAmD;gBACnD,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,CAOtC,UAAU,CAAC,CAAA;gBAEd,IAAI,eAAe,EAAE,iBAAiB,EAAE,CAAC;oBACvC,IAAI,CAAC;wBACH,yDAAyD;wBACzD,2DAA2D;wBAC3D,MAAM,eAAe,CAAC,iBAAiB,CAAC;4BACtC,WAAW,EAAE,UAAU;4BACvB,kBAAkB,EAAE,kBAAkB;4BACtC,IAAI,EAAE,cAAc,CAAC,IAAI,IAAI,UAAU;4BACvC,IAAI,EAAE,EAAE;yBACT,CAAC,CAAA;wBACF,OAAO,CAAC,GAAG,CACT,wFAAwF,kBAAkB,aAAa,cAAc,CAAC,IAAI,IAAI,UAAU,kBAAkB,UAAU,EAAE,CACvL,CAAA;oBACH,CAAC;oBAAC,OAAO,QAAQ,EAAE,CAAC;wBAClB,yDAAyD;wBACzD,MAAM,YAAY,GAAG,QAAQ,YAAY,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;wBACpF,OAAO,CAAC,IAAI,CACV,kFAAkF,kBAAkB,gBAAgB,UAAU,KAAK,YAAY,IAAI;4BACnJ,sFAAsF,CACvF,CAAA;oBACH,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CACV,oFAAoF;wBACpF,2CAA2C,kBAAkB,yCAAyC,CACvG,CAAA;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,yDAAyD;YACzD,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAC3E,OAAO,CAAC,IAAI,CACV,iFAAiF,kBAAkB,KAAK,YAAY,IAAI;gBACxH,sFAAsF,CACvF,CAAA;QACH,CAAC;IACH,CAAC;IAED,8EAA8E;IAC9E,MAAM,6BAA6B,GAAG,2BAA2B;QAC/D,CAAE,QAAqD,CAAC,2BAA2B,CAAC,CAAA;IAEtF,2CAA2C;IAC3C,0EAA0E;IAC1E,uCAAuC;IACvC,IAAI,6BAA6B,EAAE,CAAC;QAClC,IAAI,CAAC;YACH,gEAAgE;YAChE,4DAA4D;YAC5D,MAAM,kBAAkB,GAAG,MAAM,IAAA,gDAA0B,EACzD,OAAO,EACP,6BAA6B,EAC7B,SAAS,CACV,CAAA;YAED,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBACxB,OAAO,CAAC,IAAI,CACV,4CAA4C,6BAA6B,uBAAuB,OAAO,sCAAsC,CAC9I,CAAA;YACH,CAAC;iBAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;gBACpC,OAAO,CAAC,IAAI,CACV,4CAA4C,6BAA6B,kFAAkF,CAC5J,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,0DAA0D;gBAC1D,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,CAMtC,UAAU,CAAC,CAAA;gBAEd,IAAI,eAAe,EAAE,iBAAiB,EAAE,CAAC;oBACvC,IAAI,CAAC;wBACH,MAAM,eAAe,CAAC,iBAAiB,CAAC;4BACtC,WAAW,EAAE,UAAU;4BACvB,kBAAkB,EAAE,6BAA6B;4BACjD,IAAI,EAAE,kBAAkB,CAAC,IAAI;yBAC9B,CAAC,CAAA;wBACF,OAAO,CAAC,GAAG,CACT,gEAAgE,kBAAkB,CAAC,IAAI,MAAM,6BAA6B,iBAAiB,UAAU,EAAE,CACxJ,CAAA;oBACH,CAAC;oBAAC,OAAO,QAAQ,EAAE,CAAC;wBAClB,uDAAuD;wBACvD,+DAA+D;wBAC/D,MAAM,YAAY,GAAG,QAAQ,YAAY,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;wBACpF,OAAO,CAAC,IAAI,CACV,mEAAmE,6BAA6B,gBAAgB,UAAU,KAAK,YAAY,EAAE,CAC9I,CAAA;oBACH,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CACV,uIAAuI,CACxI,CAAA;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,iEAAiE;YACjE,+DAA+D;YAC/D,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAC3E,OAAO,CAAC,IAAI,CACV,6DAA6D,6BAA6B,KAAK,YAAY,uDAAuD,CACnK,CAAA;QACH,CAAC;IACH,CAAC;IAED,iCAAiC;IACjC,IAAI,iBAAiB,EAAE,CAAC;QACtB,IAAI,CAAC;YACH,4CAA4C;YAC5C,MAAM,mBAAmB,GAAG,SAAS,CAAC,OAAO,CAO1C,cAAc,CAAC,CAAA;YAElB,IAAI,mBAAmB,EAAE,IAAI,EAAE,CAAC;gBAC9B,MAAM,OAAO,GAAI,QAAkC,CAAC,QAAQ,CAAA;gBAC5D,8CAA8C;gBAC9C,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CACnC,iCAAyB,CAAC,YAAY,CACvC,CAAA;gBAED,IAAI,OAAO,IAAI,WAAW,EAAE,CAAC;oBAC3B,IAAI,CAAC;wBACH,MAAM,UAAU,GAAG,IAAA,mCAA2B,EAAC;4BAC7C,UAAU,EAAE,OAAO;4BACnB,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC;4BACvB,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE;yBAC3B,CAAC,CAAA;wBACF,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,CAAA;wBAC5C,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;wBAC1E,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAmC,CAAA;wBAE7D,IAAI,KAAK,EAAE,KAAK,EAAE,CAAC;4BACjB,MAAM,mBAAmB,CAAC,IAAI,CAAC;gCAC7B,EAAE,EAAE,KAAK,CAAC,KAAK;gCACf,OAAO,EAAE,OAAO;gCAChB,QAAQ,EAAE,kBAAkB;gCAC5B,IAAI,EAAE;oCACJ,WAAW,EAAE,UAAU;oCACvB,OAAO,EAAE,OAAO;oCAChB,QAAQ,EAAE,OAAO;iCAClB;6BACF,CAAC,CAAA;wBACJ,CAAC;oBACH,CAAC;oBAAC,OAAO,iBAAiB,EAAE,CAAC;wBAC3B,OAAO,CAAC,IAAI,CAAC,uDAAuD,EAAE,iBAAiB,CAAC,CAAA;oBAC1F,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,2CAA2C;YAC3C,OAAO,CAAC,IAAI,CAAC,8DAA8D,EAAE,KAAK,CAAC,CAAA;QACrF,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,MAAM,YAAY,GAAI,QAAmD,CAAC,QAAQ,IAAI,EAAE,CAAA;IACxF,MAAM,iBAAiB,GAAI,YAAY,CAAC,kBAA8C,IAAI,EAAE,CAAA;IAE5F,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC,WAAW,CAAC;QAChD,QAAQ,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE;QACzB,IAAI,EAAE;YACJ,WAAW,EAAE,UAAU;YACvB,2BAA2B,EAAE,6BAA6B,IAAI,IAAI;YAClE,iBAAiB,EAAE,iBAAiB,IAAI,KAAK;YAC7C,QAAQ,EAAE;gBACR,GAAG,YAAY;gBACf,kBAAkB,EAAE;oBAClB,GAAG,iBAAiB;oBACpB,WAAW,EAAE,UAAU;oBACvB,mBAAmB,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBAC7C,wBAAwB,EAAE,cAAc;oBACxC,2BAA2B,EAAE,6BAA6B;oBAC1D,iBAAiB,EAAE,iBAAiB,IAAI,KAAK;iBAC9C;aACF;SACF;KACF,CAAC,CAAA;IAEF,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAA;IAE3E,OAAO,IAAI,4BAAY,CAAiC;QACtD,WAAW,EAAE,UAAU;QACvB,IAAI,EAAE,SAAS,IAAI,IAAI;KACxB,CAAC,CAAA;AACJ,CAAC,CACF,CAAA"}