@karibulab/wsdl2tsx 0.21.0 → 0.23.0

package/dist/cli.js

@@ -16698,8 +16698,32 @@ var init_sequence_processors = __esm({
     init_node_extractors();
     init_element_processor();
     sequenceToObject = (node, namespaces, complexTypes, targetNamespace, isQualified = false) => {
+      const object = {};
+      if (targetNamespace !== void 0) {
+        object["$namespace"] = targetNamespace;
+      }
+      object["$qualified"] = isQualified;
+      const choiceNode = getChoiceNode(node);
+      if (choiceNode !== void 0) {
+        const choiceResult = choiceToObject(choiceNode, namespaces, complexTypes, targetNamespace, isQualified);
+        Object.assign(object, choiceResult);
+      }
+      const nestedSequenceNode = getSequenceNode(node);
+      if (nestedSequenceNode !== void 0 && nestedSequenceNode !== node) {
+        const nestedSequenceResult = sequenceToObject(nestedSequenceNode, namespaces, complexTypes, targetNamespace, isQualified);
+        Object.assign(object, nestedSequenceResult);
+      }
+      const allNode = getAllNode(node);
+      if (allNode !== void 0) {
+        const allResult = allToObject(allNode, namespaces, complexTypes, targetNamespace, isQualified);
+        Object.assign(object, allResult);
+      }
       const elementNode = getElementNode(node);
-      return processElementsToObject(elementNode, namespaces, complexTypes, targetNamespace, isQualified);
+      if (elementNode !== void 0) {
+        const elementResult = processElementsToObject(elementNode, namespaces, complexTypes, targetNamespace, isQualified);
+        Object.assign(object, elementResult);
+      }
+      return object;
     };
     choiceToObject = (node, namespaces, complexTypes, targetNamespace, isQualified = false) => {
       const elementNode = getElementNode(node);
@@ -17191,7 +17215,7 @@ var init_processors = __esm({
 });
 
 // src/wsdl/complex-type-helpers.ts
-async function processImports(wsdlFile, node, currentNamespaces, object) {
+async function processImports(wsdlFile, node, currentNamespaces, object, processedSchemas = /* @__PURE__ */ new Set()) {
   const importNode = getImportNode(node);
   if (importNode === void 0) {
     return;
@@ -17203,13 +17227,19 @@ async function processImports(wsdlFile, node, currentNamespaces, object) {
       debugContext("processImports", `Import sin schemaLocation, omitiendo`);
       return;
     }
+    const schemaId = item.schemaLocation;
+    if (processedSchemas.has(schemaId)) {
+      debugContext("processImports", `Schema ya procesado, omitiendo: ${schemaId}`);
+      return;
+    }
     debugContext("processImports", `Cargando XSD importado desde: ${item.schemaLocation}`);
     try {
       const importedXsd = await loadXsd(wsdlFile, item.schemaLocation);
       const schemaNode = getSchemaNode(importedXsd);
       if (schemaNode) {
+        processedSchemas.add(schemaId);
         const { complexTypesFromSchema: complexTypesFromSchema2 } = await Promise.resolve().then(() => (init_complex_types(), complex_types_exports));
-        const importedComplexTypes = await complexTypesFromSchema2(wsdlFile, schemaNode, currentNamespaces);
+        const importedComplexTypes = await complexTypesFromSchema2(wsdlFile, schemaNode, currentNamespaces, processedSchemas);
         const importedCount = Object.keys(importedComplexTypes).length;
         debugContext("processImports", `\u2713 XSD importado exitosamente: ${importedCount} tipo(s) complejo(s) encontrado(s)`);
         Object.assign(object, importedComplexTypes);
@@ -17288,13 +17318,13 @@ var init_complex_types = __esm({
     init_node_extractors();
     init_processors();
     init_complex_type_helpers();
-    complexTypesFromSchema = async (wsdlFile, node, namespaces) => {
+    complexTypesFromSchema = async (wsdlFile, node, namespaces, processedSchemas = /* @__PURE__ */ new Set()) => {
       const targetNamespace = node.targetNamespace;
       const isQualified = node.elementFormDefault === "qualified";
       const schemaNamespaces = namespaces ?? getNamespacesFromNode(node);
       const currentNamespaces = schemaNamespaces;
       let object = {};
-      await processImports(wsdlFile, node, currentNamespaces, object);
+      await processImports(wsdlFile, node, currentNamespaces, object, processedSchemas);
       processComplexTypeNodes(node, targetNamespace, currentNamespaces, object, isQualified);
       processElementNodes(node, targetNamespace, currentNamespaces, object, isQualified);
       return object;
@@ -23510,7 +23540,12 @@ init_node_extractors();
 // src/generator/schema-processing.ts
 init_node_extractors();
 init_loader();
-async function processSchemaAndImports(schemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject) {
+async function processSchemaAndImports(schemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject, processedSchemas = /* @__PURE__ */ new Set(), schemaLocation) {
+  const schemaId = schemaLocation || schemaNode.targetNamespace || "default";
+  if (processedSchemas.has(schemaId)) {
+    return;
+  }
+  processedSchemas.add(schemaId);
   const schemaObj = schemaToObject(schemaNode, allNamespaces, allComplexTypes);
   for (const [key, value] of Object.entries(schemaObj)) {
     if (key !== "$namespace" || !schemaObject["$namespace"]) {
@@ -23529,7 +23564,7 @@ async function processSchemaAndImports(schemaNode, wsdlPath, allNamespaces, allC
           const importedXsd = await loadXsd(wsdlPath, item.schemaLocation);
           const importedSchemaNode = getSchemaNode(importedXsd);
           if (importedSchemaNode) {
-            await processSchemaAndImports(importedSchemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject);
+            await processSchemaAndImports(importedSchemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject, processedSchemas, item.schemaLocation);
           }
         } catch (error2) {
           const { warn: warn2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
@@ -23712,6 +23747,32 @@ function extractLocalName(fullName) {
   }
   return fullName;
 }
+function validatePropertyOrder(propsOrder, xmlOrder, context = "unknown") {
+  if (propsOrder.length !== xmlOrder.length) {
+    return {
+      isValid: false,
+      differences: [{
+        index: -1,
+        props: `Length: ${propsOrder.length}`,
+        xml: `Length: ${xmlOrder.length}`
+      }]
+    };
+  }
+  const differences = [];
+  for (let i = 0; i < propsOrder.length; i++) {
+    if (propsOrder[i] !== xmlOrder[i]) {
+      differences.push({
+        index: i,
+        props: propsOrder[i] || "(missing)",
+        xml: xmlOrder[i] || "(missing)"
+      });
+    }
+  }
+  return {
+    isValid: differences.length === 0,
+    differences: differences.length > 0 ? differences : void 0
+  };
+}
 function generateHash(str, seed = 0) {
   let hash = seed;
   for (let i = 0; i < str.length; i++) {
@@ -24020,6 +24081,7 @@ function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
 }
 
 // src/codegen/xml-generator/xml-property.ts
+init_logger();
 function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping, schemaObject, allComplexTypes, tagUsageCollector) {
   const namespacePrefix = getNamespacePrefix(
     namespacesTypeMapping,
@@ -24042,7 +24104,9 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
   }
   const isArray2 = typeof elementObject === "object" && elementObject !== null && "maxOccurs" in elementObject && elementObject.maxOccurs !== void 0 && elementObject.maxOccurs !== "1" && elementObject.maxOccurs !== DEFAULT_OCCURS;
   const currentPropertyPath = propertyPath ? propertyPath.endsWith(`.${tagCamelCase}`) || propertyPath === tagCamelCase ? propertyPath : `${propertyPath}.${tagCamelCase}` : tagCamelCase;
-  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (schemaObject || allComplexTypes)) {
+  const isXsdSimpleType = typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (elementObject.type.startsWith("xsd:") || elementObject.type === "string" || elementObject.type === "int" || elementObject.type === "boolean" || elementObject.type === "date" || elementObject.type === "dateTime");
+  debugContext("generateXmlPropertyCode", `Procesando propiedad "${key}" (tagLocalName: "${tagLocalName}"), elementObject.type: ${typeof elementObject === "object" && elementObject !== null ? typeof elementObject.type : "N/A"}, isXsdSimpleType: ${isXsdSimpleType}`);
+  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (schemaObject || allComplexTypes) && !isXsdSimpleType) {
     const referencedType = elementObject.type;
     const referencedElement = resolveReferencedType(referencedType, schemaObject, allComplexTypes);
     if (referencedElement && typeof referencedElement === "object") {
@@ -24183,6 +24247,13 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
     ${wrapperCloseTag}`;
       }
     }
+    if (typeof elementObject.type === "string") {
+      return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
+    }
+  }
+  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string") {
+    debugContext("generateXmlPropertyCode", `Generando tag para tipo simple "${elementObject.type}" con propertyPath "${currentPropertyPath}"`);
+    return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
   }
   if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "object") {
     const keys = getFilteredKeys(elementObject.type);
@@ -24262,9 +24333,13 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
 }
 
 // src/codegen/xml-generator/xml-body.ts
+init_logger();
 function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping, tagUsageCollector) {
   const keys = getFilteredKeys(baseTypeObject);
+  const localNames = keys.map((key) => extractLocalName(key));
   const baseTypeLocalName = extractLocalName(baseTypeName);
+  debugContext("generateXmlBodyCode", `Generando XML para tipo "${baseTypeName}" con ${keys.length} propiedades: ${keys.join(", ")}`);
+  debugContext("generateXmlBodyCode", `Orden de tags XML (nombres locales): ${localNames.join(" -> ")}`);
   if (keys.length === 1) {
     const singleKey = keys[0];
     const element = baseTypeObject[singleKey];
@@ -24280,10 +24355,27 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
   }
   const properties = keys.map((key) => {
     const element = baseTypeObject[key];
+    debugContext("generateXmlBodyCode", `Procesando propiedad "${key}", typeof element: ${typeof element}, element: ${typeof element === "object" && element !== null ? JSON.stringify(Object.keys(element)).substring(0, 100) : element}`);
+    if (typeof element === "string") {
+      const keyLocalName = extractLocalName(key);
+      const keyCamelCase = toCamelCase2(keyLocalName);
+      const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
+      const namespacePrefix = getNamespacePrefix(
+        namespacesTypeMapping,
+        baseNamespacePrefix,
+        key,
+        null,
+        { $qualified: true },
+        prefixesMapping
+      );
+      debugContext("generateXmlBodyCode", `Generando tag para tipo simple string "${element}" con propertyPath "${propertyPath}"`);
+      return `<${namespacePrefix}.${keyLocalName}>{props.${propertyPath}}</${namespacePrefix}.${keyLocalName}>`;
+    }
     if (typeof element === "object" && element !== null) {
       const keyLocalName = extractLocalName(key);
       const keyCamelCase = toCamelCase2(keyLocalName);
       const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
+      debugContext("generateXmlBodyCode", `Llamando a generateXmlPropertyCode para "${key}" con propertyPath "${propertyPath}"`);
       return generateXmlPropertyCode(
         namespacesTypeMapping,
         baseNamespacePrefix,
@@ -24299,6 +24391,7 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
         tagUsageCollector
       );
     }
+    debugContext("generateXmlBodyCode", `\u26A0 Propiedad "${key}" no es un objeto ni string, omitiendo`);
     return "";
   }).filter(Boolean).join("\n");
   if (tagUsageCollector) {
@@ -24712,9 +24805,11 @@ function extractNestedComplexTypes(typeObject, namespaceKey, xmlSchemaUri, visit
 
 // src/codegen/data-preparer/props-interface.ts
 init_logger();
-function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces, schemaObject, allComplexTypes) {
+function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes = /* @__PURE__ */ new Set()) {
   const keys = getFilteredKeys(typeObject);
+  const localNames = keys.map((key) => extractLocalName(key));
   debugContext("preparePropsInterfaceData", `Procesando tipo "${typeName}" con ${keys.length} propiedades: ${keys.join(", ")}`);
+  debugContext("preparePropsInterfaceData", `Orden de propiedades (nombres locales): ${localNames.join(" -> ")}`);
   if (keys.length === 1) {
     const singleKey = keys[0];
     const element = typeObject[singleKey];
@@ -24725,8 +24820,75 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
       if (typeof typeValue === "string" && (schemaObject || allComplexTypes)) {
         debugContext("preparePropsInterfaceData", `Resolviendo referencia de tipo: "${typeValue}"`);
         let referencedElement = schemaObject?.[typeValue];
+        if (referencedElement) {
+          const refType = typeof referencedElement;
+          const hasType = typeof referencedElement === "object" && referencedElement !== null && "type" in referencedElement;
+          const typeValueInRef = hasType ? referencedElement.type : null;
+          const typeOfTypeValue = typeof typeValueInRef;
+          debugContext("preparePropsInterfaceData", `Tipo encontrado directamente en schemaObject[${typeValue}]: tipo=${refType}, tiene 'type'=${hasType}, typeValue=${typeValueInRef} (${typeOfTypeValue})`);
+        }
+        if (referencedElement && typeof referencedElement === "object" && "type" in referencedElement) {
+          const typeValueInElement = referencedElement.type;
+          if (typeof typeValueInElement === "string") {
+            debugContext("preparePropsInterfaceData", `Tipo encontrado es un wrapper con type="${typeValueInElement}", buscando tipo completo`);
+            let fullType = allComplexTypes?.[typeValueInElement];
+            if (fullType) {
+              const fullTypeKeys = getFilteredKeys(fullType);
+              debugContext("preparePropsInterfaceData", `Tipo completo encontrado en allComplexTypes con ${fullTypeKeys.length} propiedades: ${fullTypeKeys.join(", ")}`);
+            }
+            if (!fullType && schemaObject) {
+              fullType = schemaObject[typeValueInElement];
+              if (fullType && typeof fullType === "object") {
+                const fullTypeKeys = getFilteredKeys(fullType);
+                debugContext("preparePropsInterfaceData", `Tipo completo encontrado en schemaObject con ${fullTypeKeys.length} propiedades: ${fullTypeKeys.join(", ")}`);
+              }
+            }
+            if (!fullType) {
+              const wrappedTypeLocalName = typeValueInElement.split(":").pop() || typeValueInElement;
+              debugContext("preparePropsInterfaceData", `Buscando tipo completo por nombre local "${wrappedTypeLocalName}"`);
+              if (allComplexTypes) {
+                const matchingKey = Object.keys(allComplexTypes).find((key) => {
+                  const keyLocalName = key.split(":").pop() || key;
+                  return keyLocalName === wrappedTypeLocalName;
+                });
+                if (matchingKey) {
+                  fullType = allComplexTypes[matchingKey];
+                  const fullTypeKeys = getFilteredKeys(fullType);
+                  debugContext("preparePropsInterfaceData", `\u2713 Tipo completo encontrado en allComplexTypes por nombre local "${matchingKey}" con ${fullTypeKeys.length} propiedades`);
+                }
+              }
+              if (!fullType && schemaObject) {
+                const matchingKey = Object.keys(schemaObject).find((key) => {
+                  if (key === "$namespace" || key === "$qualified") return false;
+                  const keyLocalName = key.split(":").pop() || key;
+                  return keyLocalName === wrappedTypeLocalName;
+                });
+                if (matchingKey) {
+                  fullType = schemaObject[matchingKey];
+                  if (fullType && typeof fullType === "object") {
+                    const fullTypeKeys = getFilteredKeys(fullType);
+                    debugContext("preparePropsInterfaceData", `\u2713 Tipo completo encontrado en schemaObject por nombre local "${matchingKey}" con ${fullTypeKeys.length} propiedades`);
+                  }
+                }
+              }
+            }
+            if (fullType && typeof fullType === "object") {
+              const fullTypeKeys = getFilteredKeys(fullType);
+              debugContext("preparePropsInterfaceData", `\u2713 Usando tipo completo con ${fullTypeKeys.length} propiedades en lugar del wrapper`);
+              referencedElement = fullType;
+            } else {
+              debugContext("preparePropsInterfaceData", `\u26A0 Tipo completo no encontrado para "${typeValueInElement}", usando wrapper`);
+            }
+          } else if (typeof typeValueInElement === "object" && typeValueInElement !== null) {
+            debugContext("preparePropsInterfaceData", `Tipo encontrado tiene type como objeto, usando directamente`);
+            referencedElement = typeValueInElement;
+          }
+        }
         if (!referencedElement && allComplexTypes) {
           referencedElement = allComplexTypes[typeValue];
+          if (referencedElement) {
+            debugContext("preparePropsInterfaceData", `Tipo encontrado en allComplexTypes[${typeValue}]`);
+          }
         }
         if (!referencedElement && schemaObject) {
           const typeLocalName = typeValue.split(":").pop() || typeValue;
@@ -24759,9 +24921,16 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
         if (!referencedElement) {
           debugContext("preparePropsInterfaceData", `\u2717 No se encontr\xF3 la referencia "${typeValue}"`);
         } else {
-          debugContext("preparePropsInterfaceData", `\u2713 Referencia resuelta (${typeof referencedElement === "object" ? Object.keys(referencedElement).length + " propiedades" : "tipo simple"})`);
+          const refKeys = typeof referencedElement === "object" ? getFilteredKeys(referencedElement) : [];
+          const refLocalNames = refKeys.map((k) => extractLocalName(k));
+          debugContext("preparePropsInterfaceData", `\u2713 Referencia resuelta (${refKeys.length} propiedades): ${refKeys.join(", ")}`);
+          debugContext("preparePropsInterfaceData", `  Propiedades del tipo referenciado (nombres locales): ${refLocalNames.join(" -> ")}`);
         }
         if (referencedElement && typeof referencedElement === "object") {
+          const refKeys = getFilteredKeys(referencedElement);
+          const hasOnlyTypeProperty = refKeys.length === 0 && "type" in referencedElement;
+          const hasTypeAndOtherProperties = refKeys.length > 0 && "type" in referencedElement;
+          debugContext("preparePropsInterfaceData", `Tipo referenciado tiene ${refKeys.length} propiedades adem\xE1s de 'type'`);
           if ("type" in referencedElement && typeof referencedElement.type === "string") {
             const nestedTypeValue = referencedElement.type;
             debugContext("preparePropsInterfaceData", `Resolviendo tipo anidado recursivamente: "${nestedTypeValue}"`);
@@ -24795,14 +24964,45 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
               }
             }
             if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
-              debugContext("preparePropsInterfaceData", `Expandiendo contenido del tipo anidado`);
-              const cleanedNestedElement = { ...nestedReferencedElement };
-              Object.keys(cleanedNestedElement).forEach((key) => {
-                if (key.startsWith("_")) {
-                  delete cleanedNestedElement[key];
+              const nestedKeys = getFilteredKeys(nestedReferencedElement);
+              const nestedLocalNames = nestedKeys.map((k) => extractLocalName(k));
+              debugContext("preparePropsInterfaceData", `Tipo anidado resuelto tiene ${nestedKeys.length} propiedades: ${nestedKeys.join(", ")}`);
+              debugContext("preparePropsInterfaceData", `  Propiedades del tipo anidado (nombres locales): ${nestedLocalNames.join(" -> ")}`);
+              if (hasOnlyTypeProperty || !hasTypeAndOtherProperties && refKeys.length === 0) {
+                debugContext("preparePropsInterfaceData", `Expandiendo contenido del tipo anidado (wrapper sin otras propiedades)`);
+                if (visitedTypes.has(nestedTypeValue)) {
+                  debugContext("preparePropsInterfaceData", `\u26A0 Tipo anidado "${nestedTypeValue}" ya fue procesado, evitando recursi\xF3n infinita`);
+                  return {
+                    properties: [],
+                    interfaces: []
+                  };
                 }
-              });
-              return preparePropsInterfaceData(typeName, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+                visitedTypes.add(nestedTypeValue);
+                const cleanedNestedElement = { ...nestedReferencedElement };
+                Object.keys(cleanedNestedElement).forEach((key) => {
+                  if (key.startsWith("_")) {
+                    delete cleanedNestedElement[key];
+                  }
+                });
+                return preparePropsInterfaceData(nestedTypeValue, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+              } else {
+                debugContext("preparePropsInterfaceData", `Combinando propiedades del wrapper con el tipo anidado`);
+                if (visitedTypes.has(nestedTypeValue)) {
+                  debugContext("preparePropsInterfaceData", `\u26A0 Tipo anidado "${nestedTypeValue}" ya fue procesado, evitando recursi\xF3n infinita`);
+                  return {
+                    properties: [],
+                    interfaces: []
+                  };
+                }
+                visitedTypes.add(nestedTypeValue);
+                const cleanedNestedElement = { ...nestedReferencedElement };
+                Object.keys(cleanedNestedElement).forEach((key) => {
+                  if (key.startsWith("_")) {
+                    delete cleanedNestedElement[key];
+                  }
+                });
+                return preparePropsInterfaceData(nestedTypeValue, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+              }
             }
           }
           const cleanedReferencedElement = { ...referencedElement };
@@ -24811,7 +25011,17 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
               delete cleanedReferencedElement[key];
             }
           });
-          return preparePropsInterfaceData(typeName, cleanedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+          debugContext("preparePropsInterfaceData", `Expandiendo tipo referenciado directamente (sin type anidado)`);
+          const referencedTypeId = typeValue || typeName;
+          if (visitedTypes.has(referencedTypeId)) {
+            debugContext("preparePropsInterfaceData", `\u26A0 Tipo referenciado "${referencedTypeId}" ya fue procesado, evitando recursi\xF3n infinita`);
+            return {
+              properties: [],
+              interfaces: []
+            };
+          }
+          visitedTypes.add(referencedTypeId);
+          return preparePropsInterfaceData(referencedTypeId, cleanedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
         }
       }
       if (typeof typeValue === "object" && typeValue !== null) {
@@ -24823,7 +25033,15 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
         });
         const typeKeys = getFilteredKeys(cleanedTypeValue);
         if (typeKeys.length > 0) {
-          return preparePropsInterfaceData(typeName, cleanedTypeValue, allTypesForInterfaces, schemaObject, allComplexTypes);
+          if (visitedTypes.has(typeName)) {
+            debugContext("preparePropsInterfaceData", `\u26A0 Tipo "${typeName}" ya fue procesado, evitando recursi\xF3n infinita`);
+            return {
+              properties: [],
+              interfaces: []
+            };
+          }
+          visitedTypes.add(typeName);
+          return preparePropsInterfaceData(typeName, cleanedTypeValue, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
         }
       }
     }
@@ -25329,6 +25547,9 @@ function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, al
   return interfaces;
 }
 
+// src/codegen/data-preparer/template-data.ts
+init_logger();
+
 // src/codegen/data-preparer/template-data-helpers.ts
 init_logger();
 function processHeaders(headersInfo, schemaObject, allTypesForInterfaces, allComplexTypes, baseNamespacePrefix, namespacesTypeMapping, namespacesTagsMapping, namespacesPrefixMapping, propsInterface) {
@@ -25491,6 +25712,47 @@ function prepareTemplateData(requestType, requestTypeObject, namespacesTagsMappi
   const typesForInterfacesWithHeaders = prepareTypesForInterfaces(typesForInterfaces, headersInfo, allTypesForInterfaces);
   const interfaces = prepareInterfacesData(typesForInterfacesWithHeaders, NAMESPACE_KEY, XML_SCHEMA_URI, allTypesForInterfaces, simpleTypeNames);
   const xmlBody = generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, requestType, requestTypeObject, void 0, schemaObject, allComplexTypes, namespacesPrefixMapping);
+  const propsOrder = propsInterface.properties.filter((prop) => {
+    return !headers.some((h) => extractLocalName(h.partName) === prop.name);
+  }).map((prop) => prop.name);
+  const bodyKeys = getFilteredKeys(requestTypeObject);
+  const xmlOrder = bodyKeys.map((key) => extractLocalName(key));
+  if (propsOrder.length === xmlOrder.length) {
+    const orderValidation = validatePropertyOrder(propsOrder, xmlOrder, `body-${requestType}`);
+    if (!orderValidation.isValid) {
+      warn(`\u26A0\uFE0F  Advertencia: El orden de propiedades no coincide entre props y XML para "${requestType}"`);
+      debugContext("prepareTemplateData", `Orden en props: ${propsOrder.join(" -> ")}`);
+      debugContext("prepareTemplateData", `Orden en XML: ${xmlOrder.join(" -> ")}`);
+      if (orderValidation.differences) {
+        orderValidation.differences.forEach((diff) => {
+          debugContext("prepareTemplateData", `  Diferencia en \xEDndice ${diff.index}: props="${diff.props}" vs xml="${diff.xml}"`);
+        });
+      }
+    } else {
+      debugContext("prepareTemplateData", `\u2713 Orden de propiedades del body validado correctamente para "${requestType}"`);
+    }
+  } else {
+    debugContext("prepareTemplateData", `Nota: Props tiene ${propsOrder.length} propiedades, XML tiene ${xmlOrder.length} propiedades. Esto puede indicar expansi\xF3n de tipos referenciados (comportamiento esperado).`);
+    debugContext("prepareTemplateData", `Orden en props: ${propsOrder.join(" -> ")}`);
+    debugContext("prepareTemplateData", `Orden en XML (nivel ra\xEDz): ${xmlOrder.join(" -> ")}`);
+  }
+  if (headers.length > 0) {
+    const headersPropsOrder = propsInterface.properties.filter((prop) => headers.some((h) => extractLocalName(h.partName) === prop.name)).map((prop) => prop.name);
+    const headersXmlOrder = headers.map((h) => extractLocalName(h.partName));
+    const headersOrderValidation = validatePropertyOrder(headersPropsOrder, headersXmlOrder, `headers-${requestType}`);
+    if (!headersOrderValidation.isValid) {
+      warn(`\u26A0\uFE0F  Advertencia: El orden de headers no coincide entre props y XML para "${requestType}"`);
+      debugContext("prepareTemplateData", `Orden de headers en props: ${headersPropsOrder.join(" -> ")}`);
+      debugContext("prepareTemplateData", `Orden de headers en XML: ${headersXmlOrder.join(" -> ")}`);
+      if (headersOrderValidation.differences) {
+        headersOrderValidation.differences.forEach((diff) => {
+          debugContext("prepareTemplateData", `  Diferencia en \xEDndice ${diff.index}: props="${diff.props}" vs xml="${diff.xml}"`);
+        });
+      }
+    } else {
+      debugContext("prepareTemplateData", `\u2713 Orden de headers validado correctamente para "${requestType}"`);
+    }
+  }
   const requestTypeLocalName = extractLocalName(requestType);
   let responsePropsInterface;
   let responseInterfaces;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karibulab/wsdl2tsx",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Generador de código TSX desde archivos WSDL",
   "main": "dist/index.js",
   "bin": "./dist/cli.js",
@@ -13,7 +13,7 @@
     "start": "node dist/cli.js"
   },
   "dependencies": {
-    "@karibulab/wsdl2tsx-runtime": "0.21.0",
+    "@karibulab/wsdl2tsx-runtime": "0.23.0",
     "axios": "^1.7.9",
     "fast-xml-parser": "5.3.3",
     "handlebars": "4.7.8"