@karibulab/wsdl2tsx 0.22.0 → 0.24.0

package/dist/cli.js

@@ -17215,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;
@@ -17227,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);
@@ -17312,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;
@@ -23534,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"]) {
@@ -23553,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));
@@ -24070,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,
@@ -24092,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") {
@@ -24233,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);
@@ -24334,10 +24355,184 @@ 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 isXsdSimpleType = element.startsWith("xsd:") || element === "string" || element === "int" || element === "boolean" || element === "date" || element === "dateTime";
+      if (!isXsdSimpleType && element.includes(":") && (schemaObject || allComplexTypes)) {
+        const referencedElement = resolveReferencedType(element, schemaObject, allComplexTypes);
+        debugContext("generateXmlBodyCode", `Intentando resolver referencia "${element}", resultado: ${referencedElement ? typeof referencedElement === "object" ? `objeto con ${Object.keys(referencedElement).length} propiedades: ${Object.keys(referencedElement).join(", ")}` : typeof referencedElement : "null"}`);
+        if (referencedElement && typeof referencedElement === "object") {
+          if ("type" in referencedElement && typeof referencedElement.type === "string" && !referencedElement.type.startsWith("xsd:")) {
+            if (referencedElement.type !== element) {
+              const nestedReferencedElement = resolveReferencedType(referencedElement.type, schemaObject, allComplexTypes);
+              if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
+                let finalNestedElement = nestedReferencedElement;
+                if ("type" in nestedReferencedElement && typeof nestedReferencedElement.type === "object" && nestedReferencedElement.type !== null) {
+                  finalNestedElement = nestedReferencedElement.type;
+                  debugContext("generateXmlBodyCode", `Usando complexType inline del tipo anidado "${referencedElement.type}"`);
+                }
+                const nestedKeys = getFilteredKeys(finalNestedElement);
+                debugContext("generateXmlBodyCode", `Expandiendo tipo anidado "${referencedElement.type}" con ${nestedKeys.length} propiedades: ${nestedKeys.join(", ")}`);
+                const keyLocalName3 = extractLocalName(key);
+                const keyCamelCase3 = toCamelCase2(keyLocalName3);
+                const propertyPath3 = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase3}` : keyCamelCase3;
+                const nestedProperties = nestedKeys.map((nestedKey) => {
+                  const nestedElement = finalNestedElement[nestedKey];
+                  if (typeof nestedElement === "object" && nestedElement !== null) {
+                    const nestedKeyLocalName = extractLocalName(nestedKey);
+                    const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+                    const nestedPropertyPath = `${propertyPath3}.${nestedKeyCamelCase}`;
+                    return generateXmlPropertyCode(
+                      namespacesTypeMapping,
+                      baseNamespacePrefix,
+                      nestedKey,
+                      nestedElement,
+                      key,
+                      nestedPropertyPath,
+                      true,
+                      prefixesMapping,
+                      schemaObject,
+                      allComplexTypes,
+                      tagUsageCollector
+                    );
+                  } else if (typeof nestedElement === "string") {
+                    const nestedKeyLocalName = extractLocalName(nestedKey);
+                    const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+                    const nestedPropertyPath = `${propertyPath3}.${nestedKeyCamelCase}`;
+                    const nestedNamespacePrefix = getNamespacePrefix(
+                      namespacesTypeMapping,
+                      baseNamespacePrefix,
+                      nestedKey,
+                      key,
+                      { $qualified: true },
+                      prefixesMapping
+                    );
+                    return `<${nestedNamespacePrefix}.${nestedKeyLocalName}>{props.${nestedPropertyPath}}</${nestedNamespacePrefix}.${nestedKeyLocalName}>`;
+                  }
+                  return "";
+                }).filter(Boolean).join("\n");
+                const namespacePrefix2 = getNamespacePrefix(
+                  namespacesTypeMapping,
+                  baseNamespacePrefix,
+                  key,
+                  null,
+                  referencedElement,
+                  prefixesMapping
+                );
+                const isQualified = shouldHavePrefix(referencedElement);
+                const wrapperOpenTag = isQualified ? `<${namespacePrefix2}.${keyLocalName3}>` : `<${keyLocalName3}>`;
+                const wrapperCloseTag = isQualified ? `</${namespacePrefix2}.${keyLocalName3}>` : `</${keyLocalName3}>`;
+                return `${wrapperOpenTag}
+    ${nestedProperties}
+${wrapperCloseTag}`;
+              }
+            } else {
+              debugContext("generateXmlBodyCode", `\u26A0 Referencia circular detectada: "${element}" -> "${referencedElement.type}", buscando complexType directamente`);
+              const typeLocalName = element.split(":").pop() || element;
+              if (allComplexTypes) {
+                const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+                  const kLocalName = k.split(":").pop() || k;
+                  return kLocalName === typeLocalName;
+                });
+                if (complexTypeKey) {
+                  const complexType = allComplexTypes[complexTypeKey];
+                  if (complexType && typeof complexType === "object") {
+                    let finalComplexType = complexType;
+                    if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+                      finalComplexType = complexType.type;
+                    }
+                    const complexKeys = getFilteredKeys(finalComplexType);
+                    debugContext("generateXmlBodyCode", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+                    const keyLocalName3 = extractLocalName(key);
+                    const keyCamelCase3 = toCamelCase2(keyLocalName3);
+                    const propertyPath3 = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase3}` : keyCamelCase3;
+                    const complexProperties = complexKeys.map((complexKey) => {
+                      const complexElement = finalComplexType[complexKey];
+                      if (typeof complexElement === "object" && complexElement !== null) {
+                        const complexKeyLocalName = extractLocalName(complexKey);
+                        const complexKeyCamelCase = toCamelCase2(complexKeyLocalName);
+                        const complexPropertyPath = propsInterfaceName ? `${propsInterfaceName}.${complexKeyCamelCase}` : complexKeyCamelCase;
+                        return generateXmlPropertyCode(
+                          namespacesTypeMapping,
+                          baseNamespacePrefix,
+                          complexKey,
+                          complexElement,
+                          null,
+                          // parentKey es null porque estamos en el nivel raíz
+                          complexPropertyPath,
+                          true,
+                          prefixesMapping,
+                          schemaObject,
+                          allComplexTypes,
+                          tagUsageCollector
+                        );
+                      } else if (typeof complexElement === "string") {
+                        const complexKeyLocalName = extractLocalName(complexKey);
+                        const complexKeyCamelCase = toCamelCase2(complexKeyLocalName);
+                        const complexPropertyPath = propsInterfaceName ? `${propsInterfaceName}.${complexKeyCamelCase}` : complexKeyCamelCase;
+                        const complexNamespacePrefix = getNamespacePrefix(
+                          namespacesTypeMapping,
+                          baseNamespacePrefix,
+                          complexKey,
+                          null,
+                          // parentKey es null porque estamos en el nivel raíz
+                          { $qualified: true },
+                          prefixesMapping
+                        );
+                        return `<${complexNamespacePrefix}.${complexKeyLocalName}>{props.${complexPropertyPath}}</${complexNamespacePrefix}.${complexKeyLocalName}>`;
+                      }
+                      return "";
+                    }).filter(Boolean).join("\n");
+                    return complexProperties;
+                  }
+                }
+              }
+            }
+          }
+          debugContext("generateXmlBodyCode", `Resolviendo referencia "${element}" a tipo complejo con propiedades: ${Object.keys(referencedElement).filter((k) => !k.startsWith("$")).join(", ")}`);
+          const keyLocalName2 = extractLocalName(key);
+          const keyCamelCase2 = toCamelCase2(keyLocalName2);
+          const propertyPath2 = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase2}` : keyCamelCase2;
+          const elementAsObject = {
+            type: element,
+            $qualified: true
+          };
+          return generateXmlPropertyCode(
+            namespacesTypeMapping,
+            baseNamespacePrefix,
+            key,
+            elementAsObject,
+            null,
+            propertyPath2,
+            true,
+            prefixesMapping,
+            schemaObject,
+            allComplexTypes,
+            tagUsageCollector
+          );
+        } else {
+          debugContext("generateXmlBodyCode", `No se pudo resolver la referencia "${element}", tratando como tipo simple`);
+        }
+      }
+      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,
@@ -24353,6 +24548,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) {
@@ -24766,7 +24962,7 @@ 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(", ")}`);
@@ -24775,6 +24971,43 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
     const singleKey = keys[0];
     const element = typeObject[singleKey];
     debugContext("preparePropsInterfaceData", `Procesando propiedad \xFAnica "${singleKey}" (tipo: ${typeof element})`);
+    if (typeof element === "string" && element.includes(":") && !element.startsWith("xsd:") && (schemaObject || allComplexTypes)) {
+      const typeLocalName = typeName.split(":").pop() || typeName;
+      const elementLocalName = element.split(":").pop() || element;
+      if (elementLocalName === typeLocalName && allComplexTypes) {
+        debugContext("preparePropsInterfaceData", `\u26A0 Propiedad \xFAnica "${singleKey}" es string que parece referencia circular "${element}", buscando complexType directamente`);
+        const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+          const kLocalName = k.split(":").pop() || k;
+          return kLocalName === typeLocalName;
+        });
+        if (complexTypeKey) {
+          const complexType = allComplexTypes[complexTypeKey];
+          if (complexType && typeof complexType === "object") {
+            let finalComplexType = complexType;
+            if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+              finalComplexType = complexType.type;
+            }
+            const complexKeys = getFilteredKeys(finalComplexType);
+            debugContext("preparePropsInterfaceData", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+            const cleanedComplexType = { ...finalComplexType };
+            Object.keys(cleanedComplexType).forEach((key) => {
+              if (key.startsWith("_")) {
+                delete cleanedComplexType[key];
+              }
+            });
+            if (visitedTypes.has(complexTypeKey)) {
+              debugContext("preparePropsInterfaceData", `\u26A0 ComplexType "${complexTypeKey}" ya fue procesado, evitando recursi\xF3n infinita`);
+              return {
+                properties: [],
+                interfaces: []
+              };
+            }
+            visitedTypes.add(complexTypeKey);
+            return preparePropsInterfaceData(complexTypeKey, cleanedComplexType, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+          }
+        }
+      }
+    }
     if (typeof element === "object" && element !== null && "type" in element) {
       const typeValue = element.type;
       debugContext("preparePropsInterfaceData", `Tipo de propiedad: ${typeof typeValue === "string" ? `referencia "${typeValue}"` : `objeto complejo`}`);
@@ -24929,24 +25162,78 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
               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(" -> ")}`);
+              const typeLocalName2 = typeName.split(":").pop() || typeName;
+              const nestedTypeLocalName = nestedTypeValue.split(":").pop() || nestedTypeValue;
+              const isCircularNestedReference = nestedTypeLocalName === typeLocalName2;
+              if (isCircularNestedReference) {
+                debugContext("preparePropsInterfaceData", `\u26A0 Referencia circular detectada en tipo anidado: "${typeName}" (local: "${typeLocalName2}") -> "${nestedTypeValue}" (local: "${nestedTypeLocalName}"), buscando complexType directamente`);
+                if (allComplexTypes) {
+                  const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+                    const kLocalName = k.split(":").pop() || k;
+                    return kLocalName === typeLocalName2;
+                  });
+                  if (complexTypeKey) {
+                    const complexType = allComplexTypes[complexTypeKey];
+                    if (complexType && typeof complexType === "object") {
+                      let finalComplexType = complexType;
+                      if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+                        finalComplexType = complexType.type;
+                      }
+                      const complexKeys = getFilteredKeys(finalComplexType);
+                      debugContext("preparePropsInterfaceData", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+                      const cleanedComplexType = { ...finalComplexType };
+                      Object.keys(cleanedComplexType).forEach((key) => {
+                        if (key.startsWith("_")) {
+                          delete cleanedComplexType[key];
+                        }
+                      });
+                      if (visitedTypes.has(complexTypeKey)) {
+                        debugContext("preparePropsInterfaceData", `\u26A0 ComplexType "${complexTypeKey}" ya fue procesado, evitando recursi\xF3n infinita`);
+                        return {
+                          properties: [],
+                          interfaces: []
+                        };
+                      }
+                      visitedTypes.add(complexTypeKey);
+                      return preparePropsInterfaceData(complexTypeKey, cleanedComplexType, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+                    }
+                  }
+                }
+              }
               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: []
+                  };
+                }
+                visitedTypes.add(nestedTypeValue);
                 const cleanedNestedElement = { ...nestedReferencedElement };
                 Object.keys(cleanedNestedElement).forEach((key) => {
                   if (key.startsWith("_")) {
                     delete cleanedNestedElement[key];
                   }
                 });
-                return preparePropsInterfaceData(typeName, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+                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(typeName, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+                return preparePropsInterfaceData(nestedTypeValue, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
               }
             }
           }
@@ -24957,7 +25244,54 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
             }
           });
           debugContext("preparePropsInterfaceData", `Expandiendo tipo referenciado directamente (sin type anidado)`);
-          return preparePropsInterfaceData(typeName, cleanedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+          const referencedTypeId = typeValue || typeName;
+          const typeLocalName = typeName.split(":").pop() || typeName;
+          const referencedTypeLocalName = typeValue ? typeValue.split(":").pop() || typeValue : null;
+          const isCircularReference = referencedTypeLocalName === typeLocalName && "type" in cleanedReferencedElement && typeof cleanedReferencedElement.type === "string" && (cleanedReferencedElement.type === typeValue || cleanedReferencedElement.type.split(":").pop() === typeLocalName);
+          if (isCircularReference) {
+            debugContext("preparePropsInterfaceData", `\u26A0 Referencia circular detectada: "${typeName}" (local: "${typeLocalName}") -> "${typeValue}" (local: "${referencedTypeLocalName}"), buscando complexType directamente`);
+            if (allComplexTypes) {
+              const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+                const kLocalName = k.split(":").pop() || k;
+                return kLocalName === typeLocalName;
+              });
+              if (complexTypeKey) {
+                const complexType = allComplexTypes[complexTypeKey];
+                if (complexType && typeof complexType === "object") {
+                  let finalComplexType = complexType;
+                  if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+                    finalComplexType = complexType.type;
+                  }
+                  const complexKeys = getFilteredKeys(finalComplexType);
+                  debugContext("preparePropsInterfaceData", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+                  const cleanedComplexType = { ...finalComplexType };
+                  Object.keys(cleanedComplexType).forEach((key) => {
+                    if (key.startsWith("_")) {
+                      delete cleanedComplexType[key];
+                    }
+                  });
+                  if (visitedTypes.has(complexTypeKey)) {
+                    debugContext("preparePropsInterfaceData", `\u26A0 ComplexType "${complexTypeKey}" ya fue procesado, evitando recursi\xF3n infinita`);
+                    return {
+                      properties: [],
+                      interfaces: []
+                    };
+                  }
+                  visitedTypes.add(complexTypeKey);
+                  return preparePropsInterfaceData(complexTypeKey, cleanedComplexType, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+                }
+              }
+            }
+          }
+          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) {
@@ -24969,7 +25303,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);
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karibulab/wsdl2tsx",
-  "version": "0.22.0",
+  "version": "0.24.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.22.0",
+    "@karibulab/wsdl2tsx-runtime": "0.24.0",
     "axios": "^1.7.9",
     "fast-xml-parser": "5.3.3",
     "handlebars": "4.7.8"