@karibulab/wsdl2tsx 0.17.0 → 0.20.0

package/dist/cli.js

@@ -23589,13 +23589,34 @@ Schema [${i}] (targetNamespace: ${schemaNode.targetNamespace || "no definido"}):
 // src/generator/soap-namespace.ts
 var SOAP12_ENVELOPE_URI = "http://www.w3.org/2003/05/soap-envelope";
 var SOAP11_ENVELOPE_URI = "http://schemas.xmlsoap.org/soap/envelope/";
+var SOAP12_BINDING_URI = "http://schemas.xmlsoap.org/wsdl/soap12/";
+var SOAP11_BINDING_URI = "http://schemas.xmlsoap.org/wsdl/soap/";
 function getSoapNamespaceURI(definitionsNamespaces) {
+  for (const uri2 of definitionsNamespaces.values()) {
+    if (uri2 === SOAP12_ENVELOPE_URI) {
+      return SOAP12_ENVELOPE_URI;
+    }
+    if (uri2 === SOAP11_ENVELOPE_URI) {
+      return SOAP11_ENVELOPE_URI;
+    }
+  }
+  for (const uri2 of definitionsNamespaces.values()) {
+    if (uri2 === SOAP12_BINDING_URI || uri2.includes("wsdl/soap12") || uri2.endsWith("soap12/")) {
+      return SOAP12_ENVELOPE_URI;
+    }
+    if (uri2 === SOAP11_BINDING_URI || uri2.includes("wsdl/soap") && !uri2.includes("soap12")) {
+      return SOAP11_ENVELOPE_URI;
+    }
+  }
   const soapEntry = Array.from(definitionsNamespaces.entries()).find((entry) => entry[1].includes("soap"));
   if (!soapEntry) {
     return SOAP11_ENVELOPE_URI;
   }
-  const lastPart = soapEntry[1].split("/").slice(-1)[0];
-  return lastPart === "soap12" ? SOAP12_ENVELOPE_URI : SOAP11_ENVELOPE_URI;
+  const uri = soapEntry[1];
+  if (uri.includes("soap12") || uri.includes("2003/05/soap-envelope")) {
+    return SOAP12_ENVELOPE_URI;
+  }
+  return SOAP11_ENVELOPE_URI;
 }
 
 // src/codegen/constants.ts
@@ -23769,23 +23790,28 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
     let elementNamespace;
     let elementTypeValue = null;
     if (typeof element === "object" && element !== null) {
-      elementNamespace = element.$namespace;
+      const originalElementNamespace = element.$namespace;
+      elementNamespace = originalElementNamespace;
       if ("type" in element && typeof element.type === "string") {
         const referencedType = element.type;
         debugContext("extractAllTagsForXmlBody", `Resolviendo tipo referenciado: "${referencedType}" para tag "${tagLocalName}"`);
         let referencedTypeObject = schemaObject?.[referencedType] || allComplexTypes?.[referencedType];
-        if (!referencedTypeObject) {
+        let foundKey;
+        if (referencedTypeObject) {
+          foundKey = referencedType;
+        } else {
           const referencedLocalName = referencedType.split(":").pop() || referencedType;
-          const matchingKey = Object.keys(schemaObject || {}).find((k) => {
+          foundKey = Object.keys(schemaObject || {}).find((k) => {
+            if (k === "$namespace" || k === "$qualified") return false;
             const kLocalName = k.split(":").pop();
             return kLocalName === referencedLocalName;
           }) || Object.keys(allComplexTypes || {}).find((k) => {
             const kLocalName = k.split(":").pop();
             return kLocalName === referencedLocalName;
           });
-          if (matchingKey) {
-            referencedTypeObject = schemaObject?.[matchingKey] || allComplexTypes?.[matchingKey];
-            debugContext("extractAllTagsForXmlBody", `Tipo referenciado encontrado por nombre local: "${matchingKey}"`);
+          if (foundKey) {
+            referencedTypeObject = schemaObject?.[foundKey] || allComplexTypes?.[foundKey];
+            debugContext("extractAllTagsForXmlBody", `Tipo referenciado encontrado por nombre local: "${foundKey}"`);
           }
         }
         if (referencedTypeObject) {
@@ -23793,18 +23819,39 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
           if (typeof referencedTypeObject === "object" && referencedTypeObject !== null) {
             const refNamespace = referencedTypeObject[NAMESPACE_KEY];
             if (refNamespace) {
-              elementNamespace = refNamespace;
               const refNamespacePrefix = extractNamespacePrefix(refNamespace);
               if (!foundNamespaces.has(refNamespacePrefix)) {
                 foundNamespaces.set(refNamespacePrefix, refNamespace);
-                debugContext("extractAllTagsForXmlBody", `Registrando namespace adicional: "${refNamespacePrefix}" -> "${refNamespace}"`);
+                debugContext("extractAllTagsForXmlBody", `Registrando namespace del tipo referenciado: "${refNamespacePrefix}" -> "${refNamespace}"`);
               }
             }
-            if ("type" in referencedTypeObject && typeof referencedTypeObject.type === "object") {
-              elementTypeValue = referencedTypeObject.type;
+          }
+          let referencedElementNamespace;
+          if (foundKey && foundKey.includes(":")) {
+            const [nsPart] = foundKey.split(":");
+            if (nsPart.startsWith("http://") || nsPart.startsWith("https://")) {
+              referencedElementNamespace = nsPart;
+              debugContext("extractAllTagsForXmlBody", `Namespace del elemento referenciado obtenido de la clave "${foundKey}": "${referencedElementNamespace}"`);
+            }
+          }
+          if (!referencedElementNamespace && referencedTypeObject && typeof referencedTypeObject === "object") {
+            const refNamespace = referencedTypeObject[NAMESPACE_KEY];
+            if (refNamespace && typeof refNamespace === "string") {
+              referencedElementNamespace = refNamespace;
+              debugContext("extractAllTagsForXmlBody", `Namespace del elemento referenciado obtenido del $namespace del objeto: "${referencedElementNamespace}"`);
             }
           }
-          debugContext("extractAllTagsForXmlBody", `\u2713 Tipo referenciado resuelto para "${tagLocalName}"`);
+          if (referencedTypeObject && typeof referencedTypeObject === "object" && "type" in referencedTypeObject && typeof referencedTypeObject.type === "object") {
+            elementTypeValue = referencedTypeObject.type;
+            if (referencedElementNamespace) {
+              elementTypeValue._referencedElementNamespace = referencedElementNamespace;
+            }
+          }
+          if (referencedElementNamespace) {
+            referencedTypeObject._referencedElementNamespace = referencedElementNamespace;
+            debugContext("extractAllTagsForXmlBody", `Namespace del elemento referenciado "${tagLocalName}" guardado: "${referencedElementNamespace}"`);
+          }
+          debugContext("extractAllTagsForXmlBody", `\u2713 Tipo referenciado resuelto para "${tagLocalName}" (elemento en namespace: "${elementNamespace || currentNamespace}", tipo en namespace: "${referencedTypeObject[NAMESPACE_KEY] || "N/A"}")`);
         } else {
           debugContext("extractAllTagsForXmlBody", `\u2717 Tipo referenciado no encontrado: "${referencedType}"`);
         }
@@ -23812,7 +23859,21 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
         elementTypeValue = element.type;
       }
     }
-    const namespace = elementNamespace || currentNamespace;
+    let tagNamespace = elementNamespace || currentNamespace;
+    if (elementTypeValue && typeof elementTypeValue === "object" && elementTypeValue !== null) {
+      const referencedElementNamespace = elementTypeValue._referencedElementNamespace;
+      if (referencedElementNamespace && typeof referencedElementNamespace === "string") {
+        tagNamespace = referencedElementNamespace;
+        debugContext("extractAllTagsForXmlBody", `Tag "${tagLocalName}" pertenece al namespace del elemento referenciado: "${tagNamespace}"`);
+      } else {
+        const referencedTypeNamespace = elementTypeValue[NAMESPACE_KEY];
+        if (referencedTypeNamespace && typeof referencedTypeNamespace === "string") {
+          tagNamespace = referencedTypeNamespace;
+          debugContext("extractAllTagsForXmlBody", `Tag "${tagLocalName}" pertenece al namespace del tipo referenciado: "${tagNamespace}"`);
+        }
+      }
+    }
+    const namespace = tagNamespace;
     const namespacePrefix = extractNamespacePrefix(namespace);
     if (namespace !== currentNamespace && !foundNamespaces.has(namespacePrefix)) {
       foundNamespaces.set(namespacePrefix, namespace);
@@ -23823,7 +23884,9 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
     if (!tagsByNamespace.has(namespace)) {
       tagsByNamespace.set(namespace, []);
     }
-    tagsByNamespace.get(namespace).push(tagLocalName);
+    if (!tagsByNamespace.get(namespace).includes(tagLocalName)) {
+      tagsByNamespace.get(namespace).push(tagLocalName);
+    }
     if (elementTypeValue && typeof elementTypeValue === "object" && elementTypeValue !== null) {
       const nestedTypeObject = elementTypeValue;
       const nestedNamespace = nestedTypeObject[NAMESPACE_KEY] || namespace;
@@ -23850,7 +23913,13 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
         if (!tagsByNamespace.has(nsUri)) {
           tagsByNamespace.set(nsUri, []);
         }
-        tagsByNamespace.get(nsUri).push(...tags);
+        const existingTags = new Set(tagsByNamespace.get(nsUri));
+        for (const tag of tags) {
+          if (!existingTags.has(tag)) {
+            tagsByNamespace.get(nsUri).push(tag);
+            existingTags.add(tag);
+          }
+        }
       }
     }
   }
@@ -23891,6 +23960,358 @@ function flattenKeysWithNamespace(typeObject, currentNamespace, currentNamespace
   return result;
 }
 
+// src/codegen/xml-generator/type-resolution.ts
+function resolveReferencedType(typeValue, schemaObject, allComplexTypes) {
+  let referencedElement = schemaObject?.[typeValue];
+  if (!referencedElement && allComplexTypes) {
+    referencedElement = allComplexTypes[typeValue];
+  }
+  if (!referencedElement && schemaObject) {
+    const typeLocalName = typeValue.split(":").pop() || typeValue;
+    const matchingKey = Object.keys(schemaObject).find((key) => {
+      if (key === "$namespace" || key === "$qualified") return false;
+      const keyLocalName = key.split(":").pop() || key;
+      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
+    });
+    if (matchingKey) {
+      referencedElement = schemaObject[matchingKey];
+    }
+  }
+  if (!referencedElement && allComplexTypes) {
+    const typeLocalName = typeValue.split(":").pop() || typeValue;
+    const matchingKey = Object.keys(allComplexTypes).find((key) => {
+      const keyLocalName = key.split(":").pop() || key;
+      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
+    });
+    if (matchingKey) {
+      referencedElement = allComplexTypes[matchingKey];
+    }
+  }
+  return referencedElement;
+}
+function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
+  let nestedReferencedElement = schemaObject?.[nestedTypeValue];
+  if (!nestedReferencedElement && allComplexTypes) {
+    nestedReferencedElement = allComplexTypes[nestedTypeValue];
+  }
+  if (!nestedReferencedElement) {
+    const nestedTypeLocalName = nestedTypeValue.split(":").pop() || nestedTypeValue;
+    if (schemaObject) {
+      const nestedMatchingKey = Object.keys(schemaObject).find((key) => {
+        if (key === "$namespace" || key === "$qualified") return false;
+        const keyLocalName = key.split(":").pop() || key;
+        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
+      });
+      if (nestedMatchingKey) {
+        nestedReferencedElement = schemaObject[nestedMatchingKey];
+      }
+    }
+    if (!nestedReferencedElement && allComplexTypes) {
+      const nestedMatchingKey = Object.keys(allComplexTypes).find((key) => {
+        const keyLocalName = key.split(":").pop() || key;
+        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
+      });
+      if (nestedMatchingKey) {
+        nestedReferencedElement = allComplexTypes[nestedMatchingKey];
+      }
+    }
+  }
+  return nestedReferencedElement;
+}
+
+// src/codegen/xml-generator/xml-property.ts
+function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping, schemaObject, allComplexTypes, tagUsageCollector) {
+  const namespacePrefix = getNamespacePrefix(
+    namespacesTypeMapping,
+    baseNamespacePrefix,
+    key,
+    parentKey,
+    elementObject,
+    prefixesMapping
+  );
+  const tagLocalName = extractLocalName(key);
+  const tagCamelCase = toCamelCase2(tagLocalName);
+  const isQualified = shouldHavePrefix(elementObject);
+  const openTag = isQualified ? `<${namespacePrefix}.${tagLocalName}>` : `<${tagLocalName}>`;
+  const closeTag = isQualified ? `</${namespacePrefix}.${tagLocalName}>` : `</${tagLocalName}>`;
+  if (tagUsageCollector && isQualified) {
+    tagUsageCollector.tagToPrefix.set(tagLocalName, namespacePrefix);
+    if (prefixesMapping && prefixesMapping[namespacePrefix]) {
+      tagUsageCollector.prefixToNamespace.set(namespacePrefix, prefixesMapping[namespacePrefix]);
+    }
+  }
+  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 referencedType = elementObject.type;
+    const referencedElement = resolveReferencedType(referencedType, schemaObject, allComplexTypes);
+    if (referencedElement && typeof referencedElement === "object") {
+      let referencedElementNamespace = referencedElement.$namespace;
+      if (typeof referencedElementNamespace !== "string") {
+        const typeLocalName = referencedType.split(":").pop() || referencedType;
+        let foundKey;
+        if (schemaObject) {
+          foundKey = Object.keys(schemaObject).find((k) => {
+            if (k === "$namespace" || k === "$qualified") return false;
+            const kLocalName = k.split(":").pop() || k;
+            return kLocalName === typeLocalName;
+          });
+          if (foundKey && foundKey.includes(":")) {
+            const [nsUri] = foundKey.split(":");
+            referencedElementNamespace = nsUri;
+          }
+        }
+        if (!foundKey && allComplexTypes) {
+          foundKey = Object.keys(allComplexTypes).find((k) => {
+            const kLocalName = k.split(":").pop() || k;
+            return kLocalName === typeLocalName;
+          });
+          if (foundKey && foundKey.includes(":")) {
+            const [nsUri] = foundKey.split(":");
+            referencedElementNamespace = nsUri;
+          }
+        }
+      }
+      let wrapperNamespacePrefix = namespacePrefix;
+      if (typeof referencedElementNamespace === "string") {
+        if (prefixesMapping) {
+          for (const [prefix, uri] of Object.entries(prefixesMapping)) {
+            if (uri === referencedElementNamespace) {
+              wrapperNamespacePrefix = prefix;
+              break;
+            }
+          }
+        } else {
+          wrapperNamespacePrefix = getNamespacePrefix(
+            namespacesTypeMapping,
+            baseNamespacePrefix,
+            key,
+            parentKey,
+            { $namespace: referencedElementNamespace },
+            prefixesMapping
+          );
+        }
+      }
+      const wrapperIsQualified = referencedElement.$qualified !== false;
+      const wrapperOpenTag = wrapperIsQualified ? `<${wrapperNamespacePrefix}.${tagLocalName}>` : `<${tagLocalName}>`;
+      const wrapperCloseTag = wrapperIsQualified ? `</${wrapperNamespacePrefix}.${tagLocalName}>` : `</${tagLocalName}>`;
+      if (tagUsageCollector && wrapperIsQualified) {
+        tagUsageCollector.tagToPrefix.set(tagLocalName, wrapperNamespacePrefix);
+        if (prefixesMapping && prefixesMapping[wrapperNamespacePrefix]) {
+          tagUsageCollector.prefixToNamespace.set(wrapperNamespacePrefix, prefixesMapping[wrapperNamespacePrefix]);
+        }
+      }
+      let finalReferencedElement = referencedElement;
+      if ("type" in referencedElement && typeof referencedElement.type === "string") {
+        const nestedReferencedElement = resolveNestedType(referencedElement.type, schemaObject, allComplexTypes);
+        if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
+          finalReferencedElement = nestedReferencedElement;
+        }
+      }
+      if ("type" in finalReferencedElement && typeof finalReferencedElement.type === "object" && finalReferencedElement.type !== null) {
+        const keys = getFilteredKeys(finalReferencedElement.type);
+        if (keys.length > 0) {
+          let parentPropertyPath = "";
+          if (propertyPath === tagCamelCase) {
+            parentPropertyPath = "";
+          } else if (propertyPath.endsWith(`.${tagCamelCase}`)) {
+            parentPropertyPath = propertyPath.slice(0, -(tagCamelCase.length + 1));
+          } else {
+            parentPropertyPath = propertyPath;
+          }
+          const nestedProperties = keys.map((elementKey) => {
+            const nestedElement = finalReferencedElement.type[elementKey];
+            if (typeof nestedElement === "object" && nestedElement !== null) {
+              const nestedKeyLocalName = extractLocalName(elementKey);
+              const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+              const nestedPropertyPath = parentPropertyPath ? `${parentPropertyPath}.${nestedKeyCamelCase}` : nestedKeyCamelCase;
+              return generateXmlPropertyCode(
+                namespacesTypeMapping,
+                baseNamespacePrefix,
+                elementKey,
+                nestedElement,
+                key,
+                nestedPropertyPath,
+                isQualified,
+                prefixesMapping,
+                schemaObject,
+                allComplexTypes,
+                tagUsageCollector
+              );
+            }
+            return "";
+          }).filter(Boolean).join("\n");
+          return `${wrapperOpenTag}
+    ${nestedProperties}
+    ${wrapperCloseTag}`;
+        }
+      }
+      const referencedKeys = getFilteredKeys(finalReferencedElement);
+      if (referencedKeys.length > 0) {
+        let parentPropertyPath = "";
+        if (propertyPath === tagCamelCase) {
+          parentPropertyPath = "";
+        } else if (propertyPath.endsWith(`.${tagCamelCase}`)) {
+          parentPropertyPath = propertyPath.slice(0, -(tagCamelCase.length + 1));
+        } else {
+          parentPropertyPath = propertyPath;
+        }
+        const nestedProperties = referencedKeys.map((elementKey) => {
+          const nestedElement = finalReferencedElement[elementKey];
+          if (typeof nestedElement === "object" && nestedElement !== null) {
+            const nestedKeyLocalName = extractLocalName(elementKey);
+            const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+            const nestedPropertyPath = parentPropertyPath ? `${parentPropertyPath}.${nestedKeyCamelCase}` : nestedKeyCamelCase;
+            return generateXmlPropertyCode(
+              namespacesTypeMapping,
+              baseNamespacePrefix,
+              elementKey,
+              nestedElement,
+              key,
+              nestedPropertyPath,
+              isQualified,
+              prefixesMapping,
+              schemaObject,
+              allComplexTypes,
+              tagUsageCollector
+            );
+          }
+          return "";
+        }).filter(Boolean).join("\n");
+        return `${wrapperOpenTag}
+    ${nestedProperties}
+    ${wrapperCloseTag}`;
+      }
+    }
+  }
+  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "object") {
+    const keys = getFilteredKeys(elementObject.type);
+    if (isArray2) {
+      const nestedProperties = keys.map((elementKey) => {
+        const nestedElement = elementObject.type[elementKey];
+        if (typeof nestedElement === "object" && nestedElement !== null) {
+          const nestedIsArray = typeof nestedElement === "object" && nestedElement !== null && "maxOccurs" in nestedElement && nestedElement.maxOccurs !== void 0 && nestedElement.maxOccurs !== "1" && nestedElement.maxOccurs !== DEFAULT_OCCURS;
+          if (nestedIsArray || typeof nestedElement === "object" && nestedElement !== null && typeof nestedElement.type === "object") {
+            return generateXmlPropertyCode(
+              namespacesTypeMapping,
+              baseNamespacePrefix,
+              elementKey,
+              nestedElement,
+              key,
+              "item",
+              // Usar 'item' directamente en lugar de la ruta completa con índice
+              isQualified,
+              prefixesMapping,
+              schemaObject,
+              allComplexTypes
+            );
+          } else {
+            const nestedTagLocalName = extractLocalName(elementKey);
+            const nestedTagCamelCase = toCamelCase2(nestedTagLocalName);
+            const nestedIsQualified = shouldHavePrefix(nestedElement);
+            if (nestedIsQualified) {
+              const nestedNamespacePrefix = getNamespacePrefix(
+                namespacesTypeMapping,
+                baseNamespacePrefix,
+                elementKey,
+                key,
+                nestedElement,
+                prefixesMapping
+              );
+              return `<${nestedNamespacePrefix}.${nestedTagLocalName}>{item.${nestedTagCamelCase}}</${nestedNamespacePrefix}.${nestedTagLocalName}>`;
+            } else {
+              return `<${nestedTagLocalName}>{item.${nestedTagCamelCase}}</${nestedTagLocalName}>`;
+            }
+          }
+        }
+        return "";
+      }).filter(Boolean).join("\n");
+      const mapPath = propertyPath || currentPropertyPath;
+      return `{props.${mapPath}.map((item, i) => (
+    ${openTag}
+    ${nestedProperties}
+    ${closeTag}
+))}`;
+    } else {
+      const nestedProperties = keys.map((elementKey) => {
+        const nestedElement = elementObject.type[elementKey];
+        if (typeof nestedElement === "object" && nestedElement !== null) {
+          return generateXmlPropertyCode(
+            namespacesTypeMapping,
+            baseNamespacePrefix,
+            elementKey,
+            nestedElement,
+            key,
+            currentPropertyPath,
+            // Mantener el propertyPath completo (incluye propsInterfaceName si existe)
+            isQualified,
+            prefixesMapping,
+            schemaObject,
+            allComplexTypes,
+            tagUsageCollector
+          );
+        }
+        return "";
+      }).filter(Boolean).join("\n");
+      return `${openTag}
+    ${nestedProperties}
+    ${closeTag}`;
+    }
+  }
+  return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
+}
+
+// src/codegen/xml-generator/xml-body.ts
+function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping, tagUsageCollector) {
+  const keys = getFilteredKeys(baseTypeObject);
+  const baseTypeLocalName = extractLocalName(baseTypeName);
+  if (keys.length === 1) {
+    const singleKey = keys[0];
+    const element = baseTypeObject[singleKey];
+    if (typeof element === "object" && element !== null && "type" in element) {
+      const typeValue = element.type;
+      if (typeof typeValue === "object" && typeValue !== null) {
+        const typeKeys = getFilteredKeys(typeValue);
+        if (typeKeys.length > 0) {
+          return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, typeValue, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping, tagUsageCollector);
+        }
+      }
+    }
+  }
+  const properties = keys.map((key) => {
+    const element = baseTypeObject[key];
+    if (typeof element === "object" && element !== null) {
+      const keyLocalName = extractLocalName(key);
+      const keyCamelCase = toCamelCase2(keyLocalName);
+      const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
+      return generateXmlPropertyCode(
+        namespacesTypeMapping,
+        baseNamespacePrefix,
+        key,
+        element,
+        null,
+        propertyPath,
+        true,
+        // El padre (root element) siempre es qualified
+        prefixesMapping,
+        schemaObject,
+        allComplexTypes,
+        tagUsageCollector
+      );
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+  if (tagUsageCollector) {
+    tagUsageCollector.tagToPrefix.set(baseTypeLocalName, baseNamespacePrefix);
+    if (prefixesMapping && prefixesMapping[baseNamespacePrefix]) {
+      tagUsageCollector.prefixToNamespace.set(baseNamespacePrefix, prefixesMapping[baseNamespacePrefix]);
+    }
+  }
+  return `<${baseNamespacePrefix}.${baseTypeLocalName}>
+    ${properties}
+</${baseNamespacePrefix}.${baseTypeLocalName}>`;
+}
+
 // src/codegen/namespaces.ts
 function extractAllNamespaceMappings(baseTypeName, baseTypeObject, schemaObject, allComplexTypes) {
   const tagsMapping = {};
@@ -23987,43 +24408,67 @@ function extractAllNamespaceMappings(baseTypeName, baseTypeObject, schemaObject,
       tagsMapping[finalPrefix] = [];
     }
   }
-  for (const [nsUri, tags] of xmlBodyResult.tagsByNamespace) {
-    let finalPrefix;
-    for (const [p, u] of Object.entries(prefixesMapping)) {
-      if (u === nsUri) {
-        finalPrefix = p;
-        break;
-      }
+  const tagUsageCollector = {
+    tagToPrefix: /* @__PURE__ */ new Map(),
+    prefixToNamespace: /* @__PURE__ */ new Map()
+  };
+  generateXmlBodyCode(
+    baseNamespacePrefix,
+    typesMapping,
+    baseTypeName,
+    baseTypeObject,
+    void 0,
+    // propsInterfaceName
+    schemaObject,
+    allComplexTypes,
+    prefixesMapping,
+    tagUsageCollector
+  );
+  const newTagsMapping = {};
+  const prefixToTags = /* @__PURE__ */ new Map();
+  const tagToPrefixMap = /* @__PURE__ */ new Map();
+  for (const [tag, prefix] of tagUsageCollector.tagToPrefix) {
+    if (tag.startsWith("_")) {
+      continue;
     }
-    if (!finalPrefix) {
-      finalPrefix = extractNamespacePrefix(nsUri, existingPrefixesSet);
-      existingPrefixesSet.add(finalPrefix);
+    if (tagToPrefixMap.has(tag)) {
+      const existingPrefix = tagToPrefixMap.get(tag);
+      if (existingPrefix !== prefix) {
+        debugContext("extractAllNamespaceMappings", `Tag "${tag}" encontrado en m\xFAltiples prefijos: "${existingPrefix}" y "${prefix}", usando "${prefix}"`);
+      }
     }
-    if (!tagsMapping[finalPrefix]) {
-      tagsMapping[finalPrefix] = [];
+    tagToPrefixMap.set(tag, prefix);
+    if (!prefixToTags.has(prefix)) {
+      prefixToTags.set(prefix, /* @__PURE__ */ new Set());
     }
-    const existingTags = new Set(tagsMapping[finalPrefix] || []);
-    for (const tag of tags) {
-      if (!existingTags.has(tag)) {
-        tagsMapping[finalPrefix].push(tag);
-        existingTags.add(tag);
+    prefixToTags.get(prefix).add(tag);
+  }
+  const allTagsAdded = /* @__PURE__ */ new Set();
+  for (const [prefix, tagsSet] of prefixToTags) {
+    const tagsArray = Array.from(tagsSet).filter((tag) => {
+      if (allTagsAdded.has(tag)) {
+        return false;
       }
+      allTagsAdded.add(tag);
+      return true;
+    });
+    if (tagsArray.length > 0) {
+      newTagsMapping[prefix] = tagsArray;
+      debugContext("extractAllNamespaceMappings", `Agregando ${tagsArray.length} tag(s) al namespace "${prefix}" basado en uso real en XML: ${tagsArray.join(", ")}`);
     }
-    debugContext("extractAllNamespaceMappings", `Agregando ${tags.length} tag(s) al namespace "${finalPrefix}" (${nsUri})`);
   }
-  if (xmlBodyResult.tags.length > 0) {
-    if (tagsMapping[baseNamespacePrefix] === void 0) {
-      tagsMapping[baseNamespacePrefix] = [];
-      prefixesMapping[baseNamespacePrefix] = baseNamespace;
+  for (const [prefix, namespaceUri] of tagUsageCollector.prefixToNamespace) {
+    if (!prefixesMapping[prefix]) {
+      prefixesMapping[prefix] = namespaceUri;
+      debugContext("extractAllNamespaceMappings", `Registrando namespace para prefijo "${prefix}": "${namespaceUri}"`);
     }
-    const existingTags = new Set(tagsMapping[baseNamespacePrefix] || []);
-    for (const tag of xmlBodyResult.tags) {
-      if (!existingTags.has(tag)) {
-        tagsMapping[baseNamespacePrefix].push(tag);
-        existingTags.add(tag);
-      }
+  }
+  for (const prefix of Object.keys(prefixesMapping)) {
+    if (!newTagsMapping[prefix]) {
+      newTagsMapping[prefix] = [];
     }
   }
+  Object.assign(tagsMapping, newTagsMapping);
   return {
     tagsMapping,
     prefixesMapping,
@@ -24086,208 +24531,6 @@ function shouldHavePrefix(elementObject) {
   return false;
 }
 
-// src/codegen/xml-generator/xml-property.ts
-function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping) {
-  const namespacePrefix = getNamespacePrefix(
-    namespacesTypeMapping,
-    baseNamespacePrefix,
-    key,
-    parentKey,
-    elementObject,
-    prefixesMapping
-  );
-  const tagLocalName = extractLocalName(key);
-  const tagCamelCase = toCamelCase2(tagLocalName);
-  const isQualified = shouldHavePrefix(elementObject);
-  const openTag = isQualified ? `<${namespacePrefix}.${tagLocalName}>` : `<${tagLocalName}>`;
-  const closeTag = isQualified ? `</${namespacePrefix}.${tagLocalName}>` : `</${tagLocalName}>`;
-  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 === "object") {
-    const keys = getFilteredKeys(elementObject.type);
-    if (isArray2) {
-      const nestedProperties = keys.map((elementKey) => {
-        const nestedElement = elementObject.type[elementKey];
-        if (typeof nestedElement === "object" && nestedElement !== null) {
-          const nestedIsArray = typeof nestedElement === "object" && nestedElement !== null && "maxOccurs" in nestedElement && nestedElement.maxOccurs !== void 0 && nestedElement.maxOccurs !== "1" && nestedElement.maxOccurs !== DEFAULT_OCCURS;
-          if (nestedIsArray || typeof nestedElement === "object" && nestedElement !== null && typeof nestedElement.type === "object") {
-            return generateXmlPropertyCode(
-              namespacesTypeMapping,
-              baseNamespacePrefix,
-              elementKey,
-              nestedElement,
-              key,
-              "item",
-              // Usar 'item' directamente en lugar de la ruta completa con índice
-              isQualified
-            );
-          } else {
-            const nestedTagLocalName = extractLocalName(elementKey);
-            const nestedTagCamelCase = toCamelCase2(nestedTagLocalName);
-            const nestedIsQualified = shouldHavePrefix(nestedElement);
-            if (nestedIsQualified) {
-              const nestedNamespacePrefix = getNamespacePrefix(
-                namespacesTypeMapping,
-                baseNamespacePrefix,
-                elementKey,
-                key,
-                nestedElement,
-                prefixesMapping
-              );
-              return `<${nestedNamespacePrefix}.${nestedTagLocalName}>{item.${nestedTagCamelCase}}</${nestedNamespacePrefix}.${nestedTagLocalName}>`;
-            } else {
-              return `<${nestedTagLocalName}>{item.${nestedTagCamelCase}}</${nestedTagLocalName}>`;
-            }
-          }
-        }
-        return "";
-      }).filter(Boolean).join("\n");
-      const mapPath = propertyPath || currentPropertyPath;
-      return `{props.${mapPath}.map((item, i) => (
-    ${openTag}
-    ${nestedProperties}
-    ${closeTag}
-))}`;
-    } else {
-      const nestedProperties = keys.map((elementKey) => {
-        const nestedElement = elementObject.type[elementKey];
-        if (typeof nestedElement === "object" && nestedElement !== null) {
-          return generateXmlPropertyCode(
-            namespacesTypeMapping,
-            baseNamespacePrefix,
-            elementKey,
-            nestedElement,
-            key,
-            currentPropertyPath,
-            // Mantener el propertyPath completo (incluye propsInterfaceName si existe)
-            isQualified,
-            prefixesMapping
-          );
-        }
-        return "";
-      }).filter(Boolean).join("\n");
-      return `${openTag}
-    ${nestedProperties}
-    ${closeTag}`;
-    }
-  }
-  return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
-}
-
-// src/codegen/xml-generator/type-resolution.ts
-function resolveReferencedType(typeValue, schemaObject, allComplexTypes) {
-  let referencedElement = schemaObject?.[typeValue];
-  if (!referencedElement && allComplexTypes) {
-    referencedElement = allComplexTypes[typeValue];
-  }
-  if (!referencedElement && schemaObject) {
-    const typeLocalName = typeValue.split(":").pop() || typeValue;
-    const matchingKey = Object.keys(schemaObject).find((key) => {
-      if (key === "$namespace" || key === "$qualified") return false;
-      const keyLocalName = key.split(":").pop() || key;
-      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
-    });
-    if (matchingKey) {
-      referencedElement = schemaObject[matchingKey];
-    }
-  }
-  if (!referencedElement && allComplexTypes) {
-    const typeLocalName = typeValue.split(":").pop() || typeValue;
-    const matchingKey = Object.keys(allComplexTypes).find((key) => {
-      const keyLocalName = key.split(":").pop() || key;
-      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
-    });
-    if (matchingKey) {
-      referencedElement = allComplexTypes[matchingKey];
-    }
-  }
-  return referencedElement;
-}
-function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
-  let nestedReferencedElement = schemaObject?.[nestedTypeValue];
-  if (!nestedReferencedElement && allComplexTypes) {
-    nestedReferencedElement = allComplexTypes[nestedTypeValue];
-  }
-  if (!nestedReferencedElement) {
-    const nestedTypeLocalName = nestedTypeValue.split(":").pop() || nestedTypeValue;
-    if (schemaObject) {
-      const nestedMatchingKey = Object.keys(schemaObject).find((key) => {
-        if (key === "$namespace" || key === "$qualified") return false;
-        const keyLocalName = key.split(":").pop() || key;
-        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
-      });
-      if (nestedMatchingKey) {
-        nestedReferencedElement = schemaObject[nestedMatchingKey];
-      }
-    }
-    if (!nestedReferencedElement && allComplexTypes) {
-      const nestedMatchingKey = Object.keys(allComplexTypes).find((key) => {
-        const keyLocalName = key.split(":").pop() || key;
-        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
-      });
-      if (nestedMatchingKey) {
-        nestedReferencedElement = allComplexTypes[nestedMatchingKey];
-      }
-    }
-  }
-  return nestedReferencedElement;
-}
-
-// src/codegen/xml-generator/xml-body.ts
-function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping) {
-  const keys = getFilteredKeys(baseTypeObject);
-  const baseTypeLocalName = extractLocalName(baseTypeName);
-  if (keys.length === 1) {
-    const singleKey = keys[0];
-    const element = baseTypeObject[singleKey];
-    if (typeof element === "object" && element !== null && "type" in element) {
-      const typeValue = element.type;
-      if (typeof typeValue === "string" && (schemaObject || allComplexTypes)) {
-        const referencedElement = resolveReferencedType(typeValue, schemaObject, allComplexTypes);
-        if (referencedElement && typeof referencedElement === "object") {
-          if ("type" in referencedElement && typeof referencedElement.type === "string") {
-            const nestedTypeValue = referencedElement.type;
-            const nestedReferencedElement = resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes);
-            if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
-              return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, nestedReferencedElement, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping);
-            }
-          }
-          return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, referencedElement, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping);
-        }
-      }
-      if (typeof typeValue === "object" && typeValue !== null) {
-        const typeKeys = getFilteredKeys(typeValue);
-        if (typeKeys.length > 0) {
-          return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, typeValue, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping);
-        }
-      }
-    }
-  }
-  const properties = keys.map((key) => {
-    const element = baseTypeObject[key];
-    if (typeof element === "object" && element !== null) {
-      const keyLocalName = extractLocalName(key);
-      const keyCamelCase = toCamelCase2(keyLocalName);
-      const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
-      return generateXmlPropertyCode(
-        namespacesTypeMapping,
-        baseNamespacePrefix,
-        key,
-        element,
-        null,
-        propertyPath,
-        true,
-        // El padre (root element) siempre es qualified
-        prefixesMapping
-      );
-    }
-    return "";
-  }).filter(Boolean).join("\n");
-  return `<${baseNamespacePrefix}.${baseTypeLocalName}>
-    ${properties}
-</${baseNamespacePrefix}.${baseTypeLocalName}>`;
-}
-
 // src/codegen/data-preparer/simple-types.ts
 function prepareSimpleTypesData(typeObject, xmlSchemaUri) {
   return Object.keys(typeObject).filter((key) => {
@@ -24553,21 +24796,42 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
             }
             if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
               debugContext("preparePropsInterfaceData", `Expandiendo contenido del tipo anidado`);
-              return preparePropsInterfaceData(typeName, nestedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+              const cleanedNestedElement = { ...nestedReferencedElement };
+              Object.keys(cleanedNestedElement).forEach((key) => {
+                if (key.startsWith("_")) {
+                  delete cleanedNestedElement[key];
+                }
+              });
+              return preparePropsInterfaceData(typeName, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
             }
           }
-          return preparePropsInterfaceData(typeName, referencedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+          const cleanedReferencedElement = { ...referencedElement };
+          Object.keys(cleanedReferencedElement).forEach((key) => {
+            if (key.startsWith("_")) {
+              delete cleanedReferencedElement[key];
+            }
+          });
+          return preparePropsInterfaceData(typeName, cleanedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
         }
       }
       if (typeof typeValue === "object" && typeValue !== null) {
-        const typeKeys = getFilteredKeys(typeValue);
+        const cleanedTypeValue = { ...typeValue };
+        Object.keys(cleanedTypeValue).forEach((key) => {
+          if (key.startsWith("_")) {
+            delete cleanedTypeValue[key];
+          }
+        });
+        const typeKeys = getFilteredKeys(cleanedTypeValue);
         if (typeKeys.length > 0) {
-          return preparePropsInterfaceData(typeName, typeValue, allTypesForInterfaces, schemaObject, allComplexTypes);
+          return preparePropsInterfaceData(typeName, cleanedTypeValue, allTypesForInterfaces, schemaObject, allComplexTypes);
         }
       }
     }
   }
-  const properties = keys.map((key) => {
+  const properties = keys.filter((key) => {
+    const localName = extractLocalName(key);
+    return !localName.startsWith("_");
+  }).map((key) => {
     const localName = extractLocalName(key);
     const element = typeObject[key];
     let propertyType;

package/package.json

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